@arcbridge/mcp-server 0.1.0

package/dist/index.js

@@ -0,0 +1,3750 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/context.ts
+function createContext() {
+  return {
+    db: null,
+    projectRoot: null
+  };
+}
+
+// src/tools/init-project.ts
+import { z } from "zod";
+import { join } from "path";
+import { existsSync } from "fs";
+import {
+  generateConfig,
+  generateArc42,
+  generatePlan,
+  generateAgentRoles,
+  generateDatabase,
+  generateSyncFiles,
+  indexProject
+} from "@arcbridge/core";
+import { getAdapter } from "@arcbridge/adapters";
+function registerInitProject(server, ctx) {
+  server.tool(
+    "arcbridge_init_project",
+    "Initialize ArcBridge in a project directory. Creates .arcbridge/ with arc42 documentation, phase plan, agent roles, SQLite database, and platform-specific configs.",
+    {
+      name: z.string().min(1).describe("Project name"),
+      template: z.enum(["nextjs-app-router", "react-vite", "api-service", "dotnet-webapi"]).default("nextjs-app-router").describe("Project template"),
+      features: z.array(z.enum(["auth", "database", "api"])).default([]).describe("Features to scaffold"),
+      quality_priorities: z.array(z.string()).default(["security", "performance", "accessibility"]).describe("Quality priorities in order"),
+      platforms: z.array(z.string()).default(["claude"]).describe("Target platforms for agent config generation"),
+      target_dir: z.string().describe("Absolute path to the target project directory")
+    },
+    async (params) => {
+      const targetDir = params.target_dir;
+      if (existsSync(join(targetDir, ".arcbridge", "config.yaml"))) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `ArcBridge is already initialized in ${targetDir}. Use arcbridge_get_project_status to see the current state.`
+            }
+          ]
+        };
+      }
+      const input = {
+        name: params.name,
+        template: params.template,
+        features: params.features,
+        quality_priorities: params.quality_priorities,
+        platforms: params.platforms
+      };
+      const config = generateConfig(targetDir, input);
+      generateArc42(targetDir, input);
+      generatePlan(targetDir, input);
+      const roles = generateAgentRoles(targetDir, params.template);
+      const { db, warnings } = generateDatabase(targetDir, input);
+      ctx.db = db;
+      ctx.projectRoot = targetDir;
+      const syncFiles = generateSyncFiles(targetDir, config);
+      const platformWarnings = [];
+      for (const platform of params.platforms) {
+        try {
+          const adapter = getAdapter(platform);
+          adapter.generateProjectConfig(targetDir, config);
+          adapter.generateAgentConfigs(targetDir, roles);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          platformWarnings.push(`Platform '${platform}': ${msg}`);
+        }
+      }
+      let indexResult = null;
+      try {
+        const result = await indexProject(db, { projectRoot: targetDir });
+        indexResult = {
+          symbolsIndexed: result.symbolsIndexed,
+          dependenciesIndexed: result.dependenciesIndexed,
+          componentsAnalyzed: result.componentsAnalyzed,
+          routesAnalyzed: result.routesAnalyzed
+        };
+      } catch {
+      }
+      const blockCount = db.prepare("SELECT COUNT(*) as count FROM building_blocks").get();
+      const scenarioCount = db.prepare("SELECT COUNT(*) as count FROM quality_scenarios").get();
+      const phaseCount = db.prepare("SELECT COUNT(*) as count FROM phases").get();
+      const taskCount = db.prepare("SELECT COUNT(*) as count FROM tasks").get();
+      const allWarnings = [...warnings, ...platformWarnings];
+      const summary = [
+        `# ArcBridge Initialized: ${input.name}`,
+        "",
+        `**Template:** ${input.template}`,
+        `**Features:** ${input.features.length > 0 ? input.features.join(", ") : "none"}`,
+        `**Platforms:** ${params.platforms.join(", ")}`,
+        "",
+        "## Created",
+        "",
+        `- **Building blocks:** ${blockCount.count}`,
+        `- **Quality scenarios:** ${scenarioCount.count}`,
+        `- **Phases:** ${phaseCount.count}`,
+        `- **Tasks:** ${taskCount.count}`,
+        `- **Agent roles:** ${roles.length}`,
+        ...indexResult ? [
+          `- **Symbols indexed:** ${indexResult.symbolsIndexed}`,
+          `- **Dependencies indexed:** ${indexResult.dependenciesIndexed}`,
+          `- **Components analyzed:** ${indexResult.componentsAnalyzed}`,
+          `- **Routes analyzed:** ${indexResult.routesAnalyzed}`
+        ] : [input.template === "dotnet-webapi" ? `- **Code indexing:** not available yet for .NET projects (C# indexer planned)` : `- **Code indexing:** skipped (no tsconfig.json found \u2014 run \`arcbridge_reindex\` later)`],
+        "",
+        "## Files",
+        "",
+        "- `.arcbridge/config.yaml` \u2014 Project configuration",
+        "- `.arcbridge/arc42/` \u2014 Architecture documentation (arc42)",
+        "- `.arcbridge/plan/` \u2014 Phase plan and tasks",
+        "- `.arcbridge/agents/` \u2014 Canonical agent role definitions",
+        "- `.arcbridge/index.db` \u2014 SQLite database",
+        ...params.platforms.includes("claude") ? ["- `CLAUDE.md` \u2014 Claude Code project instructions", "- `.claude/agents/` \u2014 Claude agent configs"] : [],
+        ...params.platforms.includes("copilot") ? ["- `.github/copilot-instructions.md` \u2014 Copilot instructions", "- `.github/agents/` \u2014 Copilot agent configs"] : [],
+        ...syncFiles.map((f) => `- \`${f}\` \u2014 Sync loop trigger`),
+        ...allWarnings.length > 0 ? [
+          "",
+          "## Warnings",
+          "",
+          ...allWarnings.map((w) => `- ${w}`)
+        ] : [],
+        "",
+        "Use `arcbridge_get_project_status` to see the full project status."
+      ];
+      return {
+        content: [{ type: "text", text: summary.join("\n") }]
+      };
+    }
+  );
+}
+
+// src/tools/get-project-status.ts
+import { z as z2 } from "zod";
+import { refreshFromDocs } from "@arcbridge/core";
+
+// src/helpers.ts
+import { join as join2 } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { openDatabase } from "@arcbridge/core";
+function ensureDb(ctx, targetDir) {
+  if (ctx.db) return ctx.db;
+  const dbPath = join2(targetDir, ".arcbridge", "index.db");
+  if (!existsSync2(dbPath)) {
+    return null;
+  }
+  ctx.db = openDatabase(dbPath);
+  ctx.projectRoot = targetDir;
+  return ctx.db;
+}
+function notInitialized() {
+  return {
+    content: [
+      {
+        type: "text",
+        text: "ArcBridge is not initialized in this directory. Run `arcbridge_init_project` first."
+      }
+    ]
+  };
+}
+function textResult(text) {
+  return {
+    content: [{ type: "text", text }]
+  };
+}
+function escapeLike(value) {
+  return value.replace(/%/g, "\\%").replace(/_/g, "\\_");
+}
+function safeParseJson(value, fallback) {
+  if (value === null || value === void 0) return fallback;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+function normalizeCodePath(codePath) {
+  return codePath.replace(/\*+\/?$/, "");
+}
+
+// src/tools/get-project-status.ts
+function registerGetProjectStatus(server, ctx) {
+  server.tool(
+    "arcbridge_get_project_status",
+    "Get the current status of the ArcBridge project: current phase, task completion, building blocks, quality scenarios, and drift warnings.",
+    {
+      target_dir: z2.string().describe("Absolute path to the project directory")
+    },
+    async (params) => {
+      const db = ensureDb(ctx, params.target_dir);
+      if (!db) {
+        return notInitialized();
+      }
+      refreshFromDocs(db, params.target_dir);
+      const projectName = db.prepare(
+        "SELECT value FROM arcbridge_meta WHERE key = 'project_name'"
+      ).get()?.value ?? "Unknown";
+      const phases = db.prepare(
+        "SELECT id, name, phase_number, status FROM phases ORDER BY phase_number"
+      ).all();
+      const currentPhase = phases.find(
+        (p) => p.status === "in-progress"
+      ) ?? phases[0];
+      const taskStats = db.prepare(
+        "SELECT status, COUNT(*) as count FROM tasks GROUP BY status"
+      ).all();
+      const totalTasks = taskStats.reduce((sum, r) => sum + r.count, 0);
+      const doneTasks = taskStats.find((r) => r.status === "done")?.count ?? 0;
+      const completionPct = totalTasks > 0 ? Math.round(doneTasks / totalTasks * 100) : 0;
+      const blocks = db.prepare("SELECT id, name, responsibility FROM building_blocks").all();
+      const scenarios = db.prepare(
+        "SELECT id, name, category, status, priority FROM quality_scenarios ORDER BY category, id"
+      ).all();
+      const symbolCount = db.prepare("SELECT COUNT(*) as count FROM symbols").get().count;
+      const depCount = db.prepare("SELECT COUNT(*) as count FROM dependencies").get().count;
+      const componentCount = db.prepare("SELECT COUNT(*) as count FROM components").get().count;
+      const routeCount = db.prepare("SELECT COUNT(*) as count FROM routes").get().count;
+      const lastIndexed = db.prepare("SELECT MAX(indexed_at) as value FROM symbols").get()?.value;
+      const driftCount = db.prepare(
+        "SELECT COUNT(*) as count FROM drift_log WHERE resolution IS NULL"
+      ).get().count;
+      const lines = [
+        `# Project Status: ${projectName}`,
+        "",
+        "## Current Phase",
+        "",
+        currentPhase ? `**${currentPhase.name}** (${currentPhase.status})` : "*No phases defined*",
+        "",
+        "## Phases",
+        "",
+        ...phases.map(
+          (p) => `- ${p.status === "complete" ? "[x]" : p.status === "in-progress" ? "[>]" : "[ ]"} Phase ${p.phase_number}: ${p.name} (${p.status})`
+        ),
+        "",
+        "## Task Progress",
+        "",
+        `**${doneTasks}/${totalTasks}** tasks complete (${completionPct}%)`,
+        "",
+        ...taskStats.map((r) => `- ${r.status}: ${r.count}`),
+        "",
+        "## Building Blocks",
+        "",
+        ...blocks.map((b) => `- **${b.name}** (\`${b.id}\`): ${b.responsibility}`),
+        "",
+        "## Quality Scenarios",
+        "",
+        ...scenarios.map(
+          (s) => `- ${s.status === "passing" ? "pass" : s.status === "failing" ? "FAIL" : s.status === "partial" ? "partial" : "untested"} ${s.id}: ${s.name} [${s.category}] (${s.priority})`
+        ),
+        ""
+      ];
+      lines.push("## Code Intelligence", "");
+      if (symbolCount > 0) {
+        lines.push(
+          `- **Symbols indexed:** ${symbolCount}`,
+          `- **Dependencies indexed:** ${depCount}`,
+          `- **Components analyzed:** ${componentCount}`,
+          `- **Routes analyzed:** ${routeCount}`,
+          `- **Last indexed:** ${lastIndexed ?? "unknown"}`,
+          ""
+        );
+      } else {
+        lines.push(
+          "*Not indexed yet.* Run `arcbridge_reindex` to index TypeScript symbols.",
+          ""
+        );
+      }
+      if (driftCount > 0) {
+        lines.push(
+          "## Drift Warnings",
+          "",
+          `**${driftCount}** unresolved drift issue(s) detected.`,
+          ""
+        );
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
+
+// src/tools/get-building-blocks.ts
+import { z as z3 } from "zod";
+function registerGetBuildingBlocks(server, ctx) {
+  server.tool(
+    "arcbridge_get_building_blocks",
+    "Get all architecture building blocks with their code mappings, responsibilities, and linked quality scenarios.",
+    {
+      target_dir: z3.string().describe("Absolute path to the project directory")
+    },
+    async (params) => {
+      const db = ensureDb(ctx, params.target_dir);
+      if (!db) return notInitialized();
+      const blocks = db.prepare(
+        "SELECT id, name, level, parent_id, responsibility, code_paths, interfaces, service, last_synced FROM building_blocks ORDER BY level, name"
+      ).all();
+      if (blocks.length === 0) {
+        return {
+          content: [
+            { type: "text", text: "No building blocks defined yet." }
+          ]
+        };
+      }
+      const lines = ["# Building Blocks", ""];
+      for (const block of blocks) {
+        const indent = "  ".repeat(block.level - 1);
+        const codePaths = safeParseJson(block.code_paths, []);
+        const interfaces = safeParseJson(block.interfaces, []);
+        lines.push(`${indent}## ${block.name} (\`${block.id}\`)`);
+        lines.push("");
+        lines.push(`${indent}**Responsibility:** ${block.responsibility}`);
+        lines.push(`${indent}**Service:** ${block.service}`);
+        if (codePaths.length > 0) {
+          lines.push(
+            `${indent}**Code:** ${codePaths.map((p) => `\`${p}\``).join(", ")}`
+          );
+        }
+        if (interfaces.length > 0) {
+          lines.push(
+            `${indent}**Interfaces:** ${interfaces.map((i) => `\`${i}\``).join(", ")}`
+          );
+        }
+        if (block.parent_id) {
+          lines.push(`${indent}**Parent:** \`${block.parent_id}\``);
+        }
+        const scenarios = db.prepare(
+          "SELECT id, name, category, status FROM quality_scenarios WHERE linked_blocks LIKE ?"
+        ).all(`%"${block.id}"%`);
+        if (scenarios.length > 0) {
+          lines.push(`${indent}**Quality Scenarios:**`);
+          for (const s of scenarios) {
+            lines.push(
+              `${indent}- ${s.id}: ${s.name} [${s.category}] (${s.status})`
+            );
+          }
+        }
+        lines.push("");
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
+
+// src/tools/get-building-block.ts
+import { z as z4 } from "zod";
+function registerGetBuildingBlock(server, ctx) {
+  server.tool(
+    "arcbridge_get_building_block",
+    "Get detailed information about a single building block: its arc42 description, code modules, interfaces, quality scenarios, ADRs, and tasks.",
+    {
+      target_dir: z4.string().describe("Absolute path to the project directory"),
+      block_id: z4.string().describe("Building block ID (e.g., 'auth-module')")
+    },
+    async (params) => {
+      const db = ensureDb(ctx, params.target_dir);
+      if (!db) return notInitialized();
+      const block = db.prepare("SELECT * FROM building_blocks WHERE id = ?").get(params.block_id);
+      if (!block) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Building block '${params.block_id}' not found. Use \`arcbridge_get_building_blocks\` to see all blocks.`
+            }
+          ]
+        };
+      }
+      const codePaths = safeParseJson(block.code_paths, []);
+      const interfaces = safeParseJson(block.interfaces, []);
+      const escapedBlockId = escapeLike(block.id);
+      const lines = [
+        `# ${block.name} (\`${block.id}\`)`,
+        "",
+        `**Responsibility:** ${block.responsibility}`,
+        `**Level:** ${block.level}`,
+        `**Service:** ${block.service}`
+      ];
+      if (block.parent_id) {
+        lines.push(`**Parent:** \`${block.parent_id}\``);
+      }
+      if (block.last_synced) {
+        lines.push(`**Last synced:** ${block.last_synced}`);
+      }
+      lines.push("", "## Code Paths", "");
+      if (codePaths.length > 0) {
+        for (const p of codePaths) {
+          lines.push(`- \`${p}\``);
+        }
+      } else {
+        lines.push("*No code paths mapped yet.*");
+      }
+      if (codePaths.length > 0) {
+        const pathConditions = codePaths.map(() => "file_path LIKE ? ESCAPE '\\'");
+        const pathParams = codePaths.map((cp) => {
+          const prefix = normalizeCodePath(cp);
+          return `${escapeLike(prefix)}%`;
+        });
+        const symbolQuery = `
+          SELECT name, kind, file_path, is_exported
+          FROM symbols
+          WHERE (${pathConditions.join(" OR ")})
+          ORDER BY file_path, name
+          LIMIT 30
+        `;
+        const mappedSymbols = db.prepare(symbolQuery).all(...pathParams);
+        if (mappedSymbols.length > 0) {
+          const totalCount = db.prepare(
+            `SELECT COUNT(*) as count FROM symbols WHERE (${pathConditions.join(" OR ")})`
+          ).get(...pathParams);
+          lines.push("", `## Mapped Symbols (${totalCount.count} total)`, "");
+          const byKind = /* @__PURE__ */ new Map();
+          for (const s of mappedSymbols) {
+            byKind.set(s.kind, (byKind.get(s.kind) ?? 0) + 1);
+          }
+          lines.push(
+            [...byKind.entries()].map(([k, c]) => `**${c}** ${k}s`).join(", "),
+            ""
+          );
+          for (const s of mappedSymbols) {
+            const exported = s.is_exported ? "" : " (internal)";
+            lines.push(`- \`${s.file_path}\` \u2192 **${s.name}** (${s.kind})${exported}`);
+          }
+          if (totalCount.count > 30) {
+            lines.push(`- *... and ${totalCount.count - 30} more*`);
+          }
+        }
+      }
+      if (interfaces.length > 0) {
+        lines.push("", "## Interfaces", "");
+        for (const i of interfaces) {
+          lines.push(`- \`${i}\``);
+        }
+      }
+      const children = db.prepare(
+        "SELECT id, name, responsibility FROM building_blocks WHERE parent_id = ?"
+      ).all(params.block_id);
+      if (children.length > 0) {
+        lines.push("", "## Sub-blocks", "");
+        for (const child of children) {
+          lines.push(`- **${child.name}** (\`${child.id}\`): ${child.responsibility}`);
+        }
+      }
+      const scenarios = db.prepare(
+        "SELECT id, name, category, priority, status, scenario, expected FROM quality_scenarios WHERE linked_blocks LIKE ? ESCAPE '\\'"
+      ).all(`%"${escapedBlockId}"%`);
+      if (scenarios.length > 0) {
+        lines.push("", "## Quality Scenarios", "");
+        for (const s of scenarios) {
+          lines.push(
+            `### ${s.id}: ${s.name} [${s.category}]`,
+            `- **Priority:** ${s.priority}`,
+            `- **Status:** ${s.status}`,
+            `- **Scenario:** ${s.scenario}`,
+            `- **Expected:** ${s.expected}`,
+            ""
+          );
+        }
+      }
+      const adrs = db.prepare(
+        "SELECT id, title, status, date FROM adrs WHERE affected_blocks LIKE ? ESCAPE '\\'"
+      ).all(`%"${escapedBlockId}"%`);
+      if (adrs.length > 0) {
+        lines.push("", "## Related ADRs", "");
+        for (const adr of adrs) {
+          lines.push(`- **${adr.id}:** ${adr.title} (${adr.status}, ${adr.date})`);
+        }
+      }
+      const tasks = db.prepare(
+        "SELECT id, title, status, phase_id FROM tasks WHERE building_block = ?"
+      ).all(params.block_id);
+      if (tasks.length > 0) {
+        lines.push("", "## Tasks", "");
+        for (const task of tasks) {
+          const check = task.status === "done" ? "[x]" : task.status === "in-progress" ? "[>]" : "[ ]";
+          lines.push(`- ${check} ${task.id}: ${task.title} (${task.status})`);
+        }
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
+
+// src/tools/get-quality-scenarios.ts
+import { z as z5 } from "zod";
+import { QualityCategorySchema, QualityPrioritySchema, QualityScenarioStatusSchema } from "@arcbridge/core";
+function registerGetQualityScenarios(server, ctx) {
+  server.tool(
+    "arcbridge_get_quality_scenarios",
+    "Get quality scenarios, optionally filtered by category. Shows scenario details, linked code/tests, and current status.",
+    {
+      target_dir: z5.string().describe("Absolute path to the project directory"),
+      category: QualityCategorySchema.optional().describe("Filter by category"),
+      status: QualityScenarioStatusSchema.optional().describe("Filter by status"),
+      priority: QualityPrioritySchema.optional().describe("Filter by priority (must/should/could)")
+    },
+    async (params) => {
+      const db = ensureDb(ctx, params.target_dir);
+      if (!db) return notInitialized();
+      let query = "SELECT id, name, category, scenario, expected, priority, linked_code, linked_tests, linked_blocks, verification, status FROM quality_scenarios";
+      const conditions = [];
+      const queryParams = [];
+      if (params.category) {
+        conditions.push("category = ?");
+        queryParams.push(params.category);
+      }
+      if (params.status) {
+        conditions.push("status = ?");
+        queryParams.push(params.status);
+      }
+      if (params.priority) {
+        conditions.push("priority = ?");
+        queryParams.push(params.priority);
+      }
+      if (conditions.length > 0) {
+        query += " WHERE " + conditions.join(" AND ");
+      }
+      query += " ORDER BY category, id";
+      const scenarios = db.prepare(query).all(...queryParams);
+      if (scenarios.length === 0) {
+        const filter = [params.category, params.status, params.priority].filter(Boolean).join(", ");
+        return {
+          content: [
+            {
+              type: "text",
+              text: filter ? `No quality scenarios found matching: ${filter}` : "No quality scenarios defined yet."
+            }
+          ]
+        };
+      }
+      const byCategory = /* @__PURE__ */ new Map();
+      for (const s of scenarios) {
+        const list = byCategory.get(s.category) ?? [];
+        list.push(s);
+        byCategory.set(s.category, list);
+      }
+      const statusIcon = (s) => s === "passing" ? "PASS" : s === "failing" ? "FAIL" : s === "partial" ? "PARTIAL" : "UNTESTED";
+      const lines = ["# Quality Scenarios", ""];
+      const passing = scenarios.filter((s) => s.status === "passing").length;
+      const failing = scenarios.filter((s) => s.status === "failing").length;
+      const untested = scenarios.filter((s) => s.status === "untested").length;
+      const partial = scenarios.filter((s) => s.status === "partial").length;
+      lines.push(
+        `**Total:** ${scenarios.length} | **Passing:** ${passing} | **Failing:** ${failing} | **Untested:** ${untested} | **Partial:** ${partial}`,
+        ""
+      );
+      for (const [category, items] of byCategory) {
+        lines.push(
+          `## ${category.charAt(0).toUpperCase() + category.slice(1)}`,
+          ""
+        );
+        for (const s of items) {
+          const linkedCode = safeParseJson(s.linked_code, []);
+          const linkedTests = safeParseJson(s.linked_tests, []);
+          const linkedBlocks = safeParseJson(s.linked_blocks, []);
+          lines.push(
+            `### ${statusIcon(s.status)} ${s.id}: ${s.name}`,
+            "",
+            `- **Priority:** ${s.priority}`,
+            `- **Verification:** ${s.verification}`,
+            `- **Scenario:** ${s.scenario}`,
+            `- **Expected:** ${s.expected}`
+          );
+          if (linkedCode.length > 0) {
+            lines.push(
+              `- **Linked code:** ${linkedCode.map((c) => `\`${c}\``).join(", ")}`
+            );
+          }
+          if (linkedTests.length > 0) {
+            lines.push(
+              `- **Linked tests:** ${linkedTests.map((t) => `\`${t}\``).join(", ")}`
+            );
+          }
+          if (linkedBlocks.length > 0) {
+            lines.push(
+              `- **Linked blocks:** ${linkedBlocks.map((b) => `\`${b}\``).join(", ")}`
+            );
+          }
+          lines.push("");
+        }
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
+
+// src/tools/get-phase-plan.ts
+import { z as z6 } from "zod";
+import { refreshFromDocs as refreshFromDocs2 } from "@arcbridge/core";
+function registerGetPhasePlan(server, ctx) {
+  server.tool(
+    "arcbridge_get_phase_plan",
+    "Get the complete phase plan with all phases, their tasks, status, and gate requirements.",
+    {
+      target_dir: z6.string().describe("Absolute path to the project directory")
+    },
+    async (params) => {
+      const db = ensureDb(ctx, params.target_dir);
+      if (!db) return notInitialized();
+      refreshFromDocs2(db, params.target_dir);
+      const phases = db.prepare(
+        "SELECT id, name, phase_number, status, description, gate_status, started_at, completed_at FROM phases ORDER BY phase_number"
+      ).all();
+      if (phases.length === 0) {
+        return {
+          content: [
+            { type: "text", text: "No phases defined yet." }
+          ]
+        };
+      }
+      const lines = ["# Phase Plan", ""];
+      for (const phase of phases) {
+        const icon = phase.status === "complete" ? "[x]" : phase.status === "in-progress" ? "[>]" : phase.status === "blocked" ? "[!]" : "[ ]";
+        lines.push(
+          `## ${icon} Phase ${phase.phase_number}: ${phase.name}`,
+          "",
+          `**Status:** ${phase.status}`,
+          `**Description:** ${phase.description}`
+        );
+        if (phase.started_at) {
+          lines.push(`**Started:** ${phase.started_at}`);
+        }
+        if (phase.completed_at) {
+          lines.push(`**Completed:** ${phase.completed_at}`);
+        }
+        const tasks = db.prepare(
+          "SELECT id, title, status, building_block, quality_scenarios, acceptance_criteria FROM tasks WHERE phase_id = ? ORDER BY id"
+        ).all(phase.id);
+        if (tasks.length > 0) {
+          const done = tasks.filter((t) => t.status === "done").length;
+          lines.push(
+            "",
+            `### Tasks (${done}/${tasks.length} complete)`,
+            ""
+          );
+          for (const task of tasks) {
+            const check = task.status === "done" ? "[x]" : task.status === "in-progress" ? "[>]" : task.status === "blocked" ? "[!]" : "[ ]";
+            lines.push(`- ${check} **${task.id}:** ${task.title}`);
+            if (task.building_block) {
+              lines.push(`  - Block: \`${task.building_block}\``);
+            }
+            const qScenarios = safeParseJson(task.quality_scenarios, []);
+            if (qScenarios.length > 0) {
+              lines.push(
+                `  - Quality: ${qScenarios.join(", ")}`
+              );
+            }
+            const criteria = safeParseJson(task.acceptance_criteria, []);
+            if (criteria.length > 0) {
+              for (const c of criteria) {
+                lines.push(`  - [ ] ${c}`);
+              }
+            }
+          }
+        }
+        lines.push("");
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
+
+// src/tools/get-current-tasks.ts
+import { z as z7 } from "zod";
+import { refreshFromDocs as refreshFromDocs3 } from "@arcbridge/core";
+function registerGetCurrentTasks(server, ctx) {
+  server.tool(
+    "arcbridge_get_current_tasks",
+    "Get tasks for the current in-progress phase, with their building blocks, quality scenarios, and acceptance criteria.",
+    {
+      target_dir: z7.string().describe("Absolute path to the project directory"),
+      status: z7.enum(["todo", "in-progress", "done", "blocked"]).optional().describe("Filter tasks by status")
+    },
+    async (params) => {
+      const db = ensureDb(ctx, params.target_dir);
+      if (!db) return notInitialized();
+      refreshFromDocs3(db, params.target_dir);
+      const currentPhase = db.prepare(
+        "SELECT id, name FROM phases WHERE status = 'in-progress' ORDER BY phase_number LIMIT 1"
+      ).get();
+      if (!currentPhase) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No phase is currently in-progress. Use `arcbridge_get_phase_plan` to see all phases."
+            }
+          ]
+        };
+      }
+      let query = "SELECT id, phase_id, title, description, status, building_block, quality_scenarios, acceptance_criteria FROM tasks WHERE phase_id = ?";
+      const queryParams = [currentPhase.id];
+      if (params.status) {
+        query += " AND status = ?";
+        queryParams.push(params.status);
+      }
+      query += " ORDER BY id";
+      const tasks = db.prepare(query).all(...queryParams);
+      const lines = [
+        `# Current Tasks: ${currentPhase.name}`,
+        ""
+      ];
+      if (tasks.length === 0) {
+        lines.push(
+          params.status ? `No tasks with status '${params.status}' in this phase.` : "No tasks in this phase."
+        );
+      } else {
+        const done = tasks.filter((t) => t.status === "done").length;
+        lines.push(`**Progress:** ${done}/${tasks.length} complete`, "");
+        for (const task of tasks) {
+          const check = task.status === "done" ? "[x]" : task.status === "in-progress" ? "[>]" : task.status === "blocked" ? "[!]" : "[ ]";
+          lines.push(`## ${check} ${task.id}: ${task.title}`, "");
+          lines.push(`**Status:** ${task.status}`);
+          if (task.building_block) {
+            lines.push(`**Building block:** \`${task.building_block}\``);
+          }
+          const qScenarios = safeParseJson(task.quality_scenarios, []);
+          if (qScenarios.length > 0) {
+            lines.push(
+              `**Quality scenarios:** ${qScenarios.join(", ")}`
+            );
+          }
+          const criteria = safeParseJson(task.acceptance_criteria, []);
+          if (criteria.length > 0) {
+            lines.push("", "**Acceptance criteria:**");
+            for (const c of criteria) {
+              lines.push(
+                `- ${task.status === "done" ? "[x]" : "[ ]"} ${c}`
+              );
+            }
+          }
+          lines.push("");
+        }
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
+
+// src/tools/update-task.ts
+import { z as z8 } from "zod";
+import { syncTaskToYaml } from "@arcbridge/core";
+function registerUpdateTask(server, ctx) {
+  server.tool(
+    "arcbridge_update_task",
+    "Update a task's status. Use this to mark tasks as in-progress, done, or blocked as you work.",
+    {
+      target_dir: z8.string().describe("Absolute path to the project directory"),
+      task_id: z8.string().describe("Task ID (e.g., 'task-0.1-init-nextjs')"),
+      status: z8.enum(["in-progress", "done", "blocked"]).describe("New status"),
+      notes: z8.string().optional().describe("Optional notes about the status change")
+    },
+    async (params) => {
+      const db = ensureDb(ctx, params.target_dir);
+      if (!db) return notInitialized();
+      const task = db.prepare("SELECT id, title, status, phase_id FROM tasks WHERE id = ?").get(params.task_id);
+      if (!task) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Task '${params.task_id}' not found. Use \`arcbridge_get_current_tasks\` to see available tasks.`
+            }
+          ]
+        };
+      }
+      const oldStatus = task.status;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      if (params.status === "done") {
+        db.prepare(
+          "UPDATE tasks SET status = ?, completed_at = ? WHERE id = ?"
+        ).run(params.status, now, params.task_id);
+      } else {
+        db.prepare("UPDATE tasks SET status = ? WHERE id = ?").run(
+          params.status,
+          params.task_id
+        );
+      }
+      syncTaskToYaml(
+        params.target_dir,
+        task.phase_id,
+        params.task_id,
+        params.status,
+        params.status === "done" ? now : null
+      );
+      const lines = [
+        `Task **${task.id}** updated: ${oldStatus} \u2192 ${params.status}`,
+        "",
+        `**${task.title}**`
+      ];
+      if (params.notes) {
+        lines.push("", `**Notes:** ${params.notes}`);
+      }
+      if (params.status === "done") {
+        const phaseStats = db.prepare(
+          "SELECT COUNT(*) as total, SUM(CASE WHEN status = 'done' THEN 1 ELSE 0 END) as done FROM tasks WHERE phase_id = ?"
+        ).get(task.phase_id);
+        lines.push(
+          "",
+          `**Phase progress:** ${phaseStats.done}/${phaseStats.total} tasks complete`
+        );
+        if (phaseStats.done === phaseStats.total) {
+          lines.push(
+            "",
+            "All tasks in this phase are complete! The phase is ready to advance."
+          );
+        }
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
+
+// src/tools/create-task.ts
+import { z as z9 } from "zod";
+import { addTaskToYaml } from "@arcbridge/core";
+function registerCreateTask(server, ctx) {
+  server.tool(
+    "arcbridge_create_task",
+    "Create a new task in a phase. Links it to a building block and quality scenarios.",
+    {
+      target_dir: z9.string().describe("Absolute path to the project directory"),
+      phase_id: z9.string().describe("Phase ID to add the task to"),
+      title: z9.string().min(1).describe("Task title"),
+      building_block: z9.string().optional().describe("Building block this task belongs to"),
+      quality_scenarios: z9.array(z9.string()).default([]).describe("Quality scenario IDs this task addresses"),
+      acceptance_criteria: z9.array(z9.string()).default([]).describe("Acceptance criteria for this task")
+    },
+    async (params) => {
+      const db = ensureDb(ctx, params.target_dir);
+      if (!db) return notInitialized();
+      const phase = db.prepare("SELECT id, name, phase_number FROM phases WHERE id = ?").get(params.phase_id);
+      if (!phase) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Phase '${params.phase_id}' not found. Use \`arcbridge_get_phase_plan\` to see phases.`
+            }
+          ]
+        };
+      }
+      const existingCount = db.prepare(
+        "SELECT COUNT(*) as count FROM tasks WHERE phase_id = ?"
+      ).get(params.phase_id).count;
+      const taskNum = existingCount + 1;
+      const slug = params.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 30);
+      const taskId = `task-${phase.phase_number}.${taskNum}-${slug}`;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      db.prepare(
+        "INSERT INTO tasks (id, phase_id, title, description, status, building_block, quality_scenarios, acceptance_criteria, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
+      ).run(
+        taskId,
+        params.phase_id,
+        params.title,
+        null,
+        "todo",
+        params.building_block ?? null,
+        JSON.stringify(params.quality_scenarios),
+        JSON.stringify(params.acceptance_criteria),
+        now
+      );
+      addTaskToYaml(params.target_dir, params.phase_id, {
+        id: taskId,
+        title: params.title,
+        status: "todo",
+        building_block: params.building_block,
+        quality_scenarios: params.quality_scenarios,
+        acceptance_criteria: params.acceptance_criteria
+      });
+      const lines = [
+        `Task created: **${taskId}**`,
+        "",
+        `**Title:** ${params.title}`,
+        `**Phase:** ${phase.name}`,
+        `**Status:** todo`
+      ];
+      if (params.building_block) {
+        lines.push(`**Block:** \`${params.building_block}\``);
+      }
+      if (params.quality_scenarios.length > 0) {
+        lines.push(
+          `**Quality scenarios:** ${params.quality_scenarios.join(", ")}`
+        );
+      }
+      if (params.acceptance_criteria.length > 0) {
+        lines.push("", "**Acceptance criteria:**");
+        for (const c of params.acceptance_criteria) {
+          lines.push(`- [ ] ${c}`);
+        }
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
+
+// src/tools/get-relevant-adrs.ts
+import { z as z10 } from "zod";
+function registerGetRelevantAdrs(server, ctx) {
+  server.tool(
+    "arcbridge_get_relevant_adrs",
+    "Get architectural decision records (ADRs) relevant to a specific file path or building block.",
+    {
+      target_dir: z10.string().describe("Absolute path to the project directory"),
+      file_path: z10.string().optional().describe("File path to find relevant ADRs for"),
+      building_block: z10.string().optional().describe("Building block ID to find relevant ADRs for")
+    },
+    async (params) => {
+      const db = ensureDb(ctx, params.target_dir);
+      if (!db) return notInitialized();
+      if (!params.file_path && !params.building_block) {
+        const adrs2 = db.prepare(
+          "SELECT id, title, status, date, context, decision, consequences, affected_blocks, affected_files, quality_scenarios FROM adrs ORDER BY id"
+        ).all();
+        return formatAdrs(adrs2, "All ADRs");
+      }
+      const adrs = [];
+      const seen = /* @__PURE__ */ new Set();
+      if (params.building_block) {
+        const blockAdrs = db.prepare(
+          "SELECT id, title, status, date, context, decision, consequences, affected_blocks, affected_files, quality_scenarios FROM adrs WHERE affected_blocks LIKE ? ESCAPE '\\'"
+        ).all(`%"${escapeLike(params.building_block)}"%`);
+        for (const adr of blockAdrs) {
+          if (!seen.has(adr.id)) {
+            adrs.push(adr);
+            seen.add(adr.id);
+          }
+        }
+      }
+      if (params.file_path) {
+        const fileAdrs = db.prepare(
+          "SELECT id, title, status, date, context, decision, consequences, affected_blocks, affected_files, quality_scenarios FROM adrs WHERE affected_files LIKE ? ESCAPE '\\'"
+        ).all(`%${escapeLike(params.file_path)}%`);
+        for (const adr of fileAdrs) {
+          if (!seen.has(adr.id)) {
+            adrs.push(adr);
+            seen.add(adr.id);
+          }
+        }
+      }
+      const scope = [
+        params.file_path ? `file: ${params.file_path}` : "",
+        params.building_block ? `block: ${params.building_block}` : ""
+      ].filter(Boolean).join(", ");
+      return formatAdrs(adrs, `ADRs for ${scope}`);
+    }
+  );
+}
+function formatAdrs(adrs, title) {
+  if (adrs.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `No ADRs found for the specified scope.`
+        }
+      ]
+    };
+  }
+  const lines = [`# ${title}`, ""];
+  for (const adr of adrs) {
+    const affectedBlocks = safeParseJson(adr.affected_blocks, []);
+    const affectedFiles = safeParseJson(adr.affected_files, []);
+    lines.push(
+      `## ${adr.id}: ${adr.title}`,
+      "",
+      `**Status:** ${adr.status} | **Date:** ${adr.date}`
+    );
+    if (affectedBlocks.length > 0) {
+      lines.push(
+        `**Affected blocks:** ${affectedBlocks.map((b) => `\`${b}\``).join(", ")}`
+      );
+    }
+    if (affectedFiles.length > 0) {
+      lines.push(
+        `**Affected files:** ${affectedFiles.map((f) => `\`${f}\``).join(", ")}`
+      );
+    }
+    if (adr.decision) {
+      lines.push("", adr.decision);
+    }
+    lines.push("");
+  }
+  return {
+    content: [{ type: "text", text: lines.join("\n") }]
+  };
+}
+
+// src/tools/reindex.ts
+import { z as z11 } from "zod";
+import { indexProject as indexProject2, refreshFromDocs as refreshFromDocs4 } from "@arcbridge/core";
+function registerReindex(server, ctx) {
+  server.tool(
+    "arcbridge_reindex",
+    "Re-index code symbols in the project. Supports TypeScript and C# (.NET). Incrementally processes only changed files.",
+    {
+      target_dir: z11.string().describe("Absolute path to the project directory"),
+      tsconfig_path: z11.string().optional().describe("Override tsconfig.json path (default: auto-detect). Only used for TypeScript projects."),
+      service: z11.string().optional().describe("Service name for monorepo projects (default: 'main')"),
+      language: z11.enum(["typescript", "csharp", "auto"]).optional().describe("Project language. 'auto' detects from project files (default: 'auto')")
+    },
+    async (params) => {
+      const db = ensureDb(ctx, params.target_dir);
+      if (!db) return notInitialized();
+      try {
+        const docWarnings = refreshFromDocs4(db, params.target_dir);
+        const result = await indexProject2(db, {
+          projectRoot: params.target_dir,
+          tsconfigPath: params.tsconfig_path,
+          service: params.service,
+          language: params.language
+        });
+        const lines = [
+          "# Indexing Complete",
+          "",
+          `- **Docs refreshed:** ${docWarnings.length === 0 ? "OK" : docWarnings.join(", ")}`,
+          `- **Files processed:** ${result.filesProcessed}`,
+          `- **Files skipped (unchanged):** ${result.filesSkipped}`,
+          `- **Files removed:** ${result.filesRemoved}`,
+          `- **Symbols indexed:** ${result.symbolsIndexed}`,
+          `- **Dependencies indexed:** ${result.dependenciesIndexed}`,
+          `- **Components analyzed:** ${result.componentsAnalyzed}`,
+          `- **Routes analyzed:** ${result.routesAnalyzed}`,
+          `- **Duration:** ${result.durationMs}ms`
+        ];
+        return textResult(lines.join("\n"));
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return textResult(`Indexing failed: ${message}`);
+      }
+    }
+  );
+}
+
+// src/tools/search-symbols.ts
+import { z as z12 } from "zod";
+function registerSearchSymbols(server, ctx) {
+  server.tool(
+    "arcbridge_search_symbols",
+    "Search code symbols by name, kind, file path, or building block. Supports TypeScript and C#. Returns matching symbols with type signatures.",
+    {
+      target_dir: z12.string().describe("Absolute path to the project directory"),
+      query: z12.string().optional().describe("Search term to match against symbol names"),
+      service: z12.string().optional().describe("Filter by service name (for multi-project solutions). Omit to search all services."),
+      kind: z12.enum([
+        "function",
+        "class",
+        "type",
+        "constant",
+        "interface",
+        "enum",
+        "variable",
+        "component",
+        "hook",
+        "context"
+      ]).optional().describe("Filter by symbol kind"),
+      file_path: z12.string().optional().describe("Filter by file path (prefix match)"),
+      is_exported: z12.boolean().optional().describe("Filter by export status"),
+      building_block: z12.string().optional().describe("Filter by building block ID (matches against code_paths)"),
+      limit: z12.number().int().min(1).max(200).default(50).describe("Maximum results to return (default: 50)")
+    },
+    async (params) => {
+      const db = ensureDb(ctx, params.target_dir);
+      if (!db) return notInitialized();
+      const conditions = [];
+      const queryParams = [];
+      if (params.service) {
+        conditions.push("s.service = ?");
+        queryParams.push(params.service);
+      }
+      if (params.query) {
+        conditions.push("s.name LIKE ? ESCAPE '\\'");
+        queryParams.push(`%${escapeLike(params.query)}%`);
+      }
+      if (params.kind) {
+        conditions.push("s.kind = ?");
+        queryParams.push(params.kind);
+      }
+      if (params.file_path) {
+        conditions.push("s.file_path LIKE ? ESCAPE '\\'");
+        queryParams.push(`${escapeLike(params.file_path)}%`);
+      }
+      if (params.is_exported !== void 0) {
+        conditions.push("s.is_exported = ?");
+        queryParams.push(params.is_exported ? 1 : 0);
+      }
+      if (params.building_block) {
+        const block = db.prepare("SELECT code_paths FROM building_blocks WHERE id = ?").get(params.building_block);
+        if (block) {
+          try {
+            const codePaths = JSON.parse(block.code_paths);
+            if (codePaths.length > 0) {
+              const pathConditions = codePaths.map(() => "s.file_path LIKE ? ESCAPE '\\'");
+              conditions.push(`(${pathConditions.join(" OR ")})`);
+              for (const cp of codePaths) {
+                const prefix = cp.replace(/\*\*?\/?\*?$/, "");
+                queryParams.push(`${escapeLike(prefix)}%`);
+              }
+            }
+          } catch {
+          }
+        }
+      }
+      let query = "SELECT s.id, s.name, s.qualified_name, s.kind, s.file_path, s.start_line, s.signature, s.return_type, s.is_exported, s.is_async, s.doc_comment FROM symbols s";
+      if (conditions.length > 0) {
+        query += " WHERE " + conditions.join(" AND ");
+      }
+      query += " ORDER BY s.name LIMIT ?";
+      queryParams.push(params.limit);
+      const rows = db.prepare(query).all(...queryParams);
+      if (rows.length === 0) {
+        return textResult("No symbols found matching the search criteria.");
+      }
+      const lines = [
+        `# Symbol Search Results (${rows.length}${rows.length === params.limit ? "+" : ""})`,
+        ""
+      ];
+      for (const s of rows) {
+        const flags = [
+          s.is_exported ? "exported" : "internal",
+          s.is_async ? "async" : ""
+        ].filter(Boolean).join(", ");
+        lines.push(
+          `## \`${s.qualified_name}\` (${s.kind})`,
+          "",
+          `- **ID:** \`${s.id}\``,
+          `- **Location:** \`${s.file_path}:${s.start_line}\``,
+          `- **Flags:** ${flags}`
+        );
+        if (s.signature) {
+          lines.push(`- **Signature:** \`${s.signature}\``);
+        }
+        if (s.return_type) {
+          lines.push(`- **Returns:** \`${s.return_type}\``);
+        }
+        if (s.doc_comment) {
+          lines.push(`- **Docs:** ${s.doc_comment}`);
+        }
+        lines.push("");
+      }
+      return textResult(lines.join("\n"));
+    }
+  );
+}
+
+// src/tools/get-symbol.ts
+import { z as z13 } from "zod";
+import { readFileSync, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+function registerGetSymbol(server, ctx) {
+  server.tool(
+    "arcbridge_get_symbol",
+    "Get detailed information about a specific TypeScript symbol including its source code, type signature, and relationships.",
+    {
+      target_dir: z13.string().describe("Absolute path to the project directory"),
+      symbol_id: z13.string().describe(
+        "Symbol ID (e.g. 'src/utils.ts::formatName#function')"
+      ),
+      include_source: z13.boolean().default(true).describe("Include source code snippet (default: true)")
+    },
+    async (params) => {
+      const db = ensureDb(ctx, params.target_dir);
+      if (!db) return notInitialized();
+      const symbol = db.prepare("SELECT * FROM symbols WHERE id = ?").get(params.symbol_id);
+      if (!symbol) {
+        return textResult(
+          `Symbol not found: \`${params.symbol_id}\`
+
+Use \`arcbridge_search_symbols\` to find symbols by name.`
+        );
+      }
+      const lines = [
+        `# ${symbol.qualified_name}`,
+        "",
+        `| Field | Value |`,
+        `|-------|-------|`,
+        `| **Kind** | ${symbol.kind} |`,
+        `| **File** | \`${symbol.file_path}:${symbol.start_line}\` |`,
+        `| **Exported** | ${symbol.is_exported ? "yes" : "no"} |`,
+        `| **Async** | ${symbol.is_async ? "yes" : "no"} |`,
+        `| **Service** | ${symbol.service} |`
+      ];
+      if (symbol.signature) {
+        lines.push(`| **Signature** | \`${symbol.signature}\` |`);
+      }
+      if (symbol.return_type) {
+        lines.push(`| **Return type** | \`${symbol.return_type}\` |`);
+      }
+      lines.push("");
+      if (symbol.doc_comment) {
+        lines.push("## Documentation", "", symbol.doc_comment, "");
+      }
+      if (params.include_source) {
+        const absPath = join3(params.target_dir, symbol.file_path);
+        if (existsSync3(absPath)) {
+          try {
+            const content = readFileSync(absPath, "utf-8");
+            const fileLines = content.split("\n");
+            const contextBefore = 2;
+            const startIdx = Math.max(0, symbol.start_line - 1 - contextBefore);
+            const endIdx = Math.min(fileLines.length, symbol.end_line);
+            const snippet = fileLines.slice(startIdx, endIdx).map((line, i) => {
+              const lineNum = startIdx + i + 1;
+              const marker = lineNum >= symbol.start_line && lineNum <= symbol.end_line ? ">" : " ";
+              return `${marker} ${String(lineNum).padStart(4)} | ${line}`;
+            }).join("\n");
+            lines.push("## Source", "", "```typescript", snippet, "```", "");
+          } catch {
+          }
+        }
+      }
+      const callees = db.prepare(
+        `SELECT d.target_symbol as symbol_id, s.name as symbol_name, d.kind, s.file_path
+           FROM dependencies d
+           JOIN symbols s ON s.id = d.target_symbol
+           WHERE d.source_symbol = ?
+           ORDER BY d.kind, s.name`
+      ).all(params.symbol_id);
+      const callers = db.prepare(
+        `SELECT d.source_symbol as symbol_id, s.name as symbol_name, d.kind, s.file_path
+           FROM dependencies d
+           JOIN symbols s ON s.id = d.source_symbol
+           WHERE d.target_symbol = ?
+           ORDER BY d.kind, s.name`
+      ).all(params.symbol_id);
+      if (callees.length > 0) {
+        lines.push("## Dependencies (this symbol uses)", "");
+        for (const dep of callees) {
+          lines.push(`- **${dep.kind}** \u2192 \`${dep.symbol_name}\` (\`${dep.file_path}\`)`);
+        }
+        lines.push("");
+      }
+      if (callers.length > 0) {
+        lines.push("## Dependents (uses this symbol)", "");
+        for (const dep of callers) {
+          lines.push(`- **${dep.kind}** \u2190 \`${dep.symbol_name}\` (\`${dep.file_path}\`)`);
+        }
+        lines.push("");
+      }
+      const blocks = db.prepare("SELECT id, name, code_paths FROM building_blocks").all();
+      for (const block of blocks) {
+        const codePaths = safeParseJson(block.code_paths, []);
+        for (const cp of codePaths) {
+          const prefix = cp.replace(/\*\*?\/?\*?$/, "");
+          if (symbol.file_path.startsWith(prefix)) {
+            lines.push(`## Building Block`, "", `Part of **${block.name}** (\`${block.id}\`)`, "");
+            break;
+          }
+        }
+      }
+      return textResult(lines.join("\n"));
+    }
+  );
+}
+
+// src/tools/get-dependency-graph.ts
+import { z as z14 } from "zod";
+function registerGetDependencyGraph(server, ctx) {
+  server.tool(
+    "arcbridge_get_dependency_graph",
+    "Get the dependency graph for a module or file. Shows imports, calls, type usage, and inheritance relationships between symbols.",
+    {
+      target_dir: z14.string().describe("Absolute path to the project directory"),
+      module: z14.string().describe(
+        "Module path relative to project root (e.g. 'src/lib/auth')"
+      ),
+      direction: z14.enum(["dependencies", "dependents", "both"]).default("both").describe(
+        "Graph direction: 'dependencies' (what this module uses), 'dependents' (what uses this module), or 'both'"
+      ),
+      depth: z14.number().int().min(1).max(5).default(1).describe("How many levels to traverse (default: 1, max: 5)"),
+      service: z14.string().optional().describe("Filter by service name (for multi-project solutions). Omit to search all services.")
+    },
+    async (params) => {
+      const maybeDb = ensureDb(ctx, params.target_dir);
+      if (!maybeDb) return notInitialized();
+      const db = maybeDb;
+      const depCount = db.prepare("SELECT COUNT(*) as count FROM dependencies").get().count;
+      if (depCount === 0) {
+        return getFileImportGraph(db, params.module, params.direction);
+      }
+      const edges = [];
+      const visited = /* @__PURE__ */ new Set();
+      const serviceFilter = params.service ? " AND s1.service = ?" : "";
+      const serviceFilter2 = params.service ? " AND s2.service = ?" : "";
+      function collectEdges(modulePath, currentDepth) {
+        if (currentDepth > params.depth || visited.has(modulePath)) return;
+        visited.add(modulePath);
+        const prefix = `${escapeLike(modulePath)}%`;
+        if (params.direction === "dependencies" || params.direction === "both") {
+          const queryArgs = [prefix];
+          if (params.service) queryArgs.push(params.service);
+          const deps = db.prepare(
+            `SELECT d.source_symbol as source_id, s1.name as source_name, s1.file_path as source_file,
+                      d.target_symbol as target_id, s2.name as target_name, s2.file_path as target_file,
+                      d.kind
+               FROM dependencies d
+               JOIN symbols s1 ON s1.id = d.source_symbol
+               JOIN symbols s2 ON s2.id = d.target_symbol
+               WHERE s1.file_path LIKE ? ESCAPE '\\'${serviceFilter}
+               ORDER BY d.kind, s2.name`
+          ).all(...queryArgs);
+          for (const dep of deps) {
+            const key = `${dep.source_id}->${dep.target_id}:${dep.kind}`;
+            if (!visited.has(key)) {
+              edges.push(dep);
+              visited.add(key);
+              if (currentDepth < params.depth) {
+                const targetDir = dep.target_file.replace(/\/[^/]+$/, "");
+                collectEdges(targetDir, currentDepth + 1);
+              }
+            }
+          }
+        }
+        if (params.direction === "dependents" || params.direction === "both") {
+          const queryArgs2 = [prefix];
+          if (params.service) queryArgs2.push(params.service);
+          const deps = db.prepare(
+            `SELECT d.source_symbol as source_id, s1.name as source_name, s1.file_path as source_file,
+                      d.target_symbol as target_id, s2.name as target_name, s2.file_path as target_file,
+                      d.kind
+               FROM dependencies d
+               JOIN symbols s1 ON s1.id = d.source_symbol
+               JOIN symbols s2 ON s2.id = d.target_symbol
+               WHERE s2.file_path LIKE ? ESCAPE '\\'${serviceFilter2}
+               ORDER BY d.kind, s1.name`
+          ).all(...queryArgs2);
+          for (const dep of deps) {
+            const key = `${dep.source_id}->${dep.target_id}:${dep.kind}`;
+            if (!visited.has(key)) {
+              edges.push(dep);
+              visited.add(key);
+              if (currentDepth < params.depth) {
+                const sourceDir = dep.source_file.replace(/\/[^/]+$/, "");
+                collectEdges(sourceDir, currentDepth + 1);
+              }
+            }
+          }
+        }
+      }
+      collectEdges(params.module, 1);
+      if (edges.length === 0) {
+        return textResult(
+          `No dependency edges found for module \`${params.module}\`.
+
+This may mean dependencies haven't been indexed yet (Phase 1b). Run \`arcbridge_reindex\` to update.`
+        );
+      }
+      return formatEdges(edges, params.module, params.direction);
+    }
+  );
+}
+function getFileImportGraph(db, modulePath, _direction) {
+  const prefix = `${escapeLike(modulePath)}%`;
+  const symbols = db.prepare(
+    `SELECT file_path, name, kind, is_exported
+       FROM symbols
+       WHERE file_path LIKE ? ESCAPE '\\'
+       ORDER BY file_path, name`
+  ).all(prefix);
+  if (symbols.length === 0) {
+    return textResult(
+      `No symbols found in module \`${modulePath}\`. Run \`arcbridge_reindex\` first.`
+    );
+  }
+  const byFile = /* @__PURE__ */ new Map();
+  for (const s of symbols) {
+    const list = byFile.get(s.file_path) ?? [];
+    list.push(s);
+    byFile.set(s.file_path, list);
+  }
+  const lines = [
+    `# Module: ${modulePath}`,
+    "",
+    `> Dependency edges not yet indexed. Showing file-level symbol map.`,
+    `> Run \`arcbridge_reindex\` after Phase 1b to see full dependency graph.`,
+    ""
+  ];
+  for (const [file, syms] of byFile) {
+    lines.push(`## \`${file}\``, "");
+    for (const s of syms) {
+      const exported = s.is_exported ? " (exported)" : "";
+      lines.push(`- \`${s.name}\` \u2014 ${s.kind}${exported}`);
+    }
+    lines.push("");
+  }
+  return {
+    content: [{ type: "text", text: lines.join("\n") }]
+  };
+}
+function formatEdges(edges, modulePath, direction) {
+  const byKind = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    const list = byKind.get(e.kind) ?? [];
+    list.push(e);
+    byKind.set(e.kind, list);
+  }
+  const lines = [
+    `# Dependency Graph: ${modulePath}`,
+    "",
+    `**Direction:** ${direction} | **Edges:** ${edges.length}`,
+    ""
+  ];
+  for (const [kind, kindEdges] of byKind) {
+    lines.push(`## ${kind}`, "");
+    for (const e of kindEdges) {
+      lines.push(
+        `- \`${e.source_name}\` (\`${e.source_file}\`) \u2192 \`${e.target_name}\` (\`${e.target_file}\`)`
+      );
+    }
+    lines.push("");
+  }
+  return {
+    content: [{ type: "text", text: lines.join("\n") }]
+  };
+}
+
+// src/tools/get-component-graph.ts
+import { z as z15 } from "zod";
+function registerGetComponentGraph(server, ctx) {
+  server.tool(
+    "arcbridge_get_component_graph",
+    "Get the React component graph: component hierarchy, props, state, context usage, and server/client boundaries.",
+    {
+      target_dir: z15.string().describe("Absolute path to the project directory"),
+      file_path: z15.string().optional().describe("Filter to components in a specific file or directory prefix"),
+      client_only: z15.boolean().optional().describe("Only show client components ('use client')"),
+      with_state: z15.boolean().optional().describe("Only show components that use state (useState/useReducer)")
+    },
+    async (params) => {
+      const db = ensureDb(ctx, params.target_dir);
+      if (!db) return notInitialized();
+      let query = `
+        SELECT
+          c.symbol_id, s.name, s.file_path,
+          c.is_client, c.is_server_action, c.has_state,
+          c.context_providers, c.context_consumers, c.props_type,
+          s.is_exported
+        FROM components c
+        JOIN symbols s ON c.symbol_id = s.id
+      `;
+      const conditions = [];
+      const queryParams = [];
+      if (params.file_path) {
+        conditions.push("s.file_path LIKE ? ESCAPE '\\'");
+        queryParams.push(`${escapeLike(params.file_path)}%`);
+      }
+      if (params.client_only) {
+        conditions.push("c.is_client = 1");
+      }
+      if (params.with_state) {
+        conditions.push("c.has_state = 1");
+      }
+      if (conditions.length > 0) {
+        query += " WHERE " + conditions.join(" AND ");
+      }
+      query += " ORDER BY s.file_path, s.name";
+      const components = db.prepare(query).all(...queryParams);
+      if (components.length === 0) {
+        return textResult("No components found. Run `arcbridge_reindex` to analyze React components.");
+      }
+      const renderEdges = db.prepare(
+        `SELECT
+            ss.name as source_name, ss.file_path as source_file,
+            st.name as target_name, st.file_path as target_file
+          FROM dependencies d
+          JOIN symbols ss ON d.source_symbol = ss.id
+          JOIN symbols st ON d.target_symbol = st.id
+          WHERE d.kind = 'renders'
+            AND d.source_symbol IN (SELECT symbol_id FROM components)
+            AND d.target_symbol IN (SELECT symbol_id FROM components)`
+      ).all();
+      const lines = [
+        `# Component Graph (${components.length} components)`,
+        ""
+      ];
+      const byFile = /* @__PURE__ */ new Map();
+      for (const c of components) {
+        const existing = byFile.get(c.file_path) ?? [];
+        existing.push(c);
+        byFile.set(c.file_path, existing);
+      }
+      for (const [file, comps] of byFile) {
+        lines.push(`## \`${file}\``, "");
+        for (const c of comps) {
+          const badges = [];
+          if (c.is_client) badges.push("client");
+          if (c.is_server_action) badges.push("server-action");
+          if (c.has_state) badges.push("stateful");
+          if (!c.is_exported) badges.push("internal");
+          const badgeStr = badges.length > 0 ? ` [${badges.join(", ")}]` : "";
+          lines.push(`### ${c.name}${badgeStr}`, "");
+          if (c.props_type) {
+            lines.push(`- **Props:** \`${c.props_type}\``);
+          }
+          const providers = safeParseJson(c.context_providers, []);
+          if (providers.length > 0) {
+            lines.push(`- **Provides context:** ${providers.join(", ")}`);
+          }
+          const consumers = safeParseJson(c.context_consumers, []);
+          if (consumers.length > 0) {
+            lines.push(`- **Consumes context:** ${consumers.join(", ")}`);
+          }
+          const children = renderEdges.filter((e) => e.source_name === c.name && e.source_file === file).map((e) => e.target_name);
+          if (children.length > 0) {
+            lines.push(`- **Renders:** ${children.join(", ")}`);
+          }
+          const parents = renderEdges.filter((e) => e.target_name === c.name && e.target_file === file).map((e) => e.source_name);
+          if (parents.length > 0) {
+            lines.push(`- **Rendered by:** ${parents.join(", ")}`);
+          }
+          lines.push("");
+        }
+      }
+      const clientCount = components.filter((c) => c.is_client).length;
+      const statefulCount = components.filter((c) => c.has_state).length;
+      lines.push(
+        "## Summary",
+        "",
+        `- **Total components:** ${components.length}`,
+        `- **Client components:** ${clientCount}`,
+        `- **Stateful components:** ${statefulCount}`,
+        `- **Render edges:** ${renderEdges.length}`,
+        ""
+      );
+      return textResult(lines.join("\n"));
+    }
+  );
+}
+
+// src/tools/get-route-map.ts
+import { z as z16 } from "zod";
+function registerGetRouteMap(server, ctx) {
+  server.tool(
+    "arcbridge_get_route_map",
+    "Get the route map: pages, layouts, API routes, and their hierarchy. Works with Next.js, ASP.NET controllers, and minimal APIs.",
+    {
+      target_dir: z16.string().describe("Absolute path to the project directory"),
+      kind: z16.enum(["page", "layout", "loading", "error", "not-found", "api-route", "middleware"]).optional().describe("Filter by route kind"),
+      route_prefix: z16.string().optional().describe("Filter by route path prefix (e.g. '/dashboard' or '/api/orders')"),
+      service: z16.string().optional().describe("Filter by service name (for multi-project solutions). Omit to show all services.")
+    },
+    async (params) => {
+      const db = ensureDb(ctx, params.target_dir);
+      if (!db) return notInitialized();
+      let query = "SELECT * FROM routes";
+      const conditions = [];
+      const queryParams = [];
+      if (params.service) {
+        conditions.push("service = ?");
+        queryParams.push(params.service);
+      }
+      if (params.kind) {
+        conditions.push("kind = ?");
+        queryParams.push(params.kind);
+      }
+      if (params.route_prefix) {
+        conditions.push("route_path LIKE ? ESCAPE '\\'");
+        queryParams.push(`${escapeLike(params.route_prefix)}%`);
+      }
+      if (conditions.length > 0) {
+        query += " WHERE " + conditions.join(" AND ");
+      }
+      query += " ORDER BY route_path, kind";
+      const routes = db.prepare(query).all(...queryParams);
+      if (routes.length === 0) {
+        return textResult("No routes found. Run `arcbridge_reindex` to analyze the Next.js app/ directory.");
+      }
+      const lines = [
+        `# Route Map (${routes.length} routes)`,
+        ""
+      ];
+      const byPath = /* @__PURE__ */ new Map();
+      for (const r of routes) {
+        const existing = byPath.get(r.route_path) ?? [];
+        existing.push(r);
+        byPath.set(r.route_path, existing);
+      }
+      for (const [path, routeGroup] of byPath) {
+        lines.push(`## \`${path}\``);
+        lines.push("");
+        for (const r of routeGroup) {
+          const parts = [`- **${r.kind}**`];
+          const methods = safeParseJson(r.http_methods, []);
+          if (methods.length > 0) {
+            parts.push(`Methods: ${methods.join(", ")}`);
+          }
+          if (r.has_auth) {
+            parts.push("(auth)");
+          }
+          if (r.parent_layout) {
+            parts.push(`Layout: \`${r.parent_layout}\``);
+          }
+          lines.push(parts.join(" | "));
+        }
+        lines.push("");
+      }
+      const pages = routes.filter((r) => r.kind === "page").length;
+      const layouts = routes.filter((r) => r.kind === "layout").length;
+      const apiRoutes = routes.filter((r) => r.kind === "api-route").length;
+      const loadingStates = routes.filter((r) => r.kind === "loading").length;
+      lines.push(
+        "## Summary",
+        "",
+        `- **Pages:** ${pages}`,
+        `- **Layouts:** ${layouts}`,
+        `- **API routes:** ${apiRoutes}`,
+        `- **Loading states:** ${loadingStates}`,
+        ""
+      );
+      return textResult(lines.join("\n"));
+    }
+  );
+}
+
+// src/tools/get-boundary-analysis.ts
+import { z as z17 } from "zod";
+function registerGetBoundaryAnalysis(server, ctx) {
+  server.tool(
+    "arcbridge_get_boundary_analysis",
+    "Analyze server/client boundaries in a Next.js project. Identifies client components, server components, server actions, and potential boundary violations.",
+    {
+      target_dir: z17.string().describe("Absolute path to the project directory")
+    },
+    async (params) => {
+      const db = ensureDb(ctx, params.target_dir);
+      if (!db) return notInitialized();
+      const components = db.prepare(
+        `SELECT c.symbol_id, s.name, s.file_path,
+            c.is_client, c.is_server_action, c.has_state
+          FROM components c
+          JOIN symbols s ON c.symbol_id = s.id
+          ORDER BY s.file_path`
+      ).all();
+      if (components.length === 0) {
+        return textResult("No components found. Run `arcbridge_reindex` to analyze server/client boundaries.");
+      }
+      const crossEdges = db.prepare(
+        `SELECT
+            ss.name as source_name, ss.file_path as source_file, cs.is_client as source_is_client,
+            st.name as target_name, st.file_path as target_file, ct.is_client as target_is_client,
+            d.kind
+          FROM dependencies d
+          JOIN symbols ss ON d.source_symbol = ss.id
+          JOIN symbols st ON d.target_symbol = st.id
+          LEFT JOIN components cs ON d.source_symbol = cs.symbol_id
+          LEFT JOIN components ct ON d.target_symbol = ct.symbol_id
+          WHERE d.kind IN ('renders', 'imports')
+            AND (cs.symbol_id IS NOT NULL OR ct.symbol_id IS NOT NULL)`
+      ).all();
+      const clientComponents = components.filter((c) => c.is_client);
+      const serverComponents = components.filter((c) => !c.is_client && !c.is_server_action);
+      const serverActions = components.filter((c) => c.is_server_action);
+      const lines = [
+        "# Server/Client Boundary Analysis",
+        "",
+        "## Overview",
+        "",
+        `- **Server components:** ${serverComponents.length}`,
+        `- **Client components:** ${clientComponents.length}`,
+        `- **Server actions:** ${serverActions.length}`,
+        ""
+      ];
+      if (clientComponents.length > 0) {
+        lines.push("## Client Components (`'use client'`)", "");
+        for (const c of clientComponents) {
+          const badges = [];
+          if (c.has_state) badges.push("stateful");
+          const badgeStr = badges.length > 0 ? ` [${badges.join(", ")}]` : "";
+          lines.push(`- \`${c.file_path}\` \u2192 **${c.name}**${badgeStr}`);
+        }
+        lines.push("");
+      }
+      if (serverComponents.length > 0) {
+        lines.push("## Server Components (default)", "");
+        for (const c of serverComponents) {
+          lines.push(`- \`${c.file_path}\` \u2192 **${c.name}**`);
+        }
+        lines.push("");
+      }
+      if (serverActions.length > 0) {
+        lines.push("## Server Actions (`'use server'`)", "");
+        for (const c of serverActions) {
+          lines.push(`- \`${c.file_path}\` \u2192 **${c.name}**`);
+        }
+        lines.push("");
+      }
+      const boundaryViolations = [];
+      const validCrossings = [];
+      for (const edge of crossEdges) {
+        if (edge.kind !== "renders") continue;
+        const sourceIsClient = edge.source_is_client === 1;
+        const targetIsClient = edge.target_is_client === 1;
+        if (sourceIsClient === targetIsClient) continue;
+        if (!sourceIsClient && targetIsClient) {
+          validCrossings.push(
+            `- **${edge.source_name}** (server) \u2192 **${edge.target_name}** (client)`
+          );
+        } else if (sourceIsClient && !targetIsClient) {
+          boundaryViolations.push(
+            `- **${edge.source_name}** (client, \`${edge.source_file}\`) renders **${edge.target_name}** (server, \`${edge.target_file}\`)`
+          );
+        }
+      }
+      if (validCrossings.length > 0) {
+        lines.push("## Boundary Crossings (valid)", "");
+        lines.push(...validCrossings, "");
+      }
+      if (boundaryViolations.length > 0) {
+        lines.push("## Potential Boundary Violations", "");
+        lines.push(
+          "These client components appear to render server components, which is not allowed in Next.js App Router:",
+          "",
+          ...boundaryViolations,
+          ""
+        );
+      } else {
+        lines.push("## Boundary Check", "");
+        lines.push("No boundary violations detected.", "");
+      }
+      return textResult(lines.join("\n"));
+    }
+  );
+}
+
+// src/tools/check-drift.ts
+import { z as z18 } from "zod";
+import { detectDrift, writeDriftLog } from "@arcbridge/core";
+function registerCheckDrift(server, ctx) {
+  server.tool(
+    "arcbridge_check_drift",
+    "Detect architecture drift: undocumented modules, missing code paths, cross-block dependency violations, and stale ADR references.",
+    {
+      target_dir: z18.string().describe("Absolute path to the project directory"),
+      persist: z18.boolean().default(true).describe("Write findings to drift_log table (default: true)")
+    },
+    async (params) => {
+      const db = ensureDb(ctx, params.target_dir);
+      if (!db) return notInitialized();
+      const entries = detectDrift(db);
+      if (params.persist) {
+        writeDriftLog(db, entries);
+      }
+      if (entries.length === 0) {
+        return textResult(
+          "# Drift Check\n\nNo architecture drift detected. Code aligns with documented building blocks."
+        );
+      }
+      const byKind = /* @__PURE__ */ new Map();
+      for (const e of entries) {
+        const existing = byKind.get(e.kind) ?? [];
+        existing.push(e);
+        byKind.set(e.kind, existing);
+      }
+      const kindLabels = {
+        undocumented_module: "Undocumented Modules",
+        missing_module: "Missing Modules",
+        dependency_violation: "Dependency Violations",
+        stale_adr: "Stale ADR References",
+        unlinked_test: "Unlinked Tests"
+      };
+      const severityIcon = {
+        error: "ERROR",
+        warning: "WARN",
+        info: "INFO"
+      };
+      const lines = [
+        `# Drift Check (${entries.length} issues)`,
+        ""
+      ];
+      const errors = entries.filter((e) => e.severity === "error").length;
+      const warnings = entries.filter((e) => e.severity === "warning").length;
+      const infos = entries.filter((e) => e.severity === "info").length;
+      lines.push(
+        `**${errors}** errors, **${warnings}** warnings, **${infos}** info`,
+        ""
+      );
+      for (const [kind, items] of byKind) {
+        lines.push(`## ${kindLabels[kind] ?? kind}`, "");
+        for (const item of items) {
+          const icon = severityIcon[item.severity] ?? item.severity;
+          lines.push(`- [${icon}] ${item.description}`);
+        }
+        lines.push("");
+      }
+      if (params.persist) {
+        lines.push(
+          "---",
+          "*Findings saved to drift_log. Use `arcbridge_update_task` or resolve drift by updating `.arcbridge/arc42/05-building-blocks.md`.*",
+          ""
+        );
+      }
+      return textResult(lines.join("\n"));
+    }
+  );
+}
+
+// src/tools/get-guidance.ts
+import { z as z19 } from "zod";
+function registerGetGuidance(server, ctx) {
+  server.tool(
+    "arcbridge_get_guidance",
+    "Get context-aware architectural guidance for a code change. Surfaces relevant quality scenarios, patterns, constraints, and questions to consider.",
+    {
+      target_dir: z19.string().describe("Absolute path to the project directory"),
+      file_path: z19.string().optional().describe("File path you're working on (to determine building block and context)"),
+      action: z19.enum([
+        "adding-component",
+        "adding-api-route",
+        "adding-hook",
+        "modifying-auth",
+        "new-dependency",
+        "refactoring",
+        "general"
+      ]).default("general").describe("Type of change you're making")
+    },
+    async (params) => {
+      const db = ensureDb(ctx, params.target_dir);
+      if (!db) return notInitialized();
+      const lines = ["# Architectural Guidance", ""];
+      let matchedBlock = null;
+      if (params.file_path) {
+        const blocks = db.prepare("SELECT id, name, responsibility, code_paths, interfaces FROM building_blocks").all();
+        for (const block of blocks) {
+          const paths = safeParseJson(block.code_paths, []);
+          for (const cp of paths) {
+            const prefix = normalizeCodePath(cp);
+            if (params.file_path.startsWith(prefix) || params.file_path === prefix) {
+              matchedBlock = block;
+              break;
+            }
+          }
+          if (matchedBlock) break;
+        }
+        if (matchedBlock) {
+          lines.push(
+            `## Building Block: ${matchedBlock.name} (\`${matchedBlock.id}\`)`,
+            "",
+            `**Responsibility:** ${matchedBlock.responsibility}`,
+            ""
+          );
+          const interfaces = safeParseJson(matchedBlock.interfaces, []);
+          if (interfaces.length > 0) {
+            lines.push(
+              `**Declared interfaces:** ${interfaces.join(", ")}`,
+              ""
+            );
+          }
+        } else {
+          lines.push(
+            "## Warning: Unmapped File",
+            "",
+            `\`${params.file_path}\` is not mapped to any building block. Consider updating \`.arcbridge/arc42/05-building-blocks.md\` to include this path.`,
+            ""
+          );
+        }
+        const existingSymbols = db.prepare(
+          "SELECT name, kind, file_path FROM symbols WHERE file_path LIKE ? ESCAPE '\\' ORDER BY kind, name LIMIT 20"
+        ).all(`${escapeLike(params.file_path.replace(/\/[^/]+$/, "/"))}%`);
+        if (existingSymbols.length > 0) {
+          const byKind = /* @__PURE__ */ new Map();
+          for (const s of existingSymbols) {
+            const existing = byKind.get(s.kind) ?? [];
+            existing.push(s.name);
+            byKind.set(s.kind, existing);
+          }
+          lines.push("## Existing Patterns Nearby", "");
+          for (const [kind, names] of byKind) {
+            lines.push(`- **${kind}s:** ${names.join(", ")}`);
+          }
+          lines.push("");
+        }
+      }
+      const scenarios = db.prepare(
+        "SELECT id, name, category, scenario, expected, priority FROM quality_scenarios ORDER BY priority, category"
+      ).all();
+      const relevantScenarios = filterRelevantScenarios(
+        scenarios,
+        params.action,
+        matchedBlock?.id ?? null
+      );
+      if (relevantScenarios.length > 0) {
+        lines.push("## Relevant Quality Scenarios", "");
+        for (const s of relevantScenarios) {
+          lines.push(
+            `### ${s.id}: ${s.name} [${s.category}] (${s.priority})`,
+            "",
+            `**Scenario:** ${s.scenario}`,
+            `**Expected:** ${s.expected}`,
+            ""
+          );
+        }
+      }
+      if (matchedBlock) {
+        const tasks = db.prepare(
+          "SELECT id, title, status, building_block FROM tasks WHERE building_block = ? AND status IN ('todo', 'in-progress')"
+        ).all(matchedBlock.id);
+        if (tasks.length > 0) {
+          lines.push("## Active Tasks in This Block", "");
+          for (const t of tasks) {
+            lines.push(`- [${t.status}] ${t.id}: ${t.title}`);
+          }
+          lines.push("");
+        }
+      }
+      const adrRows = db.prepare("SELECT id, title, status, decision, affected_blocks, affected_files FROM adrs").all();
+      const relevantAdrs = adrRows.filter((adr) => {
+        if (params.file_path) {
+          const affectedFiles = safeParseJson(adr.affected_files, []);
+          if (affectedFiles.some((f) => params.file_path.includes(f) || f.includes(params.file_path))) return true;
+        }
+        if (matchedBlock) {
+          const affectedBlocks = safeParseJson(adr.affected_blocks, []);
+          if (affectedBlocks.includes(matchedBlock.id)) return true;
+        }
+        return false;
+      });
+      if (relevantAdrs.length > 0) {
+        lines.push("## Relevant ADRs", "");
+        for (const adr of relevantAdrs) {
+          lines.push(`### ${adr.id}: ${adr.title} [${adr.status}]`, "");
+          lines.push(`**Decision:** ${adr.decision}`, "");
+        }
+      }
+      const driftEntries = params.file_path ? db.prepare(
+        "SELECT kind, description FROM drift_log WHERE resolution IS NULL AND (affected_file = ? OR affected_block = ?)"
+      ).all(params.file_path, matchedBlock?.id ?? "") : db.prepare(
+        "SELECT kind, description FROM drift_log WHERE resolution IS NULL LIMIT 5"
+      ).all();
+      if (driftEntries.length > 0) {
+        lines.push("## Unresolved Drift", "");
+        for (const d of driftEntries) {
+          lines.push(`- [${d.kind}] ${d.description}`);
+        }
+        lines.push("");
+      }
+      const actionGuidance = getActionGuidance(params.action);
+      if (actionGuidance) {
+        lines.push("## Guidance", "", actionGuidance, "");
+      }
+      return textResult(lines.join("\n"));
+    }
+  );
+}
+function filterRelevantScenarios(scenarios, action, _blockId) {
+  const categoryMap = {
+    "adding-component": ["accessibility", "performance", "maintainability"],
+    "adding-api-route": ["security", "performance", "reliability"],
+    "adding-hook": ["maintainability", "performance"],
+    "modifying-auth": ["security", "reliability"],
+    "new-dependency": ["maintainability", "performance", "security"],
+    "refactoring": ["maintainability", "reliability"],
+    "general": []
+  };
+  const relevantCategories = categoryMap[action] ?? [];
+  if (relevantCategories.length === 0) {
+    return scenarios.filter((s) => s.priority === "must");
+  }
+  return scenarios.filter((s) => relevantCategories.includes(s.category));
+}
+function getActionGuidance(action) {
+  const guidance = {
+    "adding-component": "- Follow existing component patterns in this directory\n- Add props interface alongside the component\n- Consider server vs. client: does this need interactivity (`'use client'`)?\n- Check accessibility: keyboard navigation, ARIA labels, screen reader support\n- **Arc42:** If this introduces a new UI pattern, document it in `08-crosscutting.md`",
+    "adding-api-route": "- Ensure authentication middleware covers this route\n- Validate all input with zod or equivalent\n- Follow existing error response patterns\n- Consider rate limiting for public endpoints\n- If this introduces a new API pattern or convention, document it in an ADR\n- **Arc42:** Update `03-context.md` if this route exposes a new external integration; update `06-runtime-views.md` if it's a key workflow",
+    "adding-hook": "- Follow the `use` prefix convention\n- Keep hooks focused \u2014 one responsibility per hook\n- Consider memoization for expensive computations\n- Document the hook's return type",
+    "modifying-auth": "- Check all API routes still have auth coverage after changes\n- Verify no secrets leak to client components\n- Test edge cases: expired tokens, revoked sessions, role changes\n- Update security quality scenarios if behavior changes\n- Document the auth strategy and any changes in an ADR \u2014 auth decisions are critical to trace\n- **Arc42:** Update `08-crosscutting.md` with the auth pattern; update `06-runtime-views.md` with the auth flow",
+    "new-dependency": "- Document the dependency rationale in an ADR\n- Check bundle size impact (client-side deps)\n- Verify the dependency doesn't introduce known CVEs\n- Ensure the dependency's license is compatible\n- **Arc42:** If this dependency introduces a new external system, update `03-context.md`",
+    "refactoring": "- Ensure no cross-block boundary violations are introduced\n- Maintain existing public API contracts\n- Run tests before and after to verify behavior preservation\n- Check that no quality scenarios regress\n- If the refactoring changes architectural patterns, update or create an ADR to explain why\n- **Arc42:** Update `05-building-blocks.md` if module structure changed; update `08-crosscutting.md` if patterns changed",
+    "general": "- Check `arcbridge_get_relevant_adrs` for existing decisions that may constrain this change\n- If you're choosing between approaches, document the decision in an ADR\n- **Arc42:** Consider which documentation sections may need updating (check `.arcbridge/arc42/` \u2014 especially `05-building-blocks.md` and `08-crosscutting.md`)"
+  };
+  return guidance[action] ?? null;
+}
+
+// src/tools/get-open-questions.ts
+import { z as z20 } from "zod";
+function registerGetOpenQuestions(server, ctx) {
+  server.tool(
+    "arcbridge_get_open_questions",
+    "Surface architectural gaps: untested quality scenarios, building blocks without boundaries, unresolved drift, and tasks missing acceptance criteria.",
+    {
+      target_dir: z20.string().describe("Absolute path to the project directory"),
+      scope: z20.string().optional().describe("Focus scope: 'current-phase', 'building-block:<id>', or omit for project-wide")
+    },
+    async (params) => {
+      const db = ensureDb(ctx, params.target_dir);
+      if (!db) return notInitialized();
+      const lines = ["# Open Questions & Gaps", ""];
+      let totalGaps = 0;
+      const scenarios = db.prepare(
+        "SELECT id, name, category, status, priority, linked_tests, linked_code FROM quality_scenarios ORDER BY priority, category"
+      ).all();
+      const untestedMust = scenarios.filter(
+        (s) => s.priority === "must" && (s.status === "untested" || s.status === "failing")
+      );
+      const untestedShould = scenarios.filter(
+        (s) => s.priority === "should" && (s.status === "untested" || s.status === "failing")
+      );
+      const unlinked = scenarios.filter((s) => {
+        const tests = safeParseJson(s.linked_tests, []);
+        return tests.length === 0;
+      });
+      if (untestedMust.length > 0) {
+        lines.push("## Critical: Untested/Failing Must-Have Scenarios", "");
+        for (const s of untestedMust) {
+          lines.push(`- **${s.id}: ${s.name}** [${s.category}] \u2014 ${s.status}`);
+          totalGaps++;
+        }
+        lines.push("");
+      }
+      if (untestedShould.length > 0) {
+        lines.push("## Untested/Failing Should-Have Scenarios", "");
+        for (const s of untestedShould) {
+          lines.push(`- ${s.id}: ${s.name} [${s.category}] \u2014 ${s.status}`);
+          totalGaps++;
+        }
+        lines.push("");
+      }
+      if (unlinked.length > 0) {
+        lines.push("## Scenarios Without Linked Tests", "");
+        for (const s of unlinked) {
+          lines.push(`- ${s.id}: ${s.name} [${s.category}] (${s.priority})`);
+          totalGaps++;
+        }
+        lines.push("");
+      }
+      const blocks = db.prepare("SELECT id, name, code_paths, description FROM building_blocks").all();
+      const emptyBlocks = blocks.filter((b) => {
+        const paths = safeParseJson(b.code_paths, []);
+        return paths.length === 0;
+      });
+      const undescribed = blocks.filter(
+        (b) => !b.description || b.description.trim().length === 0
+      );
+      if (emptyBlocks.length > 0) {
+        lines.push("## Building Blocks Without Code Paths", "");
+        for (const b of emptyBlocks) {
+          lines.push(`- **${b.name}** (\`${b.id}\`) \u2014 no code_paths defined`);
+          totalGaps++;
+        }
+        lines.push("");
+      }
+      if (undescribed.length > 0) {
+        lines.push("## Building Blocks Without Descriptions", "");
+        for (const b of undescribed) {
+          lines.push(`- **${b.name}** (\`${b.id}\`)`);
+          totalGaps++;
+        }
+        lines.push("");
+      }
+      const drift = db.prepare(
+        "SELECT kind, severity, description FROM drift_log WHERE resolution IS NULL ORDER BY severity DESC"
+      ).all();
+      if (drift.length > 0) {
+        lines.push("## Unresolved Architecture Drift", "");
+        for (const d of drift) {
+          lines.push(`- [${d.severity.toUpperCase()}] ${d.description}`);
+          totalGaps++;
+        }
+        lines.push("");
+      }
+      let phaseTasks = [];
+      if (params.scope === "current-phase" || !params.scope) {
+        const currentPhase = db.prepare("SELECT id, name, status FROM phases WHERE status = 'in-progress' LIMIT 1").get();
+        if (currentPhase) {
+          phaseTasks = db.prepare("SELECT id, title, status, acceptance_criteria FROM tasks WHERE phase_id = ?").all(currentPhase.id);
+        }
+      }
+      const tasksWithoutCriteria = phaseTasks.filter((t) => {
+        const criteria = safeParseJson(t.acceptance_criteria, []);
+        return criteria.length === 0 && t.status !== "done";
+      });
+      if (tasksWithoutCriteria.length > 0) {
+        lines.push("## Tasks Without Acceptance Criteria", "");
+        for (const t of tasksWithoutCriteria) {
+          lines.push(`- ${t.id}: ${t.title} (${t.status})`);
+          totalGaps++;
+        }
+        lines.push("");
+      }
+      if (totalGaps === 0) {
+        return textResult(
+          "# Open Questions & Gaps\n\nNo significant architectural gaps found. Quality scenarios are linked, building blocks are defined, and no drift is unresolved."
+        );
+      }
+      lines[0] = `# Open Questions & Gaps (${totalGaps} items)`;
+      return textResult(lines.join("\n"));
+    }
+  );
+}
+
+// src/tools/propose-arc42-update.ts
+import { z as z21 } from "zod";
+import {
+  resolveRef,
+  getChangedFiles,
+  getHeadSha,
+  setSyncCommit
+} from "@arcbridge/core";
+function registerProposeArc42Update(server, ctx) {
+  server.tool(
+    "arcbridge_propose_arc42_update",
+    "Analyze code changes since a reference point and generate specific, actionable proposals for updating arc42 documentation.",
+    {
+      target_dir: z21.string().describe("Absolute path to the project directory"),
+      changes_since: z21.string().default("last-sync").describe("Reference point: 'last-commit', 'last-sync', 'last-phase', or a git ref"),
+      update_sync_point: z21.boolean().default(false).describe("Update the stored sync commit to HEAD after generating proposals")
+    },
+    async (params) => {
+      const db = ensureDb(ctx, params.target_dir);
+      if (!db) return notInitialized();
+      const projectRoot = ctx.projectRoot ?? params.target_dir;
+      const ref = resolveRef(projectRoot, params.changes_since, db);
+      const changedFiles = getChangedFiles(projectRoot, ref.sha);
+      if (changedFiles.length === 0) {
+        return textResult(
+          `# Arc42 Update Proposals
+
+No code changes detected since ${ref.label}. Documentation is up to date.`
+        );
+      }
+      const blocks = db.prepare("SELECT id, name, code_paths, interfaces, description FROM building_blocks").all();
+      const proposals = generateProposals(db, blocks, changedFiles, projectRoot);
+      const lines = [
+        `# Arc42 Update Proposals`,
+        "",
+        `**Changes since:** ${ref.label}`,
+        `**Files changed:** ${changedFiles.length}`,
+        `**Proposals:** ${proposals.length}`,
+        ""
+      ];
+      if (proposals.length === 0) {
+        lines.push(
+          "No documentation updates needed \u2014 all changes are within documented building blocks and don't introduce new patterns."
+        );
+      } else {
+        const bySection = /* @__PURE__ */ new Map();
+        for (const p of proposals) {
+          const existing = bySection.get(p.section) ?? [];
+          existing.push(p);
+          bySection.set(p.section, existing);
+        }
+        for (const [section, items] of bySection) {
+          lines.push(`## ${section}`, "");
+          for (const item of items) {
+            lines.push(`### ${item.title}`, "");
+            lines.push(item.description, "");
+            if (item.suggestedChange) {
+              lines.push("**Suggested change:**", "", item.suggestedChange, "");
+            }
+          }
+        }
+      }
+      if (params.update_sync_point) {
+        const headSha = getHeadSha(projectRoot);
+        if (headSha) {
+          setSyncCommit(db, "last_sync_commit", headSha);
+          lines.push("---", `*Sync point updated to ${headSha.slice(0, 7)}.*`, "");
+        }
+      }
+      return textResult(lines.join("\n"));
+    }
+  );
+}
+function generateProposals(db, blocks, changedFiles, _projectRoot) {
+  const proposals = [];
+  const fileToBlock = /* @__PURE__ */ new Map();
+  const unmappedFiles = [];
+  for (const cf of changedFiles) {
+    if (cf.status === "deleted") continue;
+    let matched = false;
+    for (const block of blocks) {
+      const paths = safeParseJson(block.code_paths, []);
+      for (const cp of paths) {
+        const prefix = normalizeCodePath(cp);
+        if (cf.path.startsWith(prefix) || cf.path === prefix) {
+          fileToBlock.set(cf.path, block);
+          matched = true;
+          break;
+        }
+      }
+      if (matched) break;
+    }
+    if (!matched) {
+      unmappedFiles.push(cf);
+    }
+  }
+  if (unmappedFiles.length > 0) {
+    const byDir = /* @__PURE__ */ new Map();
+    for (const f of unmappedFiles) {
+      const dir = f.path.replace(/\/[^/]+$/, "/");
+      const existing = byDir.get(dir) ?? [];
+      existing.push(f);
+      byDir.set(dir, existing);
+    }
+    for (const [dir, files] of byDir) {
+      const fileList = files.map((f) => `\`${f.path}\``).join(", ");
+      proposals.push({
+        section: "05 Building Block View",
+        title: `Unmapped files in \`${dir}\``,
+        description: `${files.length} file(s) in \`${dir}\` are not covered by any building block: ${fileList}`,
+        suggestedChange: `Add \`${dir}\` to an existing building block's \`code_paths\`, or create a new building block for this directory.`
+      });
+    }
+  }
+  const addedOrModified = changedFiles.filter(
+    (f) => f.status === "added" || f.status === "modified"
+  );
+  for (const cf of addedOrModified) {
+    const block = fileToBlock.get(cf.path);
+    if (!block) continue;
+    const symbols = db.prepare(
+      "SELECT name, kind, is_exported FROM symbols WHERE file_path = ? AND is_exported = 1"
+    ).all(cf.path);
+    if (symbols.length === 0) continue;
+    for (const sym of symbols) {
+      const consumers = findCrossBlockConsumers(
+        db,
+        `${cf.path}::${sym.name}#${sym.kind}`,
+        block.id,
+        blocks
+      );
+      if (consumers.length > 0) {
+        const consumerNames = consumers.map((c) => `\`${c}\``).join(", ");
+        proposals.push({
+          section: "05 Building Block View",
+          title: `New cross-block interface: \`${sym.name}\``,
+          description: `Exported ${sym.kind} \`${sym.name}\` in block \`${block.name}\` is consumed by blocks: ${consumerNames}. This should be documented as an interface.`,
+          suggestedChange: `Add \`${sym.name}\` to the interfaces section of building block \`${block.id}\` in \`.arcbridge/arc42/05-building-blocks.md\`.`
+        });
+      }
+    }
+  }
+  const deletedFiles = changedFiles.filter((f) => f.status === "deleted");
+  for (const cf of deletedFiles) {
+    for (const block of blocks) {
+      const paths = safeParseJson(block.code_paths, []);
+      for (const cp of paths) {
+        const prefix = normalizeCodePath(cp);
+        if (cf.path.startsWith(prefix)) {
+          const remaining = db.prepare("SELECT 1 FROM symbols WHERE file_path LIKE ? LIMIT 1").get(`${prefix}%`);
+          if (!remaining) {
+            proposals.push({
+              section: "05 Building Block View",
+              title: `Empty code path in \`${block.name}\``,
+              description: `All files under \`${cp}\` in block \`${block.name}\` (${block.id}) have been deleted. The code_path no longer matches any code.`,
+              suggestedChange: `Remove \`${cp}\` from building block \`${block.id}\`, or update it to reflect the new file structure.`
+            });
+          }
+          break;
+        }
+      }
+    }
+  }
+  const routeFiles = addedOrModified.filter(
+    (f) => f.path.includes("/app/") && /\/(page|layout|route)\.(ts|tsx|js|jsx)$/.test(f.path)
+  );
+  if (routeFiles.length > 0) {
+    const routeList = routeFiles.map((f) => `\`${f.path}\``).join(", ");
+    proposals.push({
+      section: "06 Runtime View",
+      title: "New route files detected",
+      description: `${routeFiles.length} route file(s) were added or modified: ${routeList}. Consider updating the runtime view to reflect new user flows.`,
+      suggestedChange: null
+    });
+  }
+  return proposals;
+}
+function findCrossBlockConsumers(db, symbolId, sourceBlockId, blocks) {
+  const consumers = db.prepare(
+    `SELECT DISTINCT s.file_path
+       FROM dependencies d
+       JOIN symbols s ON d.source_symbol = s.id
+       WHERE d.target_symbol = ?
+         AND d.kind IN ('imports', 'calls', 'renders')`
+  ).all(symbolId);
+  const consumerBlocks = /* @__PURE__ */ new Set();
+  for (const { file_path } of consumers) {
+    for (const block of blocks) {
+      if (block.id === sourceBlockId) continue;
+      const paths = safeParseJson(block.code_paths, []);
+      for (const cp of paths) {
+        const prefix = normalizeCodePath(cp);
+        if (file_path.startsWith(prefix)) {
+          consumerBlocks.add(block.name);
+          break;
+        }
+      }
+    }
+  }
+  return [...consumerBlocks];
+}
+
+// src/tools/get-practice-review.ts
+import { z as z22 } from "zod";
+import {
+  resolveRef as resolveRef2,
+  getChangedFiles as getChangedFiles2,
+  detectDrift as detectDrift2
+} from "@arcbridge/core";
+function registerGetPracticeReview(server, ctx) {
+  server.tool(
+    "arcbridge_get_practice_review",
+    "Structured, practice-aware review of recent code changes across 5 dimensions: Architecture, Security, Testing, Documentation, and Complexity.",
+    {
+      target_dir: z22.string().describe("Absolute path to the project directory"),
+      since: z22.string().default("last-commit").describe("Reference point: 'last-commit', 'last-session', or 'last-phase'")
+    },
+    async (params) => {
+      const db = ensureDb(ctx, params.target_dir);
+      if (!db) return notInitialized();
+      const projectRoot = ctx.projectRoot ?? params.target_dir;
+      const ref = resolveRef2(projectRoot, params.since, db);
+      const changedFiles = getChangedFiles2(projectRoot, ref.sha);
+      if (changedFiles.length === 0) {
+        return textResult(
+          `# Practice Review
+
+No changes detected since ${ref.label}. Nothing to review.`
+        );
+      }
+      const lines = [
+        "# Practice Review",
+        "",
+        `**Since:** ${ref.label}`,
+        `**Files changed:** ${changedFiles.length}`,
+        ""
+      ];
+      const findings = [];
+      reviewArchitecture(db, changedFiles, findings);
+      reviewSecurity(db, changedFiles, findings);
+      reviewTesting(db, changedFiles, findings);
+      reviewDocumentation(db, changedFiles, findings);
+      reviewComplexity(db, changedFiles, findings);
+      if (findings.length === 0) {
+        lines.push("All checks passed. No issues found across the 5 practice dimensions.");
+        return textResult(lines.join("\n"));
+      }
+      const byDimension = /* @__PURE__ */ new Map();
+      for (const f of findings) {
+        const existing = byDimension.get(f.dimension) ?? [];
+        existing.push(f);
+        byDimension.set(f.dimension, existing);
+      }
+      const dimensionIcons = {
+        Architecture: "1",
+        Security: "2",
+        Testing: "3",
+        Documentation: "4",
+        Complexity: "5"
+      };
+      const errors = findings.filter((f) => f.severity === "error").length;
+      const warnings = findings.filter((f) => f.severity === "warning").length;
+      const infos = findings.filter((f) => f.severity === "info").length;
+      lines.push(
+        `**${errors}** errors, **${warnings}** warnings, **${infos}** info`,
+        ""
+      );
+      for (const dim of ["Architecture", "Security", "Testing", "Documentation", "Complexity"]) {
+        const items = byDimension.get(dim);
+        const num = dimensionIcons[dim] ?? "?";
+        if (!items || items.length === 0) {
+          lines.push(`## ${num}. ${dim} \u2713`, "", `No issues found.`, "");
+          continue;
+        }
+        lines.push(`## ${num}. ${dim} (${items.length} findings)`, "");
+        for (const item of items) {
+          const icon = item.severity === "error" ? "ERROR" : item.severity === "warning" ? "WARN" : "INFO";
+          lines.push(`- [${icon}] ${item.description}`);
+          if (item.action) {
+            lines.push(`  \u2192 **Action:** ${item.action}`);
+          }
+        }
+        lines.push("");
+      }
+      return textResult(lines.join("\n"));
+    }
+  );
+}
+function reviewArchitecture(db, changedFiles, findings) {
+  const blocks = db.prepare("SELECT id, name, code_paths, interfaces FROM building_blocks").all();
+  if (blocks.length === 0) return;
+  const changedPaths = new Set(
+    changedFiles.filter((f) => f.status !== "deleted").map((f) => f.path)
+  );
+  const changedByBlock = /* @__PURE__ */ new Map();
+  const unmapped = [];
+  for (const path of changedPaths) {
+    let matched = false;
+    for (const block of blocks) {
+      const paths = safeParseJson(block.code_paths, []);
+      for (const cp of paths) {
+        const prefix = normalizeCodePath(cp);
+        if (path.startsWith(prefix)) {
+          const existing = changedByBlock.get(block.id) ?? [];
+          existing.push(path);
+          changedByBlock.set(block.id, existing);
+          matched = true;
+          break;
+        }
+      }
+      if (matched) break;
+    }
+    if (!matched) unmapped.push(path);
+  }
+  if (unmapped.length > 0) {
+    findings.push({
+      dimension: "Architecture",
+      severity: "warning",
+      description: `${unmapped.length} changed file(s) not mapped to any building block: ${unmapped.slice(0, 3).map((f) => `\`${f}\``).join(", ")}${unmapped.length > 3 ? ` and ${unmapped.length - 3} more` : ""}`,
+      action: "Map these files to building blocks in `.arcbridge/arc42/05-building-blocks.md`"
+    });
+  }
+  for (const [blockId, files] of changedByBlock) {
+    const block = blocks.find((b) => b.id === blockId);
+    if (!block) continue;
+    const declaredInterfaces = new Set(safeParseJson(block.interfaces, []));
+    for (const filePath of files) {
+      const outgoing = db.prepare(
+        `SELECT DISTINCT st.file_path as target_file
+           FROM dependencies d
+           JOIN symbols ss ON d.source_symbol = ss.id
+           JOIN symbols st ON d.target_symbol = st.id
+           WHERE ss.file_path = ?
+             AND d.kind IN ('imports', 'calls', 'renders')`
+      ).all(filePath);
+      for (const { target_file } of outgoing) {
+        for (const targetBlock of blocks) {
+          if (targetBlock.id === blockId) continue;
+          const tPaths = safeParseJson(targetBlock.code_paths, []);
+          for (const cp of tPaths) {
+            const prefix = normalizeCodePath(cp);
+            if (target_file.startsWith(prefix) && !declaredInterfaces.has(targetBlock.id)) {
+              findings.push({
+                dimension: "Architecture",
+                severity: "error",
+                description: `\`${filePath}\` in block \`${block.name}\` depends on block \`${targetBlock.name}\` without declaring it as an interface.`,
+                action: `Add \`${targetBlock.id}\` to the interfaces of block \`${blockId}\``
+              });
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+}
+function reviewSecurity(db, changedFiles, findings) {
+  const changedPaths = changedFiles.filter((f) => f.status !== "deleted").map((f) => f.path);
+  const routeFiles = changedPaths.filter(
+    (p) => /\/(route)\.(ts|tsx|js|jsx)$/.test(p)
+  );
+  for (const routePath of routeFiles) {
+    const appMatch = routePath.match(/app\/(.+)\/route\./);
+    if (!appMatch) continue;
+    const urlPath = "/" + appMatch[1].replace(/\([^)]+\)\//g, "").replace(/\[\.{3}(\w+)\]/g, "*$1").replace(/\[(\w+)\]/g, ":$1");
+    const route = db.prepare("SELECT route_path, has_auth FROM routes WHERE route_path = ? AND kind = 'api-route'").get(urlPath);
+    if (route && !route.has_auth) {
+      findings.push({
+        dimension: "Security",
+        severity: "warning",
+        description: `API route \`${route.route_path}\` does not have auth middleware detected.`,
+        action: "Verify this route has authentication. Add auth middleware or mark as intentionally public."
+      });
+    }
+  }
+  const sensitivePatterns = [/\.env/, /secrets?\./, /credentials/, /\.pem$/, /\.key$/];
+  for (const path of changedPaths) {
+    if (sensitivePatterns.some((p) => p.test(path))) {
+      findings.push({
+        dimension: "Security",
+        severity: "error",
+        description: `Potentially sensitive file changed: \`${path}\``,
+        action: "Ensure this file is in .gitignore and not committed to version control."
+      });
+    }
+  }
+  const clientFiles = changedPaths.filter((p) => p.endsWith(".tsx") || p.endsWith(".ts"));
+  for (const filePath of clientFiles) {
+    const comp = db.prepare(
+      `SELECT s.name, c.is_client
+         FROM components c
+         JOIN symbols s ON c.symbol_id = s.id
+         WHERE s.file_path = ? AND c.is_client = 1`
+    ).all(filePath);
+    if (comp.length === 0) continue;
+    const serverImports = db.prepare(
+      `SELECT DISTINCT st.file_path
+         FROM dependencies d
+         JOIN symbols ss ON d.source_symbol = ss.id
+         JOIN symbols st ON d.target_symbol = st.id
+         JOIN components ct ON d.target_symbol = ct.symbol_id
+         WHERE ss.file_path = ?
+           AND ct.is_server_action = 1
+           AND d.kind = 'imports'`
+    ).all(filePath);
+    for (const imp of serverImports) {
+      findings.push({
+        dimension: "Security",
+        severity: "warning",
+        description: `Client component in \`${filePath}\` imports from server action file \`${imp.file_path}\`. Verify no server secrets are exposed.`,
+        action: null
+      });
+    }
+  }
+}
+function reviewTesting(db, changedFiles, findings) {
+  const changedPaths = changedFiles.filter((f) => f.status !== "deleted").map((f) => f.path);
+  const testFilePattern = /\.(test|spec)\.(ts|tsx|js|jsx)$/;
+  const codeFiles = changedPaths.filter((p) => !testFilePattern.test(p) && /\.(ts|tsx|js|jsx)$/.test(p));
+  const testFiles = changedPaths.filter((p) => testFilePattern.test(p));
+  if (codeFiles.length > 0 && testFiles.length === 0) {
+    findings.push({
+      dimension: "Testing",
+      severity: "info",
+      description: `${codeFiles.length} code file(s) changed but no test files were modified.`,
+      action: "Consider whether existing tests still cover the changed behavior."
+    });
+  }
+  const scenarios = db.prepare(
+    "SELECT id, name, linked_code, linked_blocks, status FROM quality_scenarios WHERE priority IN ('must', 'should')"
+  ).all();
+  for (const scenario of scenarios) {
+    const linkedCode = safeParseJson(scenario.linked_code, []);
+    const linkedBlocks = safeParseJson(scenario.linked_blocks, []);
+    const affectedByCode = linkedCode.some(
+      (lc) => changedPaths.some((cp) => cp.startsWith(lc) || cp === lc)
+    );
+    let affectedByBlock = false;
+    if (linkedBlocks.length > 0) {
+      const blocks = db.prepare("SELECT id, code_paths FROM building_blocks").all();
+      for (const blockId of linkedBlocks) {
+        const block = blocks.find((b) => b.id === blockId);
+        if (!block) continue;
+        const paths = safeParseJson(block.code_paths, []);
+        for (const cp of paths) {
+          const prefix = normalizeCodePath(cp);
+          if (changedPaths.some((p) => p.startsWith(prefix))) {
+            affectedByBlock = true;
+            break;
+          }
+        }
+        if (affectedByBlock) break;
+      }
+    }
+    if (affectedByCode || affectedByBlock) {
+      const severity = scenario.status === "passing" ? "warning" : "error";
+      findings.push({
+        dimension: "Testing",
+        severity,
+        description: `Quality scenario \`${scenario.id}: ${scenario.name}\` may be affected by these changes (status: ${scenario.status}).`,
+        action: "Re-run tests for this quality scenario to verify it still passes."
+      });
+    }
+  }
+}
+function reviewDocumentation(db, changedFiles, findings) {
+  const driftEntries = detectDrift2(db);
+  if (driftEntries.length > 0) {
+    const errors = driftEntries.filter((d) => d.severity === "error");
+    const warnings = driftEntries.filter((d) => d.severity === "warning");
+    if (errors.length > 0) {
+      findings.push({
+        dimension: "Documentation",
+        severity: "error",
+        description: `${errors.length} architecture drift error(s) detected (dependency violations, etc.).`,
+        action: "Run `arcbridge_check_drift` for details and resolve violations."
+      });
+    }
+    if (warnings.length > 0) {
+      findings.push({
+        dimension: "Documentation",
+        severity: "warning",
+        description: `${warnings.length} documentation gap(s) found (undocumented modules, missing code paths, etc.).`,
+        action: "Run `arcbridge_propose_arc42_update` to generate update proposals."
+      });
+    }
+  }
+  const arc42Changes = changedFiles.filter(
+    (f) => f.path.includes(".arcbridge/arc42/")
+  );
+  if (arc42Changes.length > 0) {
+    findings.push({
+      dimension: "Documentation",
+      severity: "info",
+      description: `${arc42Changes.length} arc42 documentation file(s) were updated.`,
+      action: "Run `arcbridge_reindex` to ensure the database reflects documentation changes."
+    });
+  }
+}
+function reviewComplexity(db, changedFiles, findings) {
+  const changedPaths = changedFiles.filter((f) => f.status !== "deleted").map((f) => f.path);
+  for (const filePath of changedPaths) {
+    if (!/\.(ts|tsx|js|jsx)$/.test(filePath)) continue;
+    const symbolCount = db.prepare("SELECT COUNT(*) as count FROM symbols WHERE file_path = ?").get(filePath).count;
+    if (symbolCount > 30) {
+      findings.push({
+        dimension: "Complexity",
+        severity: "warning",
+        description: `\`${filePath}\` has ${symbolCount} symbols \u2014 consider splitting into smaller modules.`,
+        action: null
+      });
+    }
+    const depCount = db.prepare(
+      `SELECT COUNT(DISTINCT d.target_symbol) as count
+           FROM dependencies d
+           JOIN symbols s ON d.source_symbol = s.id
+           WHERE s.file_path = ?`
+    ).get(filePath).count;
+    if (depCount > 20) {
+      findings.push({
+        dimension: "Complexity",
+        severity: "warning",
+        description: `\`${filePath}\` has ${depCount} outgoing dependencies \u2014 high coupling detected.`,
+        action: "Consider reducing dependencies or introducing an abstraction layer."
+      });
+    }
+  }
+}
+
+// src/tools/complete-phase.ts
+import { z as z23 } from "zod";
+import {
+  detectDrift as detectDrift3,
+  writeDriftLog as writeDriftLog2,
+  getHeadSha as getHeadSha2,
+  setSyncCommit as setSyncCommit2,
+  inferTaskStatuses,
+  applyInferences,
+  verifyScenarios,
+  loadConfig,
+  refreshFromDocs as refreshFromDocs5,
+  syncPhaseToYaml
+} from "@arcbridge/core";
+function registerCompletePhase(server, ctx) {
+  server.tool(
+    "arcbridge_complete_phase",
+    "Attempt to complete a phase by validating all gates: tasks done, no critical drift, quality scenarios passing. Transitions the phase to 'complete' if all gates pass.",
+    {
+      target_dir: z23.string().describe("Absolute path to the project directory"),
+      phase_id: z23.string().optional().describe("Phase ID to complete (defaults to current in-progress phase)"),
+      notes: z23.string().optional().describe("Optional notes about this phase completion"),
+      auto_infer: z23.boolean().default(true).describe("Automatically infer task statuses from code state before checking gates"),
+      run_tests: z23.boolean().default(false).describe("Run linked tests for quality scenarios before checking the quality gate")
+    },
+    async (params) => {
+      const db = ensureDb(ctx, params.target_dir);
+      if (!db) return notInitialized();
+      refreshFromDocs5(db, params.target_dir);
+      let phase;
+      if (params.phase_id) {
+        phase = db.prepare("SELECT id, name, phase_number, status, gate_status FROM phases WHERE id = ?").get(params.phase_id);
+      } else {
+        phase = db.prepare(
+          "SELECT id, name, phase_number, status, gate_status FROM phases WHERE status = 'in-progress' LIMIT 1"
+        ).get();
+      }
+      if (!phase) {
+        return textResult(
+          "No in-progress phase found. Use `arcbridge_get_phase_plan` to see all phases."
+        );
+      }
+      if (phase.status === "complete") {
+        return textResult(`Phase \`${phase.name}\` is already complete.`);
+      }
+      const lines = [
+        `# Phase Completion: ${phase.name}`,
+        ""
+      ];
+      if (params.auto_infer) {
+        const inferences = inferTaskStatuses(db, phase.id);
+        if (inferences.length > 0) {
+          applyInferences(db, inferences, ctx.projectRoot ?? params.target_dir);
+          lines.push("## Task Status Inference", "");
+          for (const inf of inferences) {
+            lines.push(
+              `- **${inf.taskId}**: ${inf.previousStatus} \u2192 **${inf.inferredStatus}** (${inf.reason})`
+            );
+          }
+          lines.push("");
+        }
+      }
+      const tasks = db.prepare("SELECT id, title, status FROM tasks WHERE phase_id = ?").all(phase.id);
+      const incompleteTasks = tasks.filter((t) => t.status !== "done");
+      const tasksPass = incompleteTasks.length === 0;
+      const driftEntries = detectDrift3(db);
+      writeDriftLog2(db, driftEntries);
+      const criticalDrift = driftEntries.filter((d) => d.severity === "error");
+      const driftPass = criticalDrift.length === 0;
+      if (params.run_tests) {
+        const projectRoot = ctx.projectRoot ?? params.target_dir;
+        let testCommand = "npx vitest run";
+        let timeoutMs = 6e4;
+        const configResult = loadConfig(params.target_dir);
+        if (configResult.config) {
+          testCommand = configResult.config.testing.test_command;
+          timeoutMs = configResult.config.testing.timeout_ms;
+        }
+        const verifyResult = verifyScenarios(db, projectRoot, {
+          testCommand,
+          timeoutMs
+        });
+        if (verifyResult.results.length > 0) {
+          lines.push("## Test Verification", "");
+          for (const r of verifyResult.results) {
+            const icon = r.passed ? "PASS" : "FAIL";
+            lines.push(
+              `- [${icon}] **${r.scenarioId}: ${r.scenarioName}** (${r.durationMs}ms)`
+            );
+          }
+          lines.push("");
+        }
+      }
+      const mustScenarios = db.prepare(
+        "SELECT id, name, status, priority FROM quality_scenarios WHERE priority = 'must'"
+      ).all();
+      const failingMust = mustScenarios.filter(
+        (s) => s.status === "failing"
+      );
+      const qualityPass = failingMust.length === 0;
+      const gates = [
+        { name: "All tasks complete", pass: tasksPass },
+        { name: "No critical drift", pass: driftPass },
+        { name: "Must-have quality scenarios not failing", pass: qualityPass }
+      ];
+      const allPass = gates.every((g) => g.pass);
+      lines.push("## Gate Results", "");
+      for (const gate of gates) {
+        const icon = gate.pass ? "PASS" : "FAIL";
+        lines.push(`- [${icon}] ${gate.name}`);
+      }
+      lines.push("");
+      if (!tasksPass) {
+        lines.push("### Incomplete Tasks", "");
+        for (const t of incompleteTasks) {
+          const icon = t.status === "in-progress" ? "[>]" : t.status === "blocked" ? "[!]" : "[ ]";
+          lines.push(`- ${icon} ${t.id}: ${t.title} (${t.status})`);
+        }
+        lines.push("");
+      }
+      if (!driftPass) {
+        lines.push("### Critical Drift", "");
+        for (const d of criticalDrift) {
+          lines.push(`- [ERROR] ${d.description}`);
+        }
+        lines.push("");
+      }
+      if (!qualityPass) {
+        lines.push("### Failing Must-Have Scenarios", "");
+        for (const s of failingMust) {
+          lines.push(`- **${s.id}: ${s.name}** \u2014 ${s.status}`);
+        }
+        lines.push("");
+      }
+      const adrCount = db.prepare("SELECT COUNT(*) as count FROM adrs").get().count;
+      const architecturalKeywords = ["auth", "database", "middleware", "validation", "caching", "dependency injection", "error handling"];
+      const phaseTasks = tasks.map((t) => t.title.toLowerCase());
+      const hasArchitecturalWork = phaseTasks.some(
+        (title) => architecturalKeywords.some((kw) => title.includes(kw))
+      );
+      if (hasArchitecturalWork && adrCount <= 1) {
+        lines.push(
+          "## ADR Reminder",
+          "",
+          "This phase involved architectural decisions that should be documented as ADRs.",
+          "Use `arcbridge_get_relevant_adrs` to review existing ADRs and create new ones in `.arcbridge/arc42/09-decisions/` for:",
+          ""
+        );
+        for (const t of tasks) {
+          const lower = t.title.toLowerCase();
+          if (architecturalKeywords.some((kw) => lower.includes(kw))) {
+            lines.push(`- **${t.title}** \u2014 document the chosen approach and alternatives considered`);
+          }
+        }
+        lines.push("");
+      }
+      if (allPass) {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const gateStatus = JSON.stringify({
+          tasks: "pass",
+          drift: "pass",
+          quality: "pass",
+          completed_at: now,
+          notes: params.notes ?? null
+        });
+        const nextPhase = db.prepare(
+          "SELECT id, name FROM phases WHERE phase_number = ? AND status = 'planned'"
+        ).get(phase.phase_number + 1);
+        const transition = db.transaction(() => {
+          db.prepare(
+            "UPDATE phases SET status = 'complete', completed_at = ?, gate_status = ? WHERE id = ?"
+          ).run(now, gateStatus, phase.id);
+          if (nextPhase) {
+            db.prepare(
+              "UPDATE phases SET status = 'in-progress', started_at = ? WHERE id = ?"
+            ).run(now, nextPhase.id);
+          }
+        });
+        transition();
+        const projectRoot = ctx.projectRoot ?? params.target_dir;
+        syncPhaseToYaml(projectRoot, phase.id, "complete", void 0, now);
+        if (nextPhase) {
+          syncPhaseToYaml(projectRoot, nextPhase.id, "in-progress", now);
+        }
+        const headSha = getHeadSha2(projectRoot);
+        if (headSha) {
+          setSyncCommit2(db, "phase_sync_commit", headSha);
+        }
+        lines.push("## Result: PASS", "");
+        lines.push(`Phase \`${phase.name}\` is now **complete**.`);
+        if (!headSha) {
+          lines.push("", "*Warning: Could not determine git HEAD \u2014 sync point not stored.*");
+        }
+        if (params.notes) {
+          lines.push("", `**Notes:** ${params.notes}`);
+        }
+        if (nextPhase) {
+          lines.push("", `Next phase **${nextPhase.name}** is now in-progress.`);
+        }
+        lines.push(
+          "",
+          "---",
+          "## Arc42 Documentation Review",
+          "",
+          "Before moving on, review and update these arc42 sections for changes made in this phase:",
+          "",
+          "- [ ] **01 Introduction** \u2014 Do project goals still reflect reality?",
+          "- [ ] **03 Context** \u2014 Any new external systems or integrations added?",
+          "- [ ] **05 Building Blocks** \u2014 Are all new modules mapped? Run `arcbridge_check_drift` to verify.",
+          "- [ ] **06 Runtime Views** \u2014 Any new key workflows to document (auth flow, data processing, etc.)?",
+          "- [ ] **07 Deployment** \u2014 Any changes to infrastructure, environments, or deployment strategy?",
+          "- [ ] **08 Crosscutting Concepts** \u2014 Any new patterns established (error handling, validation, logging)?",
+          "- [ ] **09 Decisions** \u2014 ADRs for all significant choices? Run `arcbridge_get_relevant_adrs` to check.",
+          "- [ ] **10 Quality Scenarios** \u2014 Any new quality requirements or changed thresholds?",
+          "- [ ] **11 Risks & Debt** \u2014 Any known limitations or tech debt introduced?",
+          "",
+          "*Run `arcbridge_propose_arc42_update` to auto-detect documentation gaps.*"
+        );
+      } else {
+        const failCount = gates.filter((g) => !g.pass).length;
+        lines.push(
+          `## Result: BLOCKED (${failCount} gate${failCount > 1 ? "s" : ""} failed)`,
+          "",
+          "Resolve the issues above before completing this phase."
+        );
+      }
+      return textResult(lines.join("\n"));
+    }
+  );
+}
+
+// src/tools/activate-role.ts
+import { z as z24 } from "zod";
+import { loadRole, loadRoles } from "@arcbridge/core";
+function registerActivateRole(server, ctx) {
+  server.tool(
+    "arcbridge_activate_role",
+    "Activate an agent role: loads the role's system prompt, required tools, quality focus, and pre-loaded architectural context.",
+    {
+      target_dir: z24.string().describe("Absolute path to the project directory"),
+      role: z24.string().describe(
+        "Role ID to activate (e.g., 'architect', 'implementer', 'security-reviewer')"
+      ),
+      building_block: z24.string().optional().describe("Focus on a specific building block (for implementer/code-reviewer roles)")
+    },
+    async (params) => {
+      const db = ensureDb(ctx, params.target_dir);
+      if (!db) return notInitialized();
+      const lines = [];
+      const fileResult = loadRole(params.target_dir, params.role);
+      const role = fileResult.role ?? null;
+      const roleDef = role ? {
+        name: role.name,
+        description: role.description,
+        requiredTools: role.required_tools,
+        deniedTools: role.denied_tools,
+        readOnly: role.read_only,
+        qualityFocus: role.quality_focus,
+        systemPrompt: role.system_prompt,
+        modelPreferences: role.model_preferences
+      } : getRoleDefinition(params.role);
+      if (!roleDef) {
+        const builtInIds = ["architect", "implementer", "security-reviewer", "quality-guardian", "phase-manager", "onboarding", "code-reviewer"];
+        const fileRoles = loadRoles(params.target_dir);
+        const fileIds = fileRoles.roles.map((r) => r.role_id);
+        const availableIds = [.../* @__PURE__ */ new Set([...fileIds, ...builtInIds])].sort();
+        return textResult(
+          `Unknown role: \`${params.role}\`. Available roles: ${availableIds.map((r) => `\`${r}\``).join(", ")}`
+        );
+      }
+      const source = role ? "file" : "built-in";
+      lines.push(
+        `# Role Activated: ${roleDef.name}`,
+        "",
+        roleDef.description,
+        ""
+      );
+      if (source === "file") {
+        lines.push(`*Loaded from .arcbridge/agents/${params.role}.md*`, "");
+      }
+      lines.push("## Required Tools", "");
+      for (const tool of roleDef.requiredTools) {
+        lines.push(`- \`${tool}\``);
+      }
+      lines.push("");
+      if (roleDef.deniedTools.length > 0) {
+        lines.push("## Denied Tools", "");
+        for (const tool of roleDef.deniedTools) {
+          lines.push(`- \`${tool}\``);
+        }
+        lines.push("");
+      }
+      if (roleDef.readOnly) {
+        lines.push("**Access:** Read-only", "");
+      }
+      if (roleDef.qualityFocus.length > 0) {
+        lines.push(
+          "## Quality Focus",
+          "",
+          roleDef.qualityFocus.map((q) => `- ${q}`).join("\n"),
+          ""
+        );
+      }
+      if (roleDef.modelPreferences) {
+        const mp = roleDef.modelPreferences;
+        lines.push("## Model Preferences", "");
+        lines.push(`- **Reasoning depth:** ${mp.reasoning_depth}`);
+        lines.push(`- **Speed priority:** ${mp.speed_priority}`);
+        if (mp.suggested_models) {
+          const models = Object.entries(mp.suggested_models).filter(([, v]) => v).map(([k, v]) => `${k}: ${v}`);
+          if (models.length > 0) {
+            lines.push(`- **Suggested models:** ${models.join(", ")}`);
+          }
+        }
+        lines.push("");
+      }
+      lines.push("## Pre-loaded Context", "");
+      const blocks = db.prepare("SELECT id, name, responsibility FROM building_blocks").all();
+      if (blocks.length > 0) {
+        lines.push("### Building Blocks", "");
+        for (const b of blocks) {
+          lines.push(`- **${b.name}** (\`${b.id}\`): ${b.responsibility}`);
+        }
+        lines.push("");
+      }
+      if (roleDef.qualityFocus.length > 0) {
+        const allScenarios = db.prepare(
+          "SELECT id, name, category, priority, status FROM quality_scenarios ORDER BY priority, category"
+        ).all();
+        const focused = allScenarios.filter(
+          (s) => roleDef.qualityFocus.includes(s.category) || s.priority === "must"
+        );
+        if (focused.length > 0) {
+          lines.push("### Relevant Quality Scenarios", "");
+          for (const s of focused) {
+            const statusIcon = s.status === "passing" ? "PASS" : s.status === "failing" ? "FAIL" : "?";
+            lines.push(
+              `- [${statusIcon}] **${s.id}: ${s.name}** [${s.category}] (${s.priority})`
+            );
+          }
+          lines.push("");
+        }
+      }
+      if (["phase-manager", "onboarding", "architect"].includes(params.role)) {
+        const phases = db.prepare("SELECT id, name, status FROM phases ORDER BY id").all();
+        if (phases.length > 0) {
+          lines.push("### Phase Plan", "");
+          for (const p of phases) {
+            const icon = p.status === "complete" ? "[x]" : p.status === "in-progress" ? "[>]" : "[ ]";
+            lines.push(`- ${icon} ${p.name} (${p.status})`);
+          }
+          lines.push("");
+        }
+      }
+      if (["implementer", "code-reviewer"].includes(params.role) && params.building_block) {
+        const blockDetail = db.prepare("SELECT id, name, responsibility FROM building_blocks WHERE id = ?").get(params.building_block);
+        if (!blockDetail) {
+          lines.push(
+            `### Warning: Unknown Building Block`,
+            "",
+            `Building block \`${params.building_block}\` not found. Use \`arcbridge_get_building_blocks\` to see available blocks.`,
+            ""
+          );
+        } else {
+          lines.push(
+            `### Focus Block: ${blockDetail.name}`,
+            "",
+            `**Responsibility:** ${blockDetail.responsibility}`,
+            ""
+          );
+          const blockTasks = db.prepare(
+            "SELECT id, title, status FROM tasks WHERE building_block = ? AND status IN ('todo', 'in-progress')"
+          ).all(params.building_block);
+          if (blockTasks.length > 0) {
+            lines.push("### Active Tasks", "");
+            for (const t of blockTasks) {
+              lines.push(`- [${t.status}] ${t.id}: ${t.title}`);
+            }
+            lines.push("");
+          }
+        }
+      }
+      if (params.role === "phase-manager") {
+        const currentPhase = db.prepare(
+          "SELECT id, name FROM phases WHERE status = 'in-progress' LIMIT 1"
+        ).get();
+        if (currentPhase) {
+          const phaseTasks = db.prepare("SELECT id, title, status FROM tasks WHERE phase_id = ?").all(currentPhase.id);
+          const done = phaseTasks.filter((t) => t.status === "done").length;
+          lines.push(
+            `### Current Phase: ${currentPhase.name} (${done}/${phaseTasks.length} tasks done)`,
+            ""
+          );
+          for (const t of phaseTasks) {
+            const icon = t.status === "done" ? "[x]" : t.status === "in-progress" ? "[>]" : t.status === "blocked" ? "[!]" : "[ ]";
+            lines.push(`- ${icon} ${t.id}: ${t.title}`);
+          }
+          lines.push("");
+        }
+      }
+      lines.push("## Instructions", "", roleDef.systemPrompt, "");
+      return textResult(lines.join("\n"));
+    }
+  );
+}
+function getRoleDefinition(roleId) {
+  const roles = {
+    architect: {
+      name: "Architect",
+      description: "Designs system structure, makes architectural decisions, and maintains the arc42 documentation",
+      requiredTools: [
+        "arcbridge_get_building_blocks",
+        "arcbridge_get_quality_scenarios",
+        "arcbridge_get_relevant_adrs",
+        "arcbridge_search_symbols",
+        "arcbridge_get_symbol",
+        "arcbridge_get_dependency_graph",
+        "arcbridge_get_component_graph",
+        "arcbridge_get_route_map",
+        "arcbridge_get_boundary_analysis",
+        "arcbridge_propose_arc42_update",
+        "arcbridge_check_drift",
+        "arcbridge_get_open_questions"
+      ],
+      deniedTools: [],
+      readOnly: false,
+      qualityFocus: ["maintainability", "reliability", "security", "performance"],
+      systemPrompt: "You are the Architect agent. Design building blocks, make ADRs, maintain arc42 docs, ensure code-to-architecture mapping, review quality scenarios, and detect drift. Think at the system level."
+    },
+    implementer: {
+      name: "Implementer",
+      description: "Writes code within defined building block boundaries, follows existing patterns, and completes phase tasks",
+      requiredTools: [
+        "arcbridge_get_building_block",
+        "arcbridge_get_current_tasks",
+        "arcbridge_update_task",
+        "arcbridge_search_symbols",
+        "arcbridge_get_symbol",
+        "arcbridge_get_guidance",
+        "arcbridge_get_component_graph"
+      ],
+      deniedTools: ["arcbridge_propose_arc42_update"],
+      readOnly: false,
+      qualityFocus: ["maintainability", "performance"],
+      systemPrompt: "You are the Implementer agent. Write code within your assigned building block boundaries. Follow existing patterns, check guidance before making changes, and update task status when complete."
+    },
+    "security-reviewer": {
+      name: "Security Reviewer",
+      description: "Reviews code for security vulnerabilities, verifies security quality scenarios, and checks auth coverage",
+      requiredTools: [
+        "arcbridge_get_quality_scenarios",
+        "arcbridge_get_building_blocks",
+        "arcbridge_get_relevant_adrs",
+        "arcbridge_search_symbols",
+        "arcbridge_get_symbol",
+        "arcbridge_get_route_map",
+        "arcbridge_get_boundary_analysis",
+        "arcbridge_get_practice_review"
+      ],
+      deniedTools: ["arcbridge_propose_arc42_update"],
+      readOnly: true,
+      qualityFocus: ["security"],
+      systemPrompt: "You are the Security Reviewer agent. Review code for vulnerabilities, verify auth coverage on routes, check server/client boundary safety, and validate security quality scenarios."
+    },
+    "quality-guardian": {
+      name: "Quality Guardian",
+      description: "Verifies quality scenarios are met, checks test coverage, and monitors performance budgets",
+      requiredTools: [
+        "arcbridge_get_quality_scenarios",
+        "arcbridge_get_building_blocks",
+        "arcbridge_search_symbols",
+        "arcbridge_get_component_graph",
+        "arcbridge_get_boundary_analysis"
+      ],
+      deniedTools: [],
+      readOnly: true,
+      qualityFocus: [
+        "security",
+        "performance",
+        "accessibility",
+        "reliability",
+        "maintainability"
+      ],
+      systemPrompt: "You are the Quality Guardian agent. Verify all quality scenarios are met, check test coverage, monitor performance budgets, and flag regressions."
+    },
+    "phase-manager": {
+      name: "Phase Manager",
+      description: "Manages phase transitions, enforces gates, triggers sync, and tracks task completion",
+      requiredTools: [
+        "arcbridge_get_phase_plan",
+        "arcbridge_get_current_tasks",
+        "arcbridge_update_task",
+        "arcbridge_check_drift",
+        "arcbridge_get_open_questions",
+        "arcbridge_propose_arc42_update",
+        "arcbridge_complete_phase"
+      ],
+      deniedTools: [],
+      readOnly: false,
+      qualityFocus: [],
+      systemPrompt: "You are the Phase Manager agent. Track task completion, enforce phase gates, trigger architecture sync at boundaries, and manage phase transitions. Do not skip gates."
+    },
+    onboarding: {
+      name: "Onboarding Guide",
+      description: "Helps new team members understand the project architecture, conventions, and current state",
+      requiredTools: [
+        "arcbridge_get_project_status",
+        "arcbridge_get_building_blocks",
+        "arcbridge_get_quality_scenarios",
+        "arcbridge_get_phase_plan",
+        "arcbridge_get_relevant_adrs",
+        "arcbridge_get_component_graph",
+        "arcbridge_get_route_map"
+      ],
+      deniedTools: [],
+      readOnly: true,
+      qualityFocus: [],
+      systemPrompt: "You are the Onboarding Guide agent. Help new team members understand the project: architecture, conventions, current phase, and how to contribute. Be welcoming and thorough."
+    },
+    "code-reviewer": {
+      name: "Code Reviewer",
+      description: "On-demand code review: checks correctness, patterns, edge cases, and simplicity",
+      requiredTools: [
+        "arcbridge_get_building_block",
+        "arcbridge_get_quality_scenarios",
+        "arcbridge_get_relevant_adrs",
+        "arcbridge_get_current_tasks",
+        "arcbridge_search_symbols",
+        "arcbridge_get_symbol",
+        "arcbridge_get_dependency_graph",
+        "arcbridge_get_component_graph",
+        "arcbridge_get_route_map",
+        "arcbridge_get_practice_review",
+        "arcbridge_get_boundary_analysis"
+      ],
+      deniedTools: [],
+      readOnly: true,
+      qualityFocus: ["maintainability", "reliability"],
+      systemPrompt: "You are the Code Reviewer agent. Review for correctness, adherence to patterns, edge cases, simplicity, and alignment with quality scenarios. Be constructive and specific."
+    }
+  };
+  return roles[roleId] ?? null;
+}
+
+// src/tools/verify-scenarios.ts
+import { z as z25 } from "zod";
+import { verifyScenarios as verifyScenarios2, loadConfig as loadConfig2 } from "@arcbridge/core";
+function registerVerifyScenarios(server, ctx) {
+  server.tool(
+    "arcbridge_verify_scenarios",
+    "Run linked tests for quality scenarios and update their pass/fail status. Only runs scenarios with verification='automatic' or 'semi-automatic' and non-empty linked_tests.",
+    {
+      target_dir: z25.string().describe("Absolute path to the project directory"),
+      scenario_ids: z25.array(z25.string()).optional().describe(
+        "Specific scenario IDs to verify (e.g., ['SEC-01', 'PERF-01']). If omitted, verifies all automatic scenarios."
+      ),
+      test_command: z25.string().optional().describe(
+        "Override the test command from config (e.g., 'npx jest'). File paths are appended as arguments."
+      )
+    },
+    async (params) => {
+      const db = ensureDb(ctx, params.target_dir);
+      if (!db) return notInitialized();
+      let testCommand = "npx vitest run";
+      let timeoutMs = 6e4;
+      const configResult = loadConfig2(params.target_dir);
+      if (configResult.config) {
+        testCommand = configResult.config.testing.test_command;
+        timeoutMs = configResult.config.testing.timeout_ms;
+      }
+      if (params.test_command) {
+        testCommand = params.test_command;
+      }
+      const projectRoot = ctx.projectRoot ?? params.target_dir;
+      const result = verifyScenarios2(db, projectRoot, {
+        testCommand,
+        timeoutMs,
+        scenarioIds: params.scenario_ids
+      });
+      const lines = ["# Scenario Verification Results", ""];
+      if (result.results.length === 0) {
+        lines.push(
+          "No testable scenarios found. Scenarios need `verification: automatic` (or `semi-automatic`) and non-empty `linked_tests` to be verified."
+        );
+        return textResult(lines.join("\n"));
+      }
+      lines.push(`Ran tests for ${result.results.length} scenario(s).`, "");
+      const passing = result.results.filter((r) => r.passed).length;
+      const failing = result.results.length - passing;
+      lines.push(
+        `**Summary:** ${passing} passing, ${failing} failing`,
+        ""
+      );
+      for (const r of result.results) {
+        const icon = r.passed ? "PASS" : "FAIL";
+        lines.push(
+          `### [${icon}] ${r.scenarioId}: ${r.scenarioName} (${r.durationMs}ms)`,
+          ""
+        );
+        lines.push(`Tests: ${r.testPaths.join(", ")}`, "");
+        if (!r.passed && r.output) {
+          const trimmed = r.output.length > 500 ? `...${r.output.slice(-500)}` : r.output;
+          lines.push("```", trimmed, "```", "");
+        }
+      }
+      if (result.updated > 0) {
+        lines.push(
+          `---`,
+          `Updated status for ${result.updated} scenario(s) in the database.`
+        );
+      }
+      if (result.errors.length > 0) {
+        lines.push("", "## Errors", "");
+        for (const e of result.errors) {
+          lines.push(`- ${e}`);
+        }
+      }
+      return textResult(lines.join("\n"));
+    }
+  );
+}
+
+// src/tools/run-role-check.ts
+import { z as z26 } from "zod";
+import {
+  loadRole as loadRole2,
+  loadRoles as loadRoles2,
+  detectDrift as detectDrift4,
+  resolveRef as resolveRef3,
+  getChangedFiles as getChangedFiles3
+} from "@arcbridge/core";
+var SCOPE_VALUES = ["last-commit", "current-phase", "full-project"];
+function registerRunRoleCheck(server, ctx) {
+  server.tool(
+    "arcbridge_run_role_check",
+    "Run a role-specific architectural analysis: resolves the role and executes relevant checks (drift, quality scenarios, boundaries, changed files) based on the role's focus areas.",
+    {
+      target_dir: z26.string().describe("Absolute path to the project directory"),
+      role: z26.string().describe(
+        "Role ID to run checks for (e.g., 'security-reviewer', 'quality-guardian', 'architect', 'phase-manager', 'code-reviewer')"
+      ),
+      scope: z26.enum(SCOPE_VALUES).default("current-phase").describe(
+        "Scope of analysis: 'last-commit' (recent changes), 'current-phase' (since phase start), 'full-project' (everything)"
+      )
+    },
+    async (params) => {
+      const db = ensureDb(ctx, params.target_dir);
+      if (!db) return notInitialized();
+      const projectRoot = ctx.projectRoot ?? params.target_dir;
+      const fileResult = loadRole2(projectRoot, params.role);
+      const role = fileResult.role ?? null;
+      const roleDef = role ? { name: role.name, qualityFocus: role.quality_focus } : getBuiltInRoleDef(params.role);
+      if (!roleDef) {
+        const builtInIds = [
+          "architect",
+          "implementer",
+          "security-reviewer",
+          "quality-guardian",
+          "phase-manager",
+          "onboarding",
+          "code-reviewer"
+        ];
+        const fileRoles = loadRoles2(projectRoot);
+        const fileIds = fileRoles.roles.map((r) => r.role_id);
+        const availableIds = [.../* @__PURE__ */ new Set([...fileIds, ...builtInIds])].sort();
+        return textResult(
+          `Unknown role: \`${params.role}\`. Available roles: ${availableIds.map((r) => `\`${r}\``).join(", ")}`
+        );
+      }
+      const lines = [
+        `# Role Check: ${roleDef.name}`,
+        "",
+        `**Scope:** ${params.scope}`,
+        ""
+      ];
+      const changedFiles = getChangedFilesForScope(db, projectRoot, params.scope);
+      if (changedFiles && changedFiles.length > 0) {
+        lines.push(`**Changed files:** ${changedFiles.length}`, "");
+      }
+      switch (params.role) {
+        case "security-reviewer":
+          runSecurityReviewerCheck(db, lines, changedFiles);
+          break;
+        case "quality-guardian":
+          runQualityGuardianCheck(db, lines);
+          break;
+        case "architect":
+          runArchitectCheck(db, lines);
+          break;
+        case "phase-manager":
+          runPhaseManagerCheck(db, projectRoot, lines);
+          break;
+        case "code-reviewer":
+          runCodeReviewerCheck(db, lines, changedFiles);
+          break;
+        default:
+          runCustomRoleCheck(db, lines, roleDef);
+          break;
+      }
+      return textResult(lines.join("\n"));
+    }
+  );
+}
+function getChangedFilesForScope(db, projectRoot, scope) {
+  if (scope === "full-project") return null;
+  const since = scope === "last-commit" ? "last-commit" : "last-phase";
+  const ref = resolveRef3(projectRoot, since, db);
+  try {
+    return getChangedFiles3(projectRoot, ref.sha);
+  } catch {
+    return null;
+  }
+}
+function getBuiltInRoleDef(roleId) {
+  const defs = {
+    architect: { name: "Architect", qualityFocus: ["maintainability", "reliability", "security", "performance"] },
+    implementer: { name: "Implementer", qualityFocus: ["maintainability", "performance"] },
+    "security-reviewer": { name: "Security Reviewer", qualityFocus: ["security"] },
+    "quality-guardian": { name: "Quality Guardian", qualityFocus: ["security", "performance", "accessibility", "reliability", "maintainability"] },
+    "phase-manager": { name: "Phase Manager", qualityFocus: [] },
+    onboarding: { name: "Onboarding Guide", qualityFocus: [] },
+    "code-reviewer": { name: "Code Reviewer", qualityFocus: ["maintainability", "reliability"] }
+  };
+  return defs[roleId] ?? null;
+}
+function appendDriftSection(db, lines) {
+  const entries = detectDrift4(db);
+  lines.push("## Drift Check", "");
+  if (entries.length === 0) {
+    lines.push("No architecture drift detected.", "");
+    return;
+  }
+  const errors = entries.filter((e) => e.severity === "error").length;
+  const warnings = entries.filter((e) => e.severity === "warning").length;
+  const infos = entries.filter((e) => e.severity === "info").length;
+  lines.push(`**${errors}** errors, **${warnings}** warnings, **${infos}** info`, "");
+  const byKind = groupBy(entries, (e) => e.kind);
+  const kindLabels = {
+    undocumented_module: "Undocumented Modules",
+    missing_module: "Missing Modules",
+    dependency_violation: "Dependency Violations",
+    stale_adr: "Stale ADR References",
+    unlinked_test: "Unlinked Tests"
+  };
+  const severityIcon = {
+    error: "ERROR",
+    warning: "WARN",
+    info: "INFO"
+  };
+  for (const [kind, items] of byKind) {
+    lines.push(`### ${kindLabels[kind] ?? kind}`, "");
+    for (const item of items) {
+      const icon = severityIcon[item.severity] ?? item.severity;
+      lines.push(`- [${icon}] ${item.description}`);
+    }
+    lines.push("");
+  }
+}
+function appendQualityScenarios(db, lines, categoryFilter) {
+  const allScenarios = db.prepare(
+    "SELECT id, name, category, priority, status FROM quality_scenarios ORDER BY priority, category"
+  ).all();
+  const scenarios = categoryFilter ? allScenarios.filter(
+    (s) => categoryFilter.includes(s.category) || s.priority === "must"
+  ) : allScenarios;
+  const title = categoryFilter ? "## Quality Scenarios (Filtered)" : "## Quality Scenarios";
+  lines.push(title, "");
+  if (scenarios.length === 0) {
+    lines.push("No matching quality scenarios found.", "");
+    return;
+  }
+  const passing = scenarios.filter((s) => s.status === "passing").length;
+  const failing = scenarios.filter((s) => s.status === "failing").length;
+  const untested = scenarios.filter(
+    (s) => s.status === "untested" || s.status === "partial"
+  ).length;
+  lines.push(
+    `**Total:** ${scenarios.length} | **Passing:** ${passing} | **Failing:** ${failing} | **Untested/Partial:** ${untested}`,
+    ""
+  );
+  for (const s of scenarios) {
+    const icon = s.status === "passing" ? "PASS" : s.status === "failing" ? "FAIL" : "?";
+    lines.push(
+      `- [${icon}] **${s.id}: ${s.name}** [${s.category}] (${s.priority})`
+    );
+  }
+  lines.push("");
+}
+function appendChangedFilesList(lines, changedFiles) {
+  if (!changedFiles || changedFiles.length === 0) return;
+  lines.push("## Changed Files", "");
+  const limit = 30;
+  const display = changedFiles.slice(0, limit);
+  for (const f of display) {
+    const tag = f.status === "added" ? "A" : f.status === "deleted" ? "D" : "M";
+    lines.push(`- [${tag}] \`${f.path}\``);
+  }
+  if (changedFiles.length > limit) {
+    lines.push(`- ... and ${changedFiles.length - limit} more`);
+  }
+  lines.push("");
+}
+function appendBuildingBlocks(db, lines) {
+  const blocks = db.prepare("SELECT id, name, responsibility FROM building_blocks").all();
+  lines.push("## Building Blocks", "");
+  if (blocks.length === 0) {
+    lines.push("No building blocks defined.", "");
+    return;
+  }
+  for (const b of blocks) {
+    lines.push(`- **${b.name}** (\`${b.id}\`): ${b.responsibility}`);
+  }
+  lines.push("");
+}
+function mapFilesToBlocks(db, changedFiles) {
+  const blocks = db.prepare("SELECT id, name, code_paths FROM building_blocks").all();
+  const mapped = /* @__PURE__ */ new Map();
+  const unmapped = [];
+  const changedPaths = changedFiles.filter((f) => f.status !== "deleted").map((f) => f.path);
+  for (const path of changedPaths) {
+    let matched = false;
+    for (const block of blocks) {
+      const paths = safeParseJson(block.code_paths, []);
+      for (const cp of paths) {
+        const prefix = normalizeCodePath(cp);
+        if (path.startsWith(prefix)) {
+          const existing = mapped.get(block.id) ?? [];
+          existing.push(path);
+          mapped.set(block.id, existing);
+          matched = true;
+          break;
+        }
+      }
+      if (matched) break;
+    }
+    if (!matched) unmapped.push(path);
+  }
+  return { mapped, unmapped };
+}
+function groupBy(items, keyFn) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = keyFn(item);
+    const existing = map.get(key) ?? [];
+    existing.push(item);
+    map.set(key, existing);
+  }
+  return map;
+}
+function runSecurityReviewerCheck(db, lines, changedFiles) {
+  appendQualityScenarios(db, lines, ["security"]);
+  appendDriftSection(db, lines);
+  const clientComponents = db.prepare(
+    `SELECT COUNT(*) as count FROM components WHERE is_client = 1`
+  ).get();
+  const serverActions = db.prepare(
+    `SELECT COUNT(*) as count FROM components WHERE is_server_action = 1`
+  ).get();
+  const crossBoundary = db.prepare(
+    `SELECT COUNT(*) as count
+       FROM dependencies d
+       JOIN components cs ON d.source_symbol = cs.symbol_id
+       JOIN components ct ON d.target_symbol = ct.symbol_id
+       WHERE cs.is_client != ct.is_client
+         AND d.kind IN ('imports', 'calls', 'renders')`
+  ).get();
+  lines.push("## Boundary Summary", "");
+  lines.push(`- **Client components:** ${clientComponents.count}`);
+  lines.push(`- **Server actions:** ${serverActions.count}`);
+  lines.push(`- **Cross-boundary edges:** ${crossBoundary.count}`);
+  lines.push("");
+  const unauthRoutes = db.prepare(
+    `SELECT route_path FROM routes WHERE kind = 'api-route' AND has_auth = 0`
+  ).all();
+  if (unauthRoutes.length > 0) {
+    lines.push("## Unauthenticated API Routes", "");
+    for (const r of unauthRoutes) {
+      lines.push(`- \`${r.route_path}\``);
+    }
+    lines.push("");
+  }
+  appendChangedFilesList(lines, changedFiles);
+}
+function runQualityGuardianCheck(db, lines) {
+  appendQualityScenarios(db, lines);
+  appendDriftSection(db, lines);
+  const scenarios = db.prepare(
+    `SELECT verification, status, COUNT(*) as count
+       FROM quality_scenarios
+       GROUP BY verification, status`
+  ).all();
+  if (scenarios.length > 0) {
+    lines.push("## Verification Coverage", "");
+    for (const s of scenarios) {
+      lines.push(
+        `- **${s.verification}** / ${s.status}: ${s.count} scenario(s)`
+      );
+    }
+    lines.push("");
+  }
+}
+function runArchitectCheck(db, lines) {
+  appendBuildingBlocks(db, lines);
+  appendDriftSection(db, lines);
+  const blocks = db.prepare("SELECT id, name, code_paths, interfaces FROM building_blocks").all();
+  if (blocks.length > 1) {
+    const violations = [];
+    for (const block of blocks) {
+      const declaredInterfaces = new Set(
+        safeParseJson(block.interfaces, [])
+      );
+      const codePaths = safeParseJson(block.code_paths, []);
+      for (const cp of codePaths) {
+        const prefix = normalizeCodePath(cp);
+        const outgoing = db.prepare(
+          `SELECT DISTINCT st.file_path as target_file
+             FROM dependencies d
+             JOIN symbols ss ON d.source_symbol = ss.id
+             JOIN symbols st ON d.target_symbol = st.id
+             WHERE ss.file_path LIKE ? || '%'
+               AND d.kind IN ('imports', 'calls', 'renders')`
+        ).all(prefix);
+        for (const { target_file } of outgoing) {
+          for (const targetBlock of blocks) {
+            if (targetBlock.id === block.id) continue;
+            const tPaths = safeParseJson(targetBlock.code_paths, []);
+            for (const tp of tPaths) {
+              const tPrefix = normalizeCodePath(tp);
+              if (target_file.startsWith(tPrefix) && !declaredInterfaces.has(targetBlock.id)) {
+                violations.push(
+                  `Block \`${block.name}\` depends on \`${targetBlock.name}\` (undeclared interface)`
+                );
+              }
+            }
+          }
+        }
+      }
+    }
+    const unique = [...new Set(violations)];
+    if (unique.length > 0) {
+      lines.push("## Undeclared Cross-Block Dependencies", "");
+      for (const v of unique) {
+        lines.push(`- [ERROR] ${v}`);
+      }
+      lines.push("");
+    }
+  }
+}
+function runPhaseManagerCheck(db, projectRoot, lines) {
+  const currentPhase = db.prepare(
+    "SELECT id, name, status FROM phases WHERE status = 'in-progress' LIMIT 1"
+  ).get();
+  if (currentPhase) {
+    const tasks = db.prepare("SELECT id, title, status, phase_id FROM tasks WHERE phase_id = ?").all(currentPhase.id);
+    const done = tasks.filter((t) => t.status === "done").length;
+    const inProgress = tasks.filter((t) => t.status === "in-progress").length;
+    const todo = tasks.filter((t) => t.status === "todo").length;
+    const blocked = tasks.filter((t) => t.status === "blocked").length;
+    lines.push(
+      `## Current Phase: ${currentPhase.name}`,
+      "",
+      `**Progress:** ${done}/${tasks.length} done, ${inProgress} in-progress, ${todo} todo, ${blocked} blocked`,
+      ""
+    );
+    for (const t of tasks) {
+      const icon = t.status === "done" ? "[x]" : t.status === "in-progress" ? "[>]" : t.status === "blocked" ? "[!]" : "[ ]";
+      lines.push(`- ${icon} ${t.id}: ${t.title}`);
+    }
+    lines.push("");
+  } else {
+    lines.push("## Phase Status", "", "No phase currently in progress.", "");
+  }
+  appendDriftSection(db, lines);
+  lines.push("## Quality Gate Status", "");
+  const mustScenarios = db.prepare(
+    "SELECT id, name, status FROM quality_scenarios WHERE priority = 'must'"
+  ).all();
+  if (mustScenarios.length === 0) {
+    lines.push("No must-have quality scenarios defined.", "");
+  } else {
+    const passing = mustScenarios.filter((s) => s.status === "passing").length;
+    const failing = mustScenarios.filter((s) => s.status === "failing").length;
+    const gateOk = failing === 0;
+    lines.push(
+      `**Must-have scenarios:** ${passing}/${mustScenarios.length} passing`,
+      `**Gate status:** ${gateOk ? "READY" : "BLOCKED"}`,
+      ""
+    );
+    if (failing > 0) {
+      for (const s of mustScenarios.filter((s2) => s2.status !== "passing")) {
+        lines.push(`- [FAIL] ${s.id}: ${s.name} (${s.status})`);
+      }
+      lines.push("");
+    }
+  }
+  const ref = resolveRef3(projectRoot, "last-sync", db);
+  try {
+    const changedFiles = getChangedFiles3(projectRoot, ref.sha);
+    if (changedFiles.length > 0) {
+      lines.push(`## Changes Since Last Sync (${ref.label})`, "");
+      appendChangedFilesList(lines, changedFiles);
+    }
+  } catch {
+  }
+}
+function runCodeReviewerCheck(db, lines, changedFiles) {
+  if (!changedFiles || changedFiles.length === 0) {
+    lines.push(
+      "## Changed Files",
+      "",
+      "No changed files in the selected scope. Use a different scope or specify 'full-project'.",
+      ""
+    );
+    return;
+  }
+  appendChangedFilesList(lines, changedFiles);
+  const { mapped, unmapped } = mapFilesToBlocks(db, changedFiles);
+  const blocks = db.prepare("SELECT id, name, responsibility FROM building_blocks").all();
+  if (mapped.size > 0) {
+    lines.push("## Affected Building Blocks", "");
+    for (const [blockId, files] of mapped) {
+      const block = blocks.find((b) => b.id === blockId);
+      const name = block ? block.name : blockId;
+      const resp = block ? block.responsibility : "";
+      lines.push(`### ${name} (\`${blockId}\`)`, "");
+      if (resp) lines.push(`**Responsibility:** ${resp}`, "");
+      lines.push(`**Changed files:** ${files.length}`, "");
+      for (const f of files.slice(0, 10)) {
+        lines.push(`- \`${f}\``);
+      }
+      if (files.length > 10) {
+        lines.push(`- ... and ${files.length - 10} more`);
+      }
+      lines.push("");
+    }
+  }
+  if (unmapped.length > 0) {
+    lines.push("## Unmapped Files", "");
+    lines.push(
+      `${unmapped.length} file(s) not mapped to any building block:`,
+      ""
+    );
+    for (const f of unmapped.slice(0, 10)) {
+      lines.push(`- \`${f}\``);
+    }
+    if (unmapped.length > 10) {
+      lines.push(`- ... and ${unmapped.length - 10} more`);
+    }
+    lines.push("");
+  }
+}
+function runCustomRoleCheck(db, lines, roleDef) {
+  if (roleDef.qualityFocus.length > 0) {
+    appendQualityScenarios(db, lines, roleDef.qualityFocus);
+  } else {
+    appendQualityScenarios(db, lines);
+  }
+  appendDriftSection(db, lines);
+}
+
+// src/server.ts
+function createArcBridgeServer() {
+  const server = new McpServer({
+    name: "arcbridge",
+    version: "0.1.0"
+  });
+  const ctx = createContext();
+  registerInitProject(server, ctx);
+  registerGetProjectStatus(server, ctx);
+  registerGetBuildingBlocks(server, ctx);
+  registerGetBuildingBlock(server, ctx);
+  registerGetQualityScenarios(server, ctx);
+  registerGetRelevantAdrs(server, ctx);
+  registerGetPhasePlan(server, ctx);
+  registerGetCurrentTasks(server, ctx);
+  registerUpdateTask(server, ctx);
+  registerCreateTask(server, ctx);
+  registerReindex(server, ctx);
+  registerSearchSymbols(server, ctx);
+  registerGetSymbol(server, ctx);
+  registerGetDependencyGraph(server, ctx);
+  registerGetComponentGraph(server, ctx);
+  registerGetRouteMap(server, ctx);
+  registerGetBoundaryAnalysis(server, ctx);
+  registerCheckDrift(server, ctx);
+  registerGetGuidance(server, ctx);
+  registerGetOpenQuestions(server, ctx);
+  registerProposeArc42Update(server, ctx);
+  registerGetPracticeReview(server, ctx);
+  registerCompletePhase(server, ctx);
+  registerActivateRole(server, ctx);
+  registerVerifyScenarios(server, ctx);
+  registerRunRoleCheck(server, ctx);
+  return server;
+}
+
+// src/index.ts
+async function main() {
+  const server = createArcBridgeServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map