diff --git a/.gitattributes b/.gitattributes
index a8a7839..6313b56 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,2 +1 @@
 * text=auto eol=lf
-install.sh text eol=lf
diff --git a/Cargo.toml b/Cargo.toml
index 8b1e61a..99ff111 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "texforge"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 rust-version = "1.75"
 description = "Self-contained LaTeX to PDF compiler CLI"
@@ -31,11 +31,16 @@ walkdir = "2.5"
 dirs = "6.0"
 
 # HTTP client (template downloads)
-reqwest = { version = "0.13", features = ["blocking"] }
+reqwest = { version = "0.13", features = ["blocking", "json"] }
 
-# Archive extraction (GitHub tarballs)
+# Archive extraction (GitHub tarballs + tectonic zip on Windows)
 flate2 = "1.1"
 tar = "0.4"
+zip = { version = "2", default-features = false, features = ["deflate"] }
+
+# Mermaid diagram rendering
+mermaid-rs-renderer = { version = "0.2", default-features = false }
+resvg = "0.46"
 
 [dev-dependencies]
 tempfile = "3.8"
diff --git a/README.md b/README.md
index 06c9a94..db46e88 100644
--- a/README.md
+++ b/README.md
@@ -13,11 +13,19 @@ Self-contained LaTeX to PDF compiler — one curl, zero friction. No TeX Live, n
 
 ### Quick install (recommended)
 
+**Linux / macOS:**
+
 ```bash
 curl -fsSL https://raw.githubusercontent.com/JheisonMB/texforge/main/install.sh | sh
 ```
 
-This downloads and installs both `texforge` and `tectonic` (the LaTeX engine). Nothing else needed. No Rust toolchain required.
+**Windows (PowerShell):**
+
+```powershell
+irm https://raw.githubusercontent.com/JheisonMB/texforge/main/install.ps1 | iex
+```
+
+This downloads and installs `texforge`. No Rust toolchain required. Tectonic (the LaTeX engine) is installed automatically on first build.
 
 You can customize the install:
 
@@ -29,17 +37,18 @@ VERSION=0.1.0 curl -fsSL https://raw.githubusercontent.com/JheisonMB/texforge/ma
 INSTALL_DIR=/usr/local/bin curl -fsSL https://raw.githubusercontent.com/JheisonMB/texforge/main/install.sh | sh
 ```
 
+```powershell
+# Pin a specific version (PowerShell)
+$env:VERSION="0.1.0"; irm https://raw.githubusercontent.com/JheisonMB/texforge/main/install.ps1 | iex
+```
+
 ### Via cargo
 
 ```bash
 cargo install texforge
 ```
 
-**Note:** This only installs texforge. You also need tectonic for compilation:
-
-```bash
-cargo install tectonic
-```
+Tectonic (the LaTeX engine) is installed automatically on first build. No extra steps needed.
 
 Available on [crates.io](https://crates.io/crates/texforge).
 
@@ -72,6 +81,9 @@ texforge fmt
 
 # Build to PDF
 texforge build
+
+# Remove build artifacts
+texforge clean
 ```
 
 ---
@@ -82,11 +94,14 @@ texforge build
 |---|---|
 | `texforge new <name>` | Create new project from template |
 | `texforge new <name> -t <template>` | Create with specific template |
+| `texforge init` | Initialize texforge in an existing LaTeX project |
 | `texforge build` | Compile to PDF |
+| `texforge clean` | Remove build artifacts |
 | `texforge fmt` | Format .tex files |
 | `texforge fmt --check` | Check formatting without modifying |
 | `texforge check` | Lint without compiling |
 | `texforge template list` | List installed templates |
+| `texforge template list --all` | List installed + available in registry |
 | `texforge template add <name>` | Download template from registry |
 | `texforge template remove <name>` | Remove installed template |
 | `texforge template validate <name>` | Verify template compatibility |
@@ -197,7 +212,7 @@ texforge fmt --check   # check without modifying (CI-friendly)
 ```
 ~/.texforge/
   bin/
-    tectonic            # LaTeX engine (installed by install.sh)
+    tectonic            # LaTeX engine (auto-installed on first build)
   templates/
     general/            # Cached templates
     apa-general/
@@ -231,10 +246,6 @@ texforge fmt --check   # check without modifying (CI-friendly)
 
 ---
 
-## Roadmap
-
-See [texforge-spec.md](texforge-spec.md) for the complete specification and roadmap.
-
 ---
 
 ## License
diff --git a/install.ps1 b/install.ps1
new file mode 100644
index 0000000..79e96fa
--- /dev/null
+++ b/install.ps1
@@ -0,0 +1,77 @@
+# install.ps1 — download and install texforge on Windows
+# tectonic (LaTeX engine) is installed automatically on first build
+# Usage: irm https://raw.githubusercontent.com/JheisonMB/texforge/main/install.ps1 | iex
+#
+# Options (set as env vars before running):
+#   $env:VERSION    = "0.1.0"           # pin a specific version
+#   $env:INSTALL_DIR = "C:\my\bin"      # custom install directory
+
+$ErrorActionPreference = "Stop"
+
+$Repo       = "JheisonMB/texforge"
+$Binary     = "texforge.exe"
+$Target     = "x86_64-pc-windows-msvc"
+$InstallDir = if ($env:INSTALL_DIR) { $env:INSTALL_DIR } else { "$env:USERPROFILE\.local\bin" }
+
+function Info($label, $msg) {
+    Write-Host "  " -NoNewline
+    Write-Host $label -ForegroundColor Blue -NoNewline
+    Write-Host " $msg"
+}
+
+function Fail($msg) {
+    Write-Host "  error: $msg" -ForegroundColor Red
+    exit 1
+}
+
+# --- resolve version ---
+if ($env:VERSION) {
+    $Tag = "v$($env:VERSION)"
+    Info "version" "$Tag (pinned)"
+} else {
+    $latest = Invoke-RestMethod "https://api.github.com/repos/$Repo/releases/latest"
+    $Tag = $latest.tag_name
+    if (-not $Tag) { Fail "Could not resolve latest release tag" }
+    Info "version" "$Tag (latest)"
+}
+
+# --- download ---
+$Archive = "texforge-$Tag-$Target.zip"
+$Url     = "https://github.com/$Repo/releases/download/$Tag/$Archive"
+$Tmp     = Join-Path $env:TEMP "texforge-install"
+New-Item -ItemType Directory -Force -Path $Tmp | Out-Null
+
+Info "download" $Url
+try {
+    Invoke-WebRequest -Uri $Url -OutFile "$Tmp\$Archive" -UseBasicParsing
+} catch {
+    Fail "Download failed: $_`nURL: $Url"
+}
+
+# --- extract ---
+Expand-Archive -Path "$Tmp\$Archive" -DestinationPath $Tmp -Force
+$extracted = Join-Path $Tmp $Binary
+if (-not (Test-Path $extracted)) { Fail "Binary not found in archive" }
+
+# --- install ---
+New-Item -ItemType Directory -Force -Path $InstallDir | Out-Null
+Copy-Item $extracted "$InstallDir\$Binary" -Force
+Info "installed" "$InstallDir\$Binary"
+
+# --- ensure PATH ---
+$userPath = [Environment]::GetEnvironmentVariable("PATH", "User")
+if ($userPath -notlike "*$InstallDir*") {
+    [Environment]::SetEnvironmentVariable("PATH", "$InstallDir;$userPath", "User")
+    $env:PATH = "$InstallDir;$env:PATH"
+    Info "updated" "User PATH"
+}
+
+# --- cleanup ---
+Remove-Item $Tmp -Recurse -Force
+
+# --- verify ---
+$ver = & "$InstallDir\$Binary" --version 2>$null
+Info "done" $ver
+Write-Host ""
+Info "ready" "Run 'texforge new my-project' to get started!"
+Info "note"  "tectonic (LaTeX engine) will be installed automatically on first build"
diff --git a/install.sh b/install.sh
index 7b92314..cefa3f4 100755
--- a/install.sh
+++ b/install.sh
@@ -1,13 +1,12 @@
 #!/bin/sh
-# install.sh — download and install texforge + tectonic from GitHub Releases
+# install.sh — download and install texforge from GitHub Releases
+# tectonic (LaTeX engine) is installed automatically on first build
 # Usage: curl -fsSL https://raw.githubusercontent.com/JheisonMB/texforge/main/install.sh | sh
 set -eu
 
 REPO="JheisonMB/texforge"
 BINARY="texforge"
-TECTONIC_VERSION="0.15.0+20251006"
 INSTALL_DIR="${INSTALL_DIR:-$HOME/.local/bin}"
-TEXFORGE_DIR="$HOME/.texforge/bin"
 
 info() { printf '  \033[1;34m%s\033[0m %s\n' "$1" "$2"; }
 error() { printf '  \033[1;31merror:\033[0m %s\n' "$1" >&2; exit 1; }
@@ -35,34 +34,7 @@ TMPDIR="$(mktemp -d)"
 trap 'rm -rf "$TMPDIR"' EXIT
 
 # ============================================================
-# 1. Install tectonic (LaTeX engine)
-# ============================================================
-
-if command -v tectonic >/dev/null 2>&1; then
-  info "tectonic" "already installed ($(tectonic --version 2>/dev/null || echo 'unknown version'))"
-elif [ -x "$TEXFORGE_DIR/tectonic" ]; then
-  info "tectonic" "already installed at $TEXFORGE_DIR/tectonic"
-else
-  info "tectonic" "installing v${TECTONIC_VERSION}..."
-
-  TECTONIC_ARCHIVE="tectonic-${TECTONIC_VERSION}-${TARGET}.tar.gz"
-  TECTONIC_URL="https://github.com/tectonic-typesetting/tectonic/releases/download/continuous/${TECTONIC_ARCHIVE}"
-
-  info "download" "$TECTONIC_URL"
-  HTTP_CODE=$(curl -fSL -w '%{http_code}' -o "$TMPDIR/$TECTONIC_ARCHIVE" "$TECTONIC_URL" 2>/dev/null) || true
-  [ "$HTTP_CODE" = "200" ] || error "Tectonic download failed (HTTP $HTTP_CODE). URL:\n  $TECTONIC_URL"
-
-  tar xzf "$TMPDIR/$TECTONIC_ARCHIVE" -C "$TMPDIR"
-  [ -f "$TMPDIR/tectonic" ] || error "Tectonic binary not found in archive"
-
-  mkdir -p "$TEXFORGE_DIR"
-  mv "$TMPDIR/tectonic" "$TEXFORGE_DIR/tectonic"
-  chmod +x "$TEXFORGE_DIR/tectonic"
-  info "installed" "$TEXFORGE_DIR/tectonic"
-fi
-
-# ============================================================
-# 2. Install texforge
+# 1. Install texforge
 # ============================================================
 
 # --- resolve latest version ---
@@ -94,7 +66,7 @@ chmod +x "$INSTALL_DIR/$BINARY"
 info "installed" "$INSTALL_DIR/$BINARY"
 
 # ============================================================
-# 3. Ensure PATH includes both directories
+# 2. Ensure PATH
 # ============================================================
 
 PATHS_TO_ADD=""
@@ -102,10 +74,6 @@ case ":$PATH:" in
   *":$INSTALL_DIR:"*) ;;
   *) PATHS_TO_ADD="$INSTALL_DIR" ;;
 esac
-case ":$PATH:" in
-  *":$TEXFORGE_DIR:"*) ;;
-  *) PATHS_TO_ADD="$PATHS_TO_ADD $TEXFORGE_DIR" ;;
-esac
 
 if [ -n "$PATHS_TO_ADD" ]; then
   for dir in $PATHS_TO_ADD; do
@@ -125,11 +93,10 @@ if [ -n "$PATHS_TO_ADD" ]; then
 fi
 
 # ============================================================
-# 4. Verify
+# 3. Verify
 # ============================================================
 
 info "done" "$($INSTALL_DIR/$BINARY --version 2>/dev/null || echo "$BINARY installed")"
-TECTONIC_BIN=$(command -v tectonic 2>/dev/null || echo "$TEXFORGE_DIR/tectonic")
-info "tectonic" "$($TECTONIC_BIN --version 2>/dev/null || echo "installed")"
 echo ""
 info "ready" "Run 'texforge new my-project' to get started!"
+info "note"  "tectonic (LaTeX engine) will be installed automatically on first build"
diff --git a/src/cli/mod.rs b/src/cli/mod.rs
index bcba729..50f0bcf 100644
--- a/src/cli/mod.rs
+++ b/src/cli/mod.rs
@@ -15,6 +15,10 @@ pub struct Cli {
 
 #[derive(Subcommand)]
 enum Commands {
+    /// Remove build artifacts
+    Clean,
+    /// Initialize a texforge project in the current directory
+    Init,
     /// Create a new project from a template
     New {
         /// Project name
@@ -43,7 +47,11 @@ enum Commands {
 #[derive(Subcommand)]
 enum TemplateAction {
     /// List available templates
-    List,
+    List {
+        /// Also show templates available in the remote registry
+        #[arg(long)]
+        all: bool,
+    },
     /// Add a template from URL or registry
     Add { source: String },
     /// Remove a template
@@ -55,12 +63,14 @@ enum TemplateAction {
 impl Cli {
     pub fn execute(self) -> Result<()> {
         match self.command {
+            Commands::Clean => commands::clean::execute(),
+            Commands::Init => commands::init::execute(),
             Commands::New { name, template } => commands::new::execute(&name, template.as_deref()),
             Commands::Build => commands::build::execute(),
             Commands::Fmt { check } => commands::fmt::execute(check),
             Commands::Check => commands::check::execute(),
             Commands::Template { action } => match action {
-                TemplateAction::List => commands::template::list(),
+                TemplateAction::List { all } => commands::template::list(all),
                 TemplateAction::Add { source } => commands::template::add(&source),
                 TemplateAction::Remove { name } => commands::template::remove(&name),
                 TemplateAction::Validate { name } => commands::template::validate(&name),
diff --git a/src/commands/build.rs b/src/commands/build.rs
index f8ac2ab..eceea9d 100644
--- a/src/commands/build.rs
+++ b/src/commands/build.rs
@@ -3,6 +3,7 @@
 use anyhow::Result;
 
 use crate::compiler;
+use crate::diagrams;
 use crate::domain::project::Project;
 
 /// Compile project to PDF.
@@ -11,10 +12,18 @@ pub fn execute() -> Result<()> {
 
     println!("Building project: {}", project.config.documento.titulo);
 
-    // Ensure build directory exists
     std::fs::create_dir_all(project.root.join("build"))?;
 
-    compiler::compile(&project.root, &project.config.compilacion.entry)?;
+    // Pre-process embedded diagrams — works on copies in build/, originals untouched
+    diagrams::process(&project.root, &project.config.compilacion.entry)?;
+
+    // Compile from build/ — all assets are mirrored there, diagrams use relative paths
+    let build_dir = project.root.join("build");
+    let entry_filename = std::path::Path::new(&project.config.compilacion.entry)
+        .file_name()
+        .map(|n| n.to_string_lossy().to_string())
+        .unwrap_or(project.config.compilacion.entry.clone());
+    compiler::compile(&build_dir, &entry_filename)?;
 
     let pdf_name = std::path::Path::new(&project.config.compilacion.entry).with_extension("pdf");
     println!("✅ build/{}", pdf_name.display());
diff --git a/src/commands/clean.rs b/src/commands/clean.rs
new file mode 100644
index 0000000..5a6d338
--- /dev/null
+++ b/src/commands/clean.rs
@@ -0,0 +1,20 @@
+//! `texforge clean` command implementation.
+
+use anyhow::Result;
+
+use crate::domain::project::Project;
+
+/// Remove the build/ directory.
+pub fn execute() -> Result<()> {
+    let project = Project::load()?;
+    let build_dir = project.root.join("build");
+
+    if !build_dir.exists() {
+        println!("Nothing to clean.");
+        return Ok(());
+    }
+
+    std::fs::remove_dir_all(&build_dir)?;
+    println!("✅ build/ removed");
+    Ok(())
+}
diff --git a/src/commands/init.rs b/src/commands/init.rs
new file mode 100644
index 0000000..93568d1
--- /dev/null
+++ b/src/commands/init.rs
@@ -0,0 +1,96 @@
+//! `texforge init` command implementation.
+
+use std::path::Path;
+
+use anyhow::Result;
+
+/// Initialize a texforge project in the current directory.
+pub fn execute() -> Result<()> {
+    let root = std::env::current_dir()?;
+
+    if root.join("project.toml").exists() {
+        anyhow::bail!("project.toml already exists in this directory");
+    }
+
+    // Detect entry point: file with \documentclass
+    let entry = detect_entry(&root).unwrap_or_else(|| "main.tex".to_string());
+
+    // Detect bibliography: first .bib file found
+    let bib = detect_bib(&root);
+
+    let bib_line = match &bib {
+        Some(b) => format!("bibliografia = \"{}\"", b),
+        None => "# bibliografia = \"refs.bib\"".to_string(),
+    };
+
+    let project_toml = format!(
+        r#"[documento]
+titulo = "{}"
+autor = "Author"
+template = "general"
+
+[compilacion]
+entry = "{}"
+{}
+"#,
+        root.file_name()
+            .and_then(|n| n.to_str())
+            .unwrap_or("documento"),
+        entry,
+        bib_line,
+    );
+
+    std::fs::write(root.join("project.toml"), &project_toml)?;
+
+    println!("✅ project.toml generated");
+    println!("   entry: {}", entry);
+    if let Some(b) = bib {
+        println!("   bibliography: {}", b);
+    }
+    println!();
+    println!("Edit project.toml to set titulo and autor, then run:");
+    println!("  texforge build");
+
+    Ok(())
+}
+
+/// Find the .tex file that contains \documentclass.
+fn detect_entry(root: &Path) -> Option<String> {
+    for entry in walkdir::WalkDir::new(root)
+        .max_depth(2)
+        .into_iter()
+        .filter_map(|e| e.ok())
+    {
+        let path = entry.path();
+        if path.extension().and_then(|e| e.to_str()) != Some("tex") {
+            continue;
+        }
+        if let Ok(content) = std::fs::read_to_string(path) {
+            if content.contains("\\documentclass") {
+                return path
+                    .strip_prefix(root)
+                    .ok()
+                    .map(|p| p.to_string_lossy().to_string());
+            }
+        }
+    }
+    None
+}
+
+/// Find the first .bib file in the project.
+fn detect_bib(root: &Path) -> Option<String> {
+    for entry in walkdir::WalkDir::new(root)
+        .max_depth(3)
+        .into_iter()
+        .filter_map(|e| e.ok())
+    {
+        let path = entry.path();
+        if path.extension().and_then(|e| e.to_str()) == Some("bib") {
+            return path
+                .strip_prefix(root)
+                .ok()
+                .map(|p| p.to_string_lossy().to_string());
+        }
+    }
+    None
+}
diff --git a/src/commands/mod.rs b/src/commands/mod.rs
index 467bf6d..23f89e6 100644
--- a/src/commands/mod.rs
+++ b/src/commands/mod.rs
@@ -2,6 +2,8 @@
 
 pub mod build;
 pub mod check;
+pub mod clean;
 pub mod fmt;
+pub mod init;
 pub mod new;
 pub mod template;
diff --git a/src/commands/new.rs b/src/commands/new.rs
index 111fb7a..70143f7 100644
--- a/src/commands/new.rs
+++ b/src/commands/new.rs
@@ -64,7 +64,7 @@ bibliografia = "bib/references.bib"
 }
 
 /// Validate project name: no empty, no path traversal, no special chars.
-fn validate_project_name(name: &str) -> Result<()> {
+pub(crate) fn validate_project_name(name: &str) -> Result<()> {
     if name.is_empty() {
         anyhow::bail!("Project name cannot be empty");
     }
@@ -106,3 +106,33 @@ fn validate_project_name(name: &str) -> Result<()> {
 
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn empty_name_is_error() {
+        assert!(validate_project_name("").is_err());
+    }
+
+    #[test]
+    fn name_with_spaces_is_error() {
+        assert!(validate_project_name("my project").is_err());
+    }
+
+    #[test]
+    fn name_with_dotdot_is_error() {
+        assert!(validate_project_name("../evil").is_err());
+    }
+
+    #[test]
+    fn name_with_slash_is_error() {
+        assert!(validate_project_name("a/b").is_err());
+    }
+
+    #[test]
+    fn valid_name_is_ok() {
+        assert!(validate_project_name("mi-tesis").is_ok());
+    }
+}
diff --git a/src/commands/template.rs b/src/commands/template.rs
index ee0ed6f..0f3c06b 100644
--- a/src/commands/template.rs
+++ b/src/commands/template.rs
@@ -5,17 +5,42 @@ use anyhow::Result;
 use crate::templates;
 
 /// List available templates.
-pub fn list() -> Result<()> {
+pub fn list(all: bool) -> Result<()> {
     let cached = templates::list_cached()?;
-    if cached.is_empty() {
-        println!("No templates installed locally.");
-        println!("The 'general' template is always available (built-in).");
-    } else {
-        println!("Installed templates:");
-        for name in &cached {
-            println!("  - {}", name);
+    let installed: std::collections::HashSet<&str> = cached.iter().map(String::as_str).collect();
+
+    println!("Installed:");
+    println!("  - general (built-in)");
+    for name in &cached {
+        println!("  - {}", name);
+    }
+
+    if all {
+        print!("\nFetching remote registry...");
+        match templates::list_remote() {
+            Ok(remote) => {
+                println!("\r                            \r"); // clear line
+                let available: Vec<&str> = remote
+                    .iter()
+                    .map(String::as_str)
+                    .filter(|n| *n != "general" && !installed.contains(n))
+                    .collect();
+                if available.is_empty() {
+                    println!("Available (not installed): none");
+                } else {
+                    println!("Available (not installed):");
+                    for name in available {
+                        println!("  - {}", name);
+                    }
+                }
+                println!("\nRun 'texforge template add <name>' to install.");
+            }
+            Err(e) => {
+                println!("\nCould not reach registry: {}", e);
+            }
         }
     }
+
     Ok(())
 }
 
diff --git a/src/compiler/mod.rs b/src/compiler/mod.rs
index 6921b33..85f6df7 100644
--- a/src/compiler/mod.rs
+++ b/src/compiler/mod.rs
@@ -6,6 +6,7 @@ use std::process::Command;
 use anyhow::{Context, Result};
 
 /// Compile a LaTeX project to PDF using Tectonic.
+/// `root` is the working directory; output PDF goes into `root/` itself.
 pub fn compile(root: &Path, entry: &str) -> Result<()> {
     let tectonic = find_tectonic()?;
     let entry_path = root.join(entry);
@@ -13,7 +14,7 @@ pub fn compile(root: &Path, entry: &str) -> Result<()> {
     let output = Command::new(&tectonic)
         .arg(&entry_path)
         .arg("--outdir")
-        .arg(root.join("build"))
+        .arg(root)
         .arg("--keep-logs")
         .current_dir(root)
         .output()
diff --git a/src/diagrams/mod.rs b/src/diagrams/mod.rs
new file mode 100644
index 0000000..607cf5e
--- /dev/null
+++ b/src/diagrams/mod.rs
@@ -0,0 +1,290 @@
+//! Pre-processor for embedded diagram environments.
+//!
+//! Intercepts `\begin{mermaid}[opts]...\end{mermaid}` blocks, renders them
+//! to PNG, and replaces each block with a proper `figure` environment.
+//!
+//! Works on copies in `build/` — the original .tex files are never modified.
+
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+
+use anyhow::{Context, Result};
+
+/// Copy all .tex files to `build/`, rendering embedded diagrams in the copies.
+/// Also mirrors non-.tex assets so tectonic can resolve relative paths.
+/// Returns the path to the build copy of `entry`.
+pub fn process(root: &Path, entry: &str) -> Result<PathBuf> {
+    let build_dir = root.join("build");
+    std::fs::create_dir_all(&build_dir)?;
+
+    let diagrams_dir = build_dir.join("diagrams");
+    std::fs::create_dir_all(&diagrams_dir)?;
+
+    let mut counter = 0usize;
+
+    // Process .tex files
+    let tex_files = collect_tex_files(root, entry);
+    for src in &tex_files {
+        let rel = src.strip_prefix(root).unwrap_or(src);
+        let dest = build_dir.join(rel);
+        if let Some(parent) = dest.parent() {
+            std::fs::create_dir_all(parent)?;
+        }
+        let content = std::fs::read_to_string(src)?;
+        let processed = render_diagrams(&content, &diagrams_dir, &mut counter)
+            .with_context(|| format!("Failed to render diagrams in {}", src.display()))?;
+        std::fs::write(&dest, processed)?;
+    }
+
+    // Mirror asset files (non-.tex, non-build) so tectonic resolves relative paths
+    mirror_assets(root, &build_dir)?;
+
+    Ok(build_dir.join(entry))
+}
+
+/// Replace all `\begin{mermaid}[opts]...\end{mermaid}` with figure environments.
+fn render_diagrams(content: &str, diagrams_dir: &Path, counter: &mut usize) -> Result<String> {
+    let mut result = String::new();
+    let mut remaining: &str = content;
+
+    while let Some(start) = remaining.find("\\begin{mermaid}") {
+        result.push_str(&remaining[..start]);
+
+        let after_begin = &remaining[start + "\\begin{mermaid}".len()..];
+
+        // Parse optional args: \begin{mermaid}[key=val, ...]
+        let (opts, after_opts) = parse_opts(after_begin);
+
+        let end = after_opts
+            .find("\\end{mermaid}")
+            .context("\\begin{mermaid} without matching \\end{mermaid}")?;
+
+        let diagram_src = after_opts[..end].trim();
+
+        // Render SVG → PNG
+        let svg = mermaid_rs_renderer::render(diagram_src)
+            .map_err(|e| anyhow::anyhow!("Mermaid render error: {}", e))?;
+        let png = svg_to_png(&svg).context("Failed to convert mermaid SVG to PNG")?;
+
+        *counter += 1;
+        let filename = format!("diagram-{}.png", counter);
+        std::fs::write(diagrams_dir.join(&filename), &png)?;
+
+        // Build figure environment
+        let pos = opts.get("pos").map(String::as_str).unwrap_or("H");
+        if !["H", "t", "b", "h", "p"].contains(&pos) {
+            anyhow::bail!(
+                "Invalid mermaid option pos='{}' — valid values are: H, t, b, h, p",
+                pos
+            );
+        }
+        let width = opts
+            .get("width")
+            .map(String::as_str)
+            .unwrap_or("\\linewidth");
+        let caption = opts.get("caption");
+        let rel_path = format!("diagrams/{}", filename);
+
+        let mut fig = format!(
+            "\\begin{{figure}}[{pos}]\n  \\centering\n  \\includegraphics[width={width}]{{{rel_path}}}\n"
+        );
+        if let Some(cap) = caption {
+            fig.push_str(&format!("  \\caption{{{}}}\n", cap));
+        }
+        fig.push_str("\\end{figure}");
+
+        result.push_str(&fig);
+        remaining = &after_opts[end + "\\end{mermaid}".len()..];
+    }
+
+    result.push_str(remaining);
+    Ok(result)
+}
+
+/// Parse `[key=val, key2=val2]` into a map. Returns `(map, rest_of_str)`.
+pub(crate) fn parse_opts(s: &str) -> (HashMap<String, String>, &str) {
+    let s = s.trim_start_matches('\n').trim_start_matches('\r');
+    if !s.starts_with('[') {
+        return (HashMap::new(), s);
+    }
+    let Some(end) = s.find(']') else {
+        return (HashMap::new(), s);
+    };
+    let inner = &s[1..end];
+    let rest = &s[end + 1..];
+
+    let mut map = HashMap::new();
+    for part in inner.split(',') {
+        let part = part.trim();
+        if let Some((k, v)) = part.split_once('=') {
+            map.insert(k.trim().to_string(), v.trim().to_string());
+        }
+    }
+    (map, rest)
+}
+
+/// Collect .tex files reachable from entry via \input (non-recursive for simplicity).
+fn collect_tex_files(root: &Path, entry: &str) -> Vec<PathBuf> {
+    let mut files = Vec::new();
+    collect_recursive(root, entry, &mut files);
+    files
+}
+
+fn collect_recursive(root: &Path, entry: &str, files: &mut Vec<PathBuf>) {
+    let path = resolve_tex(root, entry);
+    if !path.exists() || files.contains(&path) {
+        return;
+    }
+    files.push(path.clone());
+    if let Ok(content) = std::fs::read_to_string(&path) {
+        for line in content.lines() {
+            for input in extract_inputs(line) {
+                collect_recursive(root, input, files);
+            }
+        }
+    }
+}
+
+fn extract_inputs(line: &str) -> Vec<&str> {
+    let mut results = Vec::new();
+    let mut search = line;
+    while let Some(pos) = search.find("\\input{") {
+        let after = &search[pos + 7..];
+        if let Some(end) = after.find('}') {
+            results.push(after[..end].trim());
+            search = &after[end + 1..];
+        } else {
+            break;
+        }
+    }
+    results
+}
+
+fn resolve_tex(root: &Path, input: &str) -> PathBuf {
+    let p = root.join(input);
+    if p.extension().is_some() {
+        p
+    } else {
+        p.with_extension("tex")
+    }
+}
+
+/// Mirror asset directories into build/ using symlinks (Unix) or file copy (Windows).
+/// Skips .tex files (handled separately) and the build/ dir itself.
+fn mirror_assets(root: &Path, build_dir: &Path) -> Result<()> {
+    for entry in std::fs::read_dir(root)? {
+        let entry = entry?;
+        let path = entry.path();
+        let name = entry.file_name();
+        let name_str = name.to_string_lossy();
+
+        // Skip hidden, build/, and .tex files at root level
+        if name_str.starts_with('.') || path == build_dir {
+            continue;
+        }
+
+        let dest = build_dir.join(&name);
+
+        if path.is_dir() {
+            // Remove stale symlink/dir if it points somewhere wrong
+            if dest.exists() || dest.symlink_metadata().is_ok() {
+                continue; // already linked
+            }
+            link_or_copy_dir(&path, &dest)?;
+        }
+        // Individual root-level files (e.g. .bib at root) — skip .tex
+        else if path.is_file() {
+            let ext = path.extension().and_then(|e| e.to_str()).unwrap_or("");
+            if ext == "tex" {
+                continue;
+            }
+            if !dest.exists() {
+                std::fs::copy(&path, &dest)?;
+            }
+        }
+    }
+    Ok(())
+}
+
+#[cfg(unix)]
+fn link_or_copy_dir(src: &Path, dest: &Path) -> Result<()> {
+    // Symlink: dest -> ../dirname (relative from build/)
+    let target = std::path::Path::new("..").join(src.file_name().unwrap());
+    std::os::unix::fs::symlink(&target, dest).with_context(|| {
+        format!(
+            "Failed to symlink {} -> {}",
+            dest.display(),
+            target.display()
+        )
+    })
+}
+
+#[cfg(not(unix))]
+fn link_or_copy_dir(src: &Path, dest: &Path) -> Result<()> {
+    // Windows fallback: recursive copy
+    copy_dir_recursive(src, dest)
+}
+
+#[cfg(not(unix))]
+fn copy_dir_recursive(src: &Path, dest: &Path) -> Result<()> {
+    std::fs::create_dir_all(dest)?;
+    for entry in walkdir::WalkDir::new(src)
+        .into_iter()
+        .filter_map(|e| e.ok())
+    {
+        let rel = entry.path().strip_prefix(src).unwrap();
+        let target = dest.join(rel);
+        if entry.file_type().is_dir() {
+            std::fs::create_dir_all(&target)?;
+        } else {
+            std::fs::copy(entry.path(), &target)?;
+        }
+    }
+    Ok(())
+}
+
+/// Convert SVG string to PNG bytes at 2x scale for print quality.
+fn svg_to_png(svg: &str) -> Result<Vec<u8>> {
+    let options = resvg::usvg::Options::default();
+    let tree = resvg::usvg::Tree::from_str(svg, &options).context("Failed to parse SVG")?;
+
+    let scale = 2.0_f32;
+    let width = (tree.size().width() * scale) as u32;
+    let height = (tree.size().height() * scale) as u32;
+
+    let mut pixmap =
+        resvg::tiny_skia::Pixmap::new(width, height).context("Failed to create pixmap")?;
+
+    resvg::render(
+        &tree,
+        resvg::tiny_skia::Transform::from_scale(scale, scale),
+        &mut pixmap.as_mut(),
+    );
+
+    pixmap.encode_png().context("Failed to encode PNG")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_opts_no_brackets_returns_empty_map() {
+        let (map, rest) = parse_opts("hello");
+        assert!(map.is_empty());
+        assert_eq!(rest, "hello");
+    }
+
+    #[test]
+    fn parse_opts_width_and_pos() {
+        let (map, _) = parse_opts("[width=0.5\\linewidth, pos=t]");
+        assert_eq!(map.get("width").map(String::as_str), Some("0.5\\linewidth"));
+        assert_eq!(map.get("pos").map(String::as_str), Some("t"));
+    }
+
+    #[test]
+    fn parse_opts_caption() {
+        let (map, _) = parse_opts("[caption=My diagram]");
+        assert_eq!(map.get("caption").map(String::as_str), Some("My diagram"));
+    }
+}
diff --git a/src/formatter/mod.rs b/src/formatter/mod.rs
index 9fff0bb..a9ea0c4 100644
--- a/src/formatter/mod.rs
+++ b/src/formatter/mod.rs
@@ -117,3 +117,51 @@ fn extract_env_name(line: &str) -> Option<String> {
     let end = line[start..].find('}')?;
     Some(line[start..start + end].to_string())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn empty_input_returns_single_newline() {
+        assert_eq!(format(""), "\n");
+    }
+
+    #[test]
+    fn trailing_newline_always_present() {
+        let out = format("hello");
+        assert!(out.ends_with('\n'));
+    }
+
+    #[test]
+    fn indentation_inside_environment() {
+        let src = "\\begin{document}\nhello\n\\end{document}";
+        let out = format(src);
+        assert!(
+            out.contains("  hello"),
+            "expected indented 'hello', got:\n{}",
+            out
+        );
+    }
+
+    #[test]
+    fn multiple_blank_lines_collapsed() {
+        let src = "a\n\n\n\nb";
+        let out = format(src);
+        assert_eq!(out, "a\n\nb\n");
+    }
+
+    #[test]
+    fn structural_commands_not_indented() {
+        let src = "\\begin{document}\n\\section{Intro}\n\\end{document}";
+        let out = format(src);
+        assert!(out.contains("\n\\section{Intro}\n"), "got:\n{}", out);
+    }
+
+    #[test]
+    fn verbatim_content_preserved() {
+        let src = "\\begin{verbatim}\n  raw   content\n\\end{verbatim}";
+        let out = format(src);
+        assert!(out.contains("  raw   content"), "got:\n{}", out);
+    }
+}
diff --git a/src/linter/mod.rs b/src/linter/mod.rs
index 8520197..3c9780f 100644
--- a/src/linter/mod.rs
+++ b/src/linter/mod.rs
@@ -80,6 +80,7 @@ pub fn lint(root: &Path, entry: &str, bib_file: Option<&str>) -> Result<Vec<Lint
             &mut errors,
         );
         check_environments(&rel, &content, &mut errors);
+        check_mermaid_blocks(&rel, &content, &mut errors);
     }
 
     Ok(errors)
@@ -149,6 +150,28 @@ fn check_references(
                 });
             }
         }
+
+        for arg in extract_commands(&line, "lstinputlisting") {
+            if !root.join(arg).exists() {
+                errors.push(LintError {
+                    file: rel.to_string(),
+                    line: line_num,
+                    message: format!("\\lstinputlisting{{{}}} — file not found", arg),
+                    suggestion: None,
+                });
+            }
+        }
+
+        for arg in extract_inputminted_files(&line) {
+            if !root.join(arg).exists() {
+                errors.push(LintError {
+                    file: rel.to_string(),
+                    line: line_num,
+                    message: format!("\\inputminted{{{}}} — file not found", arg),
+                    suggestion: None,
+                });
+            }
+        }
     }
 }
 
@@ -295,6 +318,97 @@ fn strip_comment(line: &str) -> String {
     result
 }
 
+/// Check mermaid blocks: unclosed and invalid pos option.
+fn check_mermaid_blocks(rel: &str, content: &str, errors: &mut Vec<LintError>) {
+    const VALID_POS: &[&str] = &["H", "t", "b", "h", "p"];
+
+    for (i, line) in content.lines().enumerate() {
+        let line_num = i + 1;
+        let trimmed = line.trim();
+
+        if !trimmed.starts_with("\\begin{mermaid}") {
+            continue;
+        }
+
+        // Check for unclosed block
+        let rest = &content[content.lines().take(i).map(|l| l.len() + 1).sum::<usize>()..];
+        if !rest.contains("\\end{mermaid}") {
+            errors.push(LintError {
+                file: rel.to_string(),
+                line: line_num,
+                message: "\\begin{mermaid} without matching \\end{mermaid}".into(),
+                suggestion: Some("Add \\end{mermaid}".into()),
+            });
+            continue;
+        }
+
+        // Check pos option if present
+        if let Some(opts_start) = trimmed.find('[') {
+            if let Some(opts_end) = trimmed.find(']') {
+                let opts = &trimmed[opts_start + 1..opts_end];
+                for part in opts.split(',') {
+                    if let Some((k, v)) = part.split_once('=') {
+                        if k.trim() == "pos" {
+                            let pos = v.trim();
+                            if !VALID_POS.contains(&pos) {
+                                errors.push(LintError {
+                                    file: rel.to_string(),
+                                    line: line_num,
+                                    message: format!(
+                                        "\\begin{{mermaid}} invalid pos='{}' — valid values: H, t, b, h, p",
+                                        pos
+                                    ),
+                                    suggestion: Some("Use pos=H, pos=t, pos=b, pos=h, or pos=p".into()),
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// Extract the file argument from `\inputminted{lang}{file}` (second brace group).
+fn extract_inputminted_files(line: &str) -> Vec<&str> {
+    let mut results = Vec::new();
+    let mut search = line;
+    while let Some(pos) = search.find("\\inputminted") {
+        let after = &search[pos + "\\inputminted".len()..];
+        // skip optional [...]
+        let after = if after.starts_with('[') {
+            match after.find(']') {
+                Some(e) => &after[e + 1..],
+                None => break,
+            }
+        } else {
+            after
+        };
+        // skip first {lang}
+        let after = if after.starts_with('{') {
+            match after.find('}') {
+                Some(e) => &after[e + 1..],
+                None => break,
+            }
+        } else {
+            break;
+        };
+        // extract second {file}
+        if after.starts_with('{') {
+            if let Some(end) = after.find('}') {
+                let arg = after[1..end].trim();
+                if !arg.is_empty() {
+                    results.push(arg);
+                }
+                search = &after[end + 1..];
+                continue;
+            }
+        }
+        break;
+    }
+    results
+}
+
 /// Parse `@type{key, ...}` entries from a .bib file.
 fn parse_bib_keys(path: &Path) -> HashSet<String> {
     let mut keys = HashSet::new();
@@ -316,3 +430,93 @@ fn parse_bib_keys(path: &Path) -> HashSet<String> {
     }
     keys
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+    use tempfile::TempDir;
+
+    fn setup(tex: &str) -> (TempDir, String) {
+        let dir = TempDir::new().unwrap();
+        fs::write(dir.path().join("main.tex"), tex).unwrap();
+        (dir, "main.tex".to_string())
+    }
+
+    fn has_error(errors: &[LintError], fragment: &str) -> bool {
+        errors.iter().any(|e| e.message.contains(fragment))
+    }
+
+    #[test]
+    fn includegraphics_missing_file_is_error() {
+        let (dir, entry) = setup("\\includegraphics{missing.png}");
+        let errors = lint(dir.path(), &entry, None).unwrap();
+        assert!(has_error(&errors, "missing.png"));
+    }
+
+    #[test]
+    fn includegraphics_existing_file_no_error() {
+        let (dir, entry) = setup("\\includegraphics{img.png}");
+        fs::write(dir.path().join("img.png"), b"").unwrap();
+        let errors = lint(dir.path(), &entry, None).unwrap();
+        assert!(!has_error(&errors, "img.png"));
+    }
+
+    #[test]
+    fn cite_missing_key_is_error() {
+        let (dir, entry) = setup("\\cite{ghost2020}");
+        fs::write(dir.path().join("refs.bib"), "@article{real2020,}").unwrap();
+        let errors = lint(dir.path(), &entry, Some("refs.bib")).unwrap();
+        assert!(has_error(&errors, "ghost2020"));
+    }
+
+    #[test]
+    fn cite_valid_key_no_error() {
+        let (dir, entry) = setup("\\cite{real2020}");
+        fs::write(dir.path().join("refs.bib"), "@article{real2020,}").unwrap();
+        let errors = lint(dir.path(), &entry, Some("refs.bib")).unwrap();
+        assert!(!has_error(&errors, "real2020"));
+    }
+
+    #[test]
+    fn begin_without_end_is_error() {
+        let (dir, entry) = setup("\\begin{figure}");
+        let errors = lint(dir.path(), &entry, None).unwrap();
+        assert!(has_error(&errors, "never closed"));
+    }
+
+    #[test]
+    fn ref_without_label_is_error() {
+        let (dir, entry) = setup("\\ref{fig:missing}");
+        let errors = lint(dir.path(), &entry, None).unwrap();
+        assert!(has_error(&errors, "fig:missing"));
+    }
+
+    #[test]
+    fn mermaid_invalid_pos_is_error() {
+        let (dir, entry) = setup("\\begin{mermaid}[pos=x]\n\\end{mermaid}");
+        let errors = lint(dir.path(), &entry, None).unwrap();
+        assert!(has_error(&errors, "invalid pos"));
+    }
+
+    #[test]
+    fn mermaid_without_end_is_error() {
+        let (dir, entry) = setup("\\begin{mermaid}");
+        let errors = lint(dir.path(), &entry, None).unwrap();
+        assert!(has_error(&errors, "without matching \\end{mermaid}"));
+    }
+
+    #[test]
+    fn lstinputlisting_missing_file_is_error() {
+        let (dir, entry) = setup("\\lstinputlisting{code.py}");
+        let errors = lint(dir.path(), &entry, None).unwrap();
+        assert!(has_error(&errors, "code.py"));
+    }
+
+    #[test]
+    fn inputminted_missing_file_is_error() {
+        let (dir, entry) = setup("\\inputminted{python}{code.py}");
+        let errors = lint(dir.path(), &entry, None).unwrap();
+        assert!(has_error(&errors, "code.py"));
+    }
+}
diff --git a/src/main.rs b/src/main.rs
index a78c83c..39d0a57 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -6,6 +6,7 @@
 mod cli;
 mod commands;
 mod compiler;
+mod diagrams;
 mod domain;
 mod formatter;
 mod linter;
diff --git a/src/templates/general/main.tex b/src/templates/general/main.tex
index 9487ed7..c49127e 100644
--- a/src/templates/general/main.tex
+++ b/src/templates/general/main.tex
@@ -6,6 +6,7 @@
 \usepackage[T1]{fontenc}
 \usepackage[spanish]{babel}
 \usepackage{amsmath}
+\usepackage{float}
 \usepackage{graphicx}
 \usepackage{hyperref}
 \usepackage{geometry}
diff --git a/src/templates/mod.rs b/src/templates/mod.rs
index 409fbc1..2511485 100644
--- a/src/templates/mod.rs
+++ b/src/templates/mod.rs
@@ -153,6 +153,37 @@ pub fn download(name: &str) -> Result<ResolvedTemplate> {
     Ok(ResolvedTemplate { files })
 }
 
+/// List template names available in the remote registry.
+pub fn list_remote() -> Result<Vec<String>> {
+    let url = format!("https://api.github.com/repos/{}/contents", REGISTRY_REPO);
+
+    let response = reqwest::blocking::Client::new()
+        .get(&url)
+        .header("User-Agent", "texforge")
+        .send()
+        .context("Failed to connect to template registry")?;
+
+    if !response.status().is_success() {
+        anyhow::bail!("Registry returned HTTP {}", response.status());
+    }
+
+    #[derive(serde::Deserialize)]
+    struct Entry {
+        name: String,
+        #[serde(rename = "type")]
+        kind: String,
+    }
+
+    let entries: Vec<Entry> = response.json()?;
+    let mut names: Vec<String> = entries
+        .into_iter()
+        .filter(|e| e.kind == "dir")
+        .map(|e| e.name)
+        .collect();
+    names.sort();
+    Ok(names)
+}
+
 /// List template names available in local cache.
 pub fn list_cached() -> Result<Vec<String>> {
     let dir = utils::templates_dir()?;
diff --git a/src/utils/mod.rs b/src/utils/mod.rs
index 1057cfe..37acfd1 100644
--- a/src/utils/mod.rs
+++ b/src/utils/mod.rs
@@ -18,19 +18,24 @@ pub fn templates_dir() -> anyhow::Result<std::path::PathBuf> {
     Ok(dir)
 }
 
-/// Find all .tex files in a directory
+/// Find all .tex files in a directory, excluding build/
 pub fn find_tex_files(root: &Path) -> anyhow::Result<Vec<std::path::PathBuf>> {
     let mut files = Vec::new();
+    let build_dir = root.join("build");
 
     for entry in walkdir::WalkDir::new(root)
         .follow_links(true)
         .into_iter()
         .filter_map(|e| e.ok())
     {
+        let path = entry.path();
+        if path.starts_with(&build_dir) {
+            continue;
+        }
         if entry.file_type().is_file() {
-            if let Some(ext) = entry.path().extension() {
+            if let Some(ext) = path.extension() {
                 if ext == "tex" {
-                    files.push(entry.path().to_path_buf());
+                    files.push(path.to_path_buf());
                 }
             }
         }