@arcbridge/core 0.6.1 → 0.6.2

package/dist/index.js

@@ -205,6 +205,15 @@ var AgentRoleSchema = z6.object({
 
 // src/db/connection.ts
 import { DatabaseSync } from "node:sqlite";
+
+// src/utils/log.ts
+function logWarn(context, err) {
+  const detail = err === void 0 ? "" : `: ${err instanceof Error ? err.message : String(err)}`;
+  process.stderr.write(`[arcbridge] ${context}${detail}
+`);
+}
+
+// src/db/connection.ts
 var suppressed = false;
 function suppressSqliteWarning() {
   if (suppressed) return;
@@ -267,7 +276,8 @@ function transaction(db, fn) {
     } catch (err) {
       try {
         db.exec("ROLLBACK");
-      } catch {
+      } catch (rollbackErr) {
+        logWarn("Transaction rollback failed", rollbackErr);
       }
       throw err;
     } finally {
@@ -285,7 +295,8 @@ function transaction(db, fn) {
     try {
       db.exec(`ROLLBACK TO ${name}`);
       db.exec(`RELEASE ${name}`);
-    } catch {
+    } catch (rollbackErr) {
+      logWarn(`Savepoint ${name} rollback failed`, rollbackErr);
     }
     throw err;
   } finally {
@@ -871,8 +882,57 @@ function generateConfig(targetDir, input) {
 }
 
 // src/generators/arc42-generator.ts
-import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join4 } from "path";
+import { mkdirSync as mkdirSync2 } from "fs";
+
+// src/utils/fs.ts
+import {
+  writeFileSync as writeFileSync2,
+  renameSync,
+  unlinkSync,
+  statSync,
+  chmodSync,
+  lstatSync,
+  realpathSync
+} from "fs";
+import { dirname, basename, join as join2 } from "path";
+var tmpCounter = 0;
+function atomicWriteFileSync(filePath, content) {
+  let target;
+  let mode;
+  try {
+    target = realpathSync(filePath);
+    mode = statSync(target).mode & 511;
+  } catch {
+    let isDanglingLink = false;
+    try {
+      isDanglingLink = lstatSync(filePath).isSymbolicLink();
+    } catch {
+    }
+    if (isDanglingLink) {
+      writeFileSync2(filePath, content, "utf-8");
+      return;
+    }
+    target = filePath;
+  }
+  const tmpPath = join2(
+    dirname(target),
+    `.${basename(target)}.${process.pid}.${tmpCounter++}.tmp`
+  );
+  try {
+    writeFileSync2(tmpPath, content, "utf-8");
+    if (mode !== void 0) chmodSync(tmpPath, mode);
+    renameSync(tmpPath, target);
+  } catch (err) {
+    try {
+      unlinkSync(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+}
+
+// src/generators/arc42-generator.ts
+import { join as join5 } from "path";
 import matter from "gray-matter";
 import { stringify as stringify2 } from "yaml";
 
@@ -1046,11 +1106,11 @@ ${input.quality_priorities.map((q) => `| ${q} | *How will you achieve ${q}?* |`)
 
 // src/templates/arc42/05-building-blocks.ts
 import { existsSync as existsSync2, readdirSync } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 
 // src/templates/arc42/detect-layout.ts
 import { existsSync } from "fs";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 function detectProjectLayout(projectRoot, template) {
   const srcPrefix = detectSrcPrefix(projectRoot);
   const appPrefix = detectAppPrefix(projectRoot, srcPrefix);
@@ -1059,13 +1119,13 @@ function detectProjectLayout(projectRoot, template) {
 }
 function detectSrcPrefix(projectRoot) {
   if (!projectRoot) return "src/";
-  if (existsSync(join2(projectRoot, "src"))) return "src/";
+  if (existsSync(join3(projectRoot, "src"))) return "src/";
   return "";
 }
 function detectAppPrefix(projectRoot, srcPrefix) {
   if (!projectRoot) return `${srcPrefix}app`;
-  if (existsSync(join2(projectRoot, "src", "app"))) return "src/app";
-  if (existsSync(join2(projectRoot, "app"))) return "app";
+  if (existsSync(join3(projectRoot, "src", "app"))) return "src/app";
+  if (existsSync(join3(projectRoot, "app"))) return "app";
   return `${srcPrefix}app`;
 }
 function getEntrypoints(template, srcPrefix, appPrefix) {
@@ -1252,11 +1312,11 @@ function buildingBlocksTemplate(input) {
       if (primaryService && primaryService.path !== ".") {
         prefix = primaryService.path.endsWith("/") ? primaryService.path : `${primaryService.path}/`;
       } else {
-        const srcDir = join3(root, "src");
+        const srcDir = join4(root, "src");
         if (existsSync2(srcDir)) {
           const entries = readdirSync(srcDir).sort();
           const projDir = entries.find(
-            (e) => existsSync2(join3(srcDir, e, `${e}.csproj`)) || existsSync2(join3(srcDir, e, "Program.cs"))
+            (e) => existsSync2(join4(srcDir, e, `${e}.csproj`)) || existsSync2(join4(srcDir, e, "Program.cs"))
           );
           if (projDir) prefix = `src/${projDir}/`;
         }
@@ -2897,11 +2957,11 @@ Track technical debt items for ${input.name} here. Each item should include:
 // src/generators/arc42-generator.ts
 function writeMarkdownWithFrontmatter(filePath, frontmatter, body) {
   const content = matter.stringify(body, frontmatter);
-  writeFileSync2(filePath, content, "utf-8");
+  atomicWriteFileSync(filePath, content);
 }
 function generateArc42(targetDir, input) {
-  const arc42Dir = join4(targetDir, ".arcbridge", "arc42");
-  const decisionsDir = join4(arc42Dir, "09-decisions");
+  const arc42Dir = join5(targetDir, ".arcbridge", "arc42");
+  const decisionsDir = join5(arc42Dir, "09-decisions");
   mkdirSync2(arc42Dir, { recursive: true });
   mkdirSync2(decisionsDir, { recursive: true });
   const sections = [
@@ -2918,25 +2978,24 @@ function generateArc42(targetDir, input) {
   const inputWithRoot = { ...input, projectRoot: targetDir };
   for (const { file, template } of sections) {
     const { frontmatter, body } = template(inputWithRoot);
-    writeMarkdownWithFrontmatter(join4(arc42Dir, file), frontmatter, body);
+    writeMarkdownWithFrontmatter(join5(arc42Dir, file), frontmatter, body);
   }
   const adr = firstAdrTemplate(inputWithRoot);
   writeMarkdownWithFrontmatter(
-    join4(decisionsDir, adr.filename),
+    join5(decisionsDir, adr.filename),
     adr.frontmatter,
     adr.body
   );
   const qualityScenarios = qualityScenariosTemplate(input);
-  writeFileSync2(
-    join4(arc42Dir, "10-quality-scenarios.yaml"),
-    stringify2(qualityScenarios),
-    "utf-8"
+  atomicWriteFileSync(
+    join5(arc42Dir, "10-quality-scenarios.yaml"),
+    stringify2(qualityScenarios)
   );
 }
 
 // src/generators/plan-generator.ts
 import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import { stringify as stringify3 } from "yaml";
 
 // src/templates/phases/nextjs-app-router.ts
@@ -4572,25 +4631,25 @@ var planTemplates = {
   "fullstack-nextjs-dotnet": { plan: phasePlanTemplate7, tasks: phaseTasksTemplate7 }
 };
 function generatePlan(targetDir, input) {
-  const planDir = join5(targetDir, ".arcbridge", "plan");
-  const tasksDir = join5(planDir, "tasks");
+  const planDir = join6(targetDir, ".arcbridge", "plan");
+  const tasksDir = join6(planDir, "tasks");
   mkdirSync3(planDir, { recursive: true });
   mkdirSync3(tasksDir, { recursive: true });
   const tmpl = planTemplates[input.template] ?? planTemplates["nextjs-app-router"];
   const phasePlan = tmpl.plan(input);
-  writeFileSync3(join5(planDir, "phases.yaml"), stringify3(phasePlan), "utf-8");
+  writeFileSync3(join6(planDir, "phases.yaml"), stringify3(phasePlan), "utf-8");
   for (const phase of phasePlan.phases) {
     const taskFile = tmpl.tasks(input, phase.id);
     if (taskFile) {
       writeFileSync3(
-        join5(tasksDir, `${phase.id}.yaml`),
+        join6(tasksDir, `${phase.id}.yaml`),
         stringify3(taskFile),
         "utf-8"
       );
     }
   }
   writeFileSync3(
-    join5(planDir, "sync-log.md"),
+    join6(planDir, "sync-log.md"),
     `# Sync Log
 
 Architecture sync events are recorded here.
@@ -4601,7 +4660,7 @@ Architecture sync events are recorded here.
 
 // src/generators/agent-generator.ts
 import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 import matter2 from "gray-matter";
 
 // src/templates/agents/architect.ts
@@ -5247,10 +5306,10 @@ var UI_TEMPLATES = /* @__PURE__ */ new Set(["nextjs-app-router", "react-vite", "
 function writeAgentRole(dir, role) {
   const { system_prompt, ...frontmatter } = role;
   const content = matter2.stringify(system_prompt, frontmatter);
-  writeFileSync4(join6(dir, `${role.role_id}.md`), content, "utf-8");
+  writeFileSync4(join7(dir, `${role.role_id}.md`), content, "utf-8");
 }
 function generateAgentRoles(targetDir, template) {
-  const agentsDir = join6(targetDir, ".arcbridge", "agents");
+  const agentsDir = join7(targetDir, ".arcbridge", "agents");
   mkdirSync4(agentsDir, { recursive: true });
   const roles = [
     architectTemplate(),
@@ -5271,13 +5330,23 @@ function generateAgentRoles(targetDir, template) {
 }
 
 // src/generators/db-generator.ts
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 import { existsSync as existsSync3, readFileSync, readdirSync as readdirSync2, appendFileSync } from "fs";
 import { parse } from "yaml";
 import matter3 from "gray-matter";
+var RefreshValidationError = class extends Error {
+  constructor(file, detail) {
+    super(`${file} failed validation: ${detail} \u2014 refresh aborted, fix the file and re-run.`);
+    this.file = file;
+    this.name = "RefreshValidationError";
+  }
+};
+function formatZodIssues(error) {
+  return error.issues.map((i) => i.path.length ? `${i.path.join(".")}: ${i.message}` : i.message).join(", ");
+}
 function populateBuildingBlocks(db, targetDir) {
   const warnings = [];
-  const filePath = join7(
+  const filePath = join8(
     targetDir,
     ".arcbridge",
     "arc42",
@@ -5288,13 +5357,21 @@ function populateBuildingBlocks(db, targetDir) {
     return warnings;
   }
   const raw = readFileSync(filePath, "utf-8");
-  const { data } = matter3(raw);
+  let data;
+  try {
+    ({ data } = matter3(raw));
+  } catch (err) {
+    throw new RefreshValidationError(
+      ".arcbridge/arc42/05-building-blocks.md",
+      err instanceof Error ? err.message : String(err)
+    );
+  }
   const result = BuildingBlocksFrontmatterSchema.safeParse(data);
   if (!result.success) {
-    warnings.push(
-      `Invalid building blocks frontmatter: ${result.error.issues.map((i) => i.path.length ? `${i.path.join(".")}: ${i.message}` : i.message).join(", ")}`
+    throw new RefreshValidationError(
+      ".arcbridge/arc42/05-building-blocks.md",
+      formatZodIssues(result.error)
     );
-    return warnings;
   }
   const fm = result.data;
   const insert = db.prepare(`
@@ -5319,7 +5396,7 @@ function populateBuildingBlocks(db, targetDir) {
 }
 function populateQualityScenarios(db, targetDir) {
   const warnings = [];
-  const filePath = join7(
+  const filePath = join8(
     targetDir,
     ".arcbridge",
     "arc42",
@@ -5330,13 +5407,21 @@ function populateQualityScenarios(db, targetDir) {
     return warnings;
   }
   const raw = readFileSync(filePath, "utf-8");
-  const parsed = parse(raw);
+  let parsed;
+  try {
+    parsed = parse(raw);
+  } catch (err) {
+    throw new RefreshValidationError(
+      ".arcbridge/arc42/10-quality-scenarios.yaml",
+      err instanceof Error ? err.message : String(err)
+    );
+  }
   const result = QualityScenariosFileSchema.safeParse(parsed);
   if (!result.success) {
-    warnings.push(
-      `Invalid quality scenarios: ${result.error.issues.map((i) => i.path.length ? `${i.path.join(".")}: ${i.message}` : i.message).join(", ")}`
+    throw new RefreshValidationError(
+      ".arcbridge/arc42/10-quality-scenarios.yaml",
+      formatZodIssues(result.error)
     );
-    return warnings;
   }
   const insert = db.prepare(`
     INSERT OR IGNORE INTO quality_scenarios (id, name, category, scenario, expected, priority, linked_code, linked_tests, linked_blocks, verification, status)
@@ -5361,19 +5446,27 @@ function populateQualityScenarios(db, targetDir) {
 }
 function populatePhases(db, targetDir) {
   const warnings = [];
-  const phasesPath = join7(targetDir, ".arcbridge", "plan", "phases.yaml");
+  const phasesPath = join8(targetDir, ".arcbridge", "plan", "phases.yaml");
   if (!existsSync3(phasesPath)) {
     warnings.push("Phases file not found, skipping");
     return warnings;
   }
   const raw = readFileSync(phasesPath, "utf-8");
-  const parsed = parse(raw);
+  let parsed;
+  try {
+    parsed = parse(raw);
+  } catch (err) {
+    throw new RefreshValidationError(
+      ".arcbridge/plan/phases.yaml",
+      err instanceof Error ? err.message : String(err)
+    );
+  }
   const result = PhasesFileSchema.safeParse(parsed);
   if (!result.success) {
-    warnings.push(
-      `Invalid phases file: ${result.error.issues.map((i) => i.path.length ? `${i.path.join(".")}: ${i.message}` : i.message).join(", ")}`
+    throw new RefreshValidationError(
+      ".arcbridge/plan/phases.yaml",
+      formatZodIssues(result.error)
     );
-    return warnings;
   }
   const insertPhase = db.prepare(`
     INSERT OR IGNORE INTO phases (id, name, phase_number, status, description, gate_status, started_at, completed_at)
@@ -5395,7 +5488,7 @@ function populatePhases(db, targetDir) {
       phase.started_at ?? null,
       phase.completed_at ?? null
     );
-    const taskPath = join7(
+    const taskPath = join8(
       targetDir,
       ".arcbridge",
       "plan",
@@ -5404,7 +5497,15 @@ function populatePhases(db, targetDir) {
     );
     if (!existsSync3(taskPath)) continue;
     const taskRaw = readFileSync(taskPath, "utf-8");
-    const taskParsed = parse(taskRaw);
+    let taskParsed;
+    try {
+      taskParsed = parse(taskRaw);
+    } catch (err) {
+      warnings.push(
+        `Invalid task file for ${phase.id}: ${err instanceof Error ? err.message : String(err)}`
+      );
+      continue;
+    }
     const taskResult = TaskFileSchema.safeParse(taskParsed);
     if (!taskResult.success) {
       warnings.push(
@@ -5430,7 +5531,7 @@ function populatePhases(db, targetDir) {
 }
 function populateAdrs(db, targetDir) {
   const warnings = [];
-  const decisionsDir = join7(
+  const decisionsDir = join8(
     targetDir,
     ".arcbridge",
     "arc42",
@@ -5445,8 +5546,17 @@ function populateAdrs(db, targetDir) {
     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `);
   for (const file of files) {
-    const raw = readFileSync(join7(decisionsDir, file), "utf-8");
-    const { data, content } = matter3(raw);
+    const raw = readFileSync(join8(decisionsDir, file), "utf-8");
+    let data;
+    let content;
+    try {
+      ({ data, content } = matter3(raw));
+    } catch (err) {
+      warnings.push(
+        `Invalid ADR ${file}: ${err instanceof Error ? err.message : String(err)}`
+      );
+      continue;
+    }
     const result = AdrFrontmatterSchema.safeParse(data);
     if (!result.success) {
       warnings.push(
@@ -5540,7 +5650,7 @@ function refreshFromDocs(db, targetDir) {
   return warnings;
 }
 function generateDatabase(targetDir, input) {
-  const dbPath = join7(targetDir, ".arcbridge", "index.db");
+  const dbPath = join8(targetDir, ".arcbridge", "index.db");
   const db = openDatabase(dbPath);
   initializeSchema(db);
   const allWarnings = [];
@@ -5561,7 +5671,7 @@ function generateDatabase(targetDir, input) {
   return { db, warnings: allWarnings };
 }
 function ensureGitignore(targetDir) {
-  const gitignorePath = join7(targetDir, ".gitignore");
+  const gitignorePath = join8(targetDir, ".gitignore");
   const marker = ".arcbridge/index.db";
   if (existsSync3(gitignorePath)) {
     const content = readFileSync(gitignorePath, "utf-8");
@@ -5578,14 +5688,14 @@ function ensureGitignore(targetDir) {
 
 // src/indexer/index.ts
 import ts6 from "typescript";
-import { relative as relative5, join as join16 } from "path";
+import { relative as relative5, join as join17 } from "path";
 import { existsSync as existsSync7, readFileSync as readFileSync9 } from "fs";
 import { execFileSync as execFileSync2 } from "child_process";
 import YAML from "yaml";
 
 // src/indexer/program.ts
 import ts from "typescript";
-import { join as join8, dirname } from "path";
+import { join as join9, dirname as dirname2 } from "path";
 function createTsProgram(options) {
   const projectRoot = options.projectRoot;
   const configPath = options.tsconfigPath ?? ts.findConfigFile(projectRoot, ts.sys.fileExists, "tsconfig.json");
@@ -5609,8 +5719,8 @@ function createTsProgram(options) {
     for (const ref of config.references) {
       const refRelPath = typeof ref === "string" ? ref : ref.path;
       if (!refRelPath) continue;
-      const refFullPath = join8(dirname(configPath), refRelPath);
-      const refConfigPath = refFullPath.endsWith(".json") ? refFullPath : join8(refFullPath, "tsconfig.json");
+      const refFullPath = join9(dirname2(configPath), refRelPath);
+      const refConfigPath = refFullPath.endsWith(".json") ? refFullPath : join9(refFullPath, "tsconfig.json");
       if (ts.sys.fileExists(refConfigPath)) {
         const refConfig = ts.readConfigFile(refConfigPath, ts.sys.readFile);
         const rc = refConfig.config;
@@ -5638,7 +5748,7 @@ function createTsProgram(options) {
   const parsed = ts.parseJsonConfigFileContent(
     configFile.config,
     ts.sys,
-    join8(projectRoot),
+    join9(projectRoot),
     { noEmit: true },
     resolvedConfigPath
   );
@@ -6316,7 +6426,7 @@ function getPropsType(node, checker) {
   if (typeStr === "{}" || typeStr === "any") return null;
   return typeStr;
 }
-function analyzeComponents(sourceFiles, checker, projectRoot, db, allClient = false) {
+function analyzeComponents(sourceFiles, checker, projectRoot, db, allClient = false, service = "main") {
   const components = [];
   for (const sf of sourceFiles) {
     const relPath = relative2(projectRoot, sf.fileName);
@@ -6443,22 +6553,24 @@ function analyzeComponents(sourceFiles, checker, projectRoot, db, allClient = fa
       }
     });
   }
-  writeComponents(db, components);
+  writeComponents(db, components, service);
   return components.length;
 }
-function writeComponents(db, components) {
-  if (components.length === 0) return;
-  db.prepare("DELETE FROM components").run();
-  const insert = db.prepare(`
-    INSERT OR IGNORE INTO components (
-      symbol_id, is_client, is_server_action, has_state,
-      context_providers, context_consumers, props_type
-    ) VALUES (?, ?, ?, ?, ?, ?, ?)
-  `);
-  const existingIds = new Set(
-    db.prepare("SELECT id FROM symbols").all().map((r) => r.id)
-  );
+function writeComponents(db, components, service) {
   transaction(db, () => {
+    db.prepare(
+      "DELETE FROM components WHERE symbol_id IN (SELECT id FROM symbols WHERE service = ?)"
+    ).run(service);
+    if (components.length === 0) return;
+    const insert = db.prepare(`
+      INSERT OR IGNORE INTO components (
+        symbol_id, is_client, is_server_action, has_state,
+        context_providers, context_consumers, props_type
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+    const existingIds = new Set(
+      db.prepare("SELECT id FROM symbols WHERE service = ?").all(service).map((r) => r.id)
+    );
     for (const c of components) {
       if (!existingIds.has(c.symbolId)) continue;
       insert.run(
@@ -6475,8 +6587,8 @@ function writeComponents(db, components) {
 }
 
 // src/indexer/route-analyzer.ts
-import { existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync2, statSync } from "fs";
-import { join as join9, relative as relative3 } from "path";
+import { existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
+import { join as join10, relative as relative3 } from "path";
 var FILE_KIND_MAP = {
   "page": "page",
   "layout": "layout",
@@ -6487,11 +6599,11 @@ var FILE_KIND_MAP = {
 };
 var TS_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
 function analyzeRoutes(projectRoot, db, service = "main") {
-  let appDir = join9(projectRoot, "app");
+  let appDir = join10(projectRoot, "app");
   try {
-    if (!existsSync4(appDir) || !statSync(appDir).isDirectory()) {
-      appDir = join9(projectRoot, "src", "app");
-      if (!existsSync4(appDir) || !statSync(appDir).isDirectory()) {
+    if (!existsSync4(appDir) || !statSync2(appDir).isDirectory()) {
+      appDir = join10(projectRoot, "src", "app");
+      if (!existsSync4(appDir) || !statSync2(appDir).isDirectory()) {
         return 0;
       }
     }
@@ -6501,7 +6613,7 @@ function analyzeRoutes(projectRoot, db, service = "main") {
   const routes = [];
   const layoutStack = [];
   for (const ext of TS_EXTENSIONS) {
-    const middlewarePath = join9(projectRoot, `middleware${ext}`);
+    const middlewarePath = join10(projectRoot, `middleware${ext}`);
     if (existsSync4(middlewarePath)) {
       routes.push({
         id: `route::middleware`,
@@ -6529,7 +6641,7 @@ function walkAppDir(dir, routePath, routes, layoutStack, service, projectRoot) {
   const currentLayout = layoutStack.length > 0 ? layoutStack[layoutStack.length - 1] : null;
   for (const [convention, kind] of Object.entries(FILE_KIND_MAP)) {
     for (const ext of TS_EXTENSIONS) {
-      const filePath = join9(dir, `${convention}${ext}`);
+      const filePath = join10(dir, `${convention}${ext}`);
       if (existsSync4(filePath)) {
         const relPath = relative3(projectRoot, dir);
         const routeId = `route::${relPath}/${convention}`;
@@ -6554,9 +6666,9 @@ function walkAppDir(dir, routePath, routes, layoutStack, service, projectRoot) {
     }
   }
   for (const entry of entries.sort()) {
-    const fullPath = join9(dir, entry);
+    const fullPath = join10(dir, entry);
     try {
-      if (!statSync(fullPath).isDirectory()) continue;
+      if (!statSync2(fullPath).isDirectory()) continue;
     } catch {
       continue;
     }
@@ -6721,33 +6833,34 @@ function writeDependencies(db, dependencies) {
 
 // src/indexer/dotnet-indexer.ts
 import { execFileSync } from "child_process";
-import { resolve, join as join10, dirname as dirname2, relative as relative4, basename } from "path";
+import { resolve, join as join11, dirname as dirname3, relative as relative4, basename as basename2 } from "path";
 import { readdirSync as readdirSync4, readFileSync as readFileSync3, existsSync as existsSync5, accessSync, constants } from "fs";
 import { fileURLToPath } from "url";
 function findDotnetProject(projectRoot) {
   try {
     const entries = readdirSync4(projectRoot);
     const sln = entries.find((e) => e.endsWith(".sln"));
-    if (sln) return join10(projectRoot, sln);
+    if (sln) return join11(projectRoot, sln);
     const csproj = entries.find((e) => e.endsWith(".csproj"));
-    if (csproj) return join10(projectRoot, csproj);
+    if (csproj) return join11(projectRoot, csproj);
     return null;
-  } catch {
+  } catch (err) {
+    logWarn(`Could not scan ${projectRoot} for .sln/.csproj`, err);
     return null;
   }
 }
 function parseSolutionProjects(slnPath) {
   const content = readFileSync3(slnPath, "utf-8");
-  const slnDir = dirname2(slnPath);
+  const slnDir = dirname3(slnPath);
   const projects = [];
   const projectPattern = /Project\("\{[^}]+\}"\)\s*=\s*"([^"]+)",\s*"([^"]+\.csproj)"/g;
   let match;
   while ((match = projectPattern.exec(content)) !== null) {
     const name = match[1];
     const relativeCsprojPath = match[2].replace(/\\/g, "/");
-    const fullCsprojPath = resolve(join10(slnDir, relativeCsprojPath));
+    const fullCsprojPath = resolve(join11(slnDir, relativeCsprojPath));
     if (!existsSync5(fullCsprojPath)) continue;
-    const projectDir = relative4(slnDir, dirname2(fullCsprojPath)).replace(/\\/g, "/") || ".";
+    const projectDir = relative4(slnDir, dirname3(fullCsprojPath)).replace(/\\/g, "/") || ".";
     const isTestProject = /[.\x2d]tests?$/i.test(name) || /[.\x2d](unit|integration|functional|e2e)tests?$/i.test(name);
     projects.push({
       name,
@@ -6763,7 +6876,7 @@ function discoverDotnetServices(projectRoot) {
   if (!slnPath || !slnPath.endsWith(".sln")) {
     const csproj = slnPath;
     if (!csproj) return [];
-    const name = basename(csproj, ".csproj");
+    const name = basename2(csproj, ".csproj");
     return [{
       name,
       path: ".",
@@ -6782,7 +6895,7 @@ function hasGlobalTool() {
     if (!dir) continue;
     for (const ext of extensions) {
       try {
-        accessSync(join10(dir, `${name}${ext}`), constants.X_OK);
+        accessSync(join11(dir, `${name}${ext}`), constants.X_OK);
         return true;
       } catch {
         continue;
@@ -6792,7 +6905,7 @@ function hasGlobalTool() {
   return false;
 }
 function resolveIndexerProject() {
-  const currentDir4 = dirname2(fileURLToPath(import.meta.url));
+  const currentDir4 = dirname3(fileURLToPath(import.meta.url));
   const candidates = [
     resolve(currentDir4, "../../../../dotnet-indexer/ArcBridge.DotnetIndexer.csproj"),
     resolve(currentDir4, "../../../dotnet-indexer/ArcBridge.DotnetIndexer.csproj"),
@@ -6822,6 +6935,7 @@ function runDotnetIndexer(dotnetProject, hashesJson, cwd) {
       return execFileSync("arcbridge-dotnet-indexer", args, { ...EXEC_OPTIONS, cwd });
     } catch (err) {
       globalToolError = err;
+      logWarn("Global tool arcbridge-dotnet-indexer failed, trying monorepo source fallback", err);
     }
   }
   const indexerProject = resolveIndexerProject();
@@ -6839,7 +6953,8 @@ function runDotnetIndexer(dotnetProject, hashesJson, cwd) {
       ["run", "--project", indexerProject, "--no-build", "--", ...args],
       { ...EXEC_OPTIONS, cwd }
     );
-  } catch {
+  } catch (err) {
+    logWarn(".NET indexer --no-build run failed, retrying with build (expected on first run)", err);
     try {
       return execFileSync(
         "dotnet",
@@ -6941,15 +7056,15 @@ function indexDotnetProjectRoslyn(db, options) {
 
 // src/indexer/csharp/indexer.ts
 import { readFileSync as readFileSync4 } from "fs";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 import { globbySync } from "globby";
 
 // src/indexer/csharp/parser.ts
 import { accessSync as accessSync2, constants as constants2 } from "fs";
-import { dirname as dirname3, resolve as resolve2 } from "path";
+import { dirname as dirname4, resolve as resolve2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import "web-tree-sitter";
-var currentDir = dirname3(fileURLToPath2(import.meta.url));
+var currentDir = dirname4(fileURLToPath2(import.meta.url));
 var cachedParser = null;
 var initPromise = null;
 function resolveGrammarPath() {
@@ -7807,7 +7922,7 @@ async function indexCSharpTreeSitter(db, options) {
   for (const filePath of csFiles) {
     const relPath = filePath.replace(/\\/g, "/");
     currentPaths.add(relPath);
-    const fullPath = join11(projectRoot, relPath);
+    const fullPath = join12(projectRoot, relPath);
     const content = readFileSync4(fullPath, "utf-8");
     const hash = hashContent(content);
     const tree = parseCSharp(content);
@@ -7884,15 +7999,15 @@ async function indexCSharpTreeSitter(db, options) {
 
 // src/indexer/python/indexer.ts
 import { readFileSync as readFileSync5 } from "fs";
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 import { globbySync as globbySync2 } from "globby";
 
 // src/indexer/python/parser.ts
 import { accessSync as accessSync3, constants as constants3 } from "fs";
-import { dirname as dirname4, resolve as resolve3 } from "path";
+import { dirname as dirname5, resolve as resolve3 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import "web-tree-sitter";
-var currentDir2 = dirname4(fileURLToPath3(import.meta.url));
+var currentDir2 = dirname5(fileURLToPath3(import.meta.url));
 var cachedParser2 = null;
 var initPromise2 = null;
 function resolveGrammarPath2() {
@@ -8508,7 +8623,7 @@ async function indexPythonTreeSitter(db, options) {
   for (const filePath of pyFiles) {
     const relPath = filePath.replace(/\\/g, "/");
     currentPaths.add(relPath);
-    const fullPath = join12(projectRoot, relPath);
+    const fullPath = join13(projectRoot, relPath);
     const content = readFileSync5(fullPath, "utf-8");
     const hash = hashContent(content);
     const tree = parsePython(content);
@@ -8585,15 +8700,15 @@ async function indexPythonTreeSitter(db, options) {
 
 // src/indexer/go/indexer.ts
 import { readFileSync as readFileSync6 } from "fs";
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 import { globbySync as globbySync3 } from "globby";
 
 // src/indexer/go/parser.ts
 import { accessSync as accessSync4, constants as constants4 } from "fs";
-import { dirname as dirname5, resolve as resolve4 } from "path";
+import { dirname as dirname6, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import "web-tree-sitter";
-var currentDir3 = dirname5(fileURLToPath4(import.meta.url));
+var currentDir3 = dirname6(fileURLToPath4(import.meta.url));
 var cachedParser3 = null;
 var initPromise3 = null;
 function resolveGrammarPath3() {
@@ -9333,7 +9448,7 @@ async function indexGoTreeSitter(db, options) {
   for (const filePath of goFiles) {
     const relPath = filePath.replace(/\\/g, "/");
     currentPaths.add(relPath);
-    const fullPath = join13(projectRoot, relPath);
+    const fullPath = join14(projectRoot, relPath);
     const content = readFileSync6(fullPath, "utf-8");
     const hash = hashContent(content);
     const tree = parseGo(content);
@@ -9409,11 +9524,11 @@ async function indexGoTreeSitter(db, options) {
 }
 
 // src/indexer/package-deps.ts
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 import { existsSync as existsSync6, readFileSync as readFileSync7, readdirSync as readdirSync5 } from "fs";
 function indexPackageDependencies(db, projectRoot, service = "main") {
   const deps = [];
-  const pkgJsonPath = join14(projectRoot, "package.json");
+  const pkgJsonPath = join15(projectRoot, "package.json");
   if (existsSync6(pkgJsonPath)) {
     deps.push(...parsePackageJson(pkgJsonPath));
   }
@@ -9479,7 +9594,7 @@ function findCsprojFiles(dir, maxDepth = 4) {
       const entries = readdirSync5(currentDir4, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.name === "bin" || entry.name === "obj" || entry.name === "node_modules" || entry.name === ".git") continue;
-        const fullPath = join14(currentDir4, entry.name);
+        const fullPath = join15(currentDir4, entry.name);
         if (entry.isFile() && entry.name.endsWith(".csproj")) {
           results.push(fullPath);
         } else if (entry.isDirectory()) {
@@ -9495,10 +9610,10 @@ function findCsprojFiles(dir, maxDepth = 4) {
 
 // src/config/loader.ts
 import { readFileSync as readFileSync8 } from "fs";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 import yaml from "yaml";
 function loadConfig(projectRoot) {
-  const configPath = join15(projectRoot, ".arcbridge", "config.yaml");
+  const configPath = join16(projectRoot, ".arcbridge", "config.yaml");
   try {
     const raw = readFileSync8(configPath, "utf-8");
     const parsed = ArcBridgeConfigSchema.safeParse(yaml.parse(raw));
@@ -9517,16 +9632,16 @@ function loadConfig(projectRoot) {
 
 // src/indexer/index.ts
 function detectProjectLanguage(projectRoot) {
-  if (existsSync7(join16(projectRoot, "ProjectSettings")) && existsSync7(join16(projectRoot, "Assets"))) {
+  if (existsSync7(join17(projectRoot, "ProjectSettings")) && existsSync7(join17(projectRoot, "Assets"))) {
     return "csharp";
   }
-  if (existsSync7(join16(projectRoot, "tsconfig.json"))) return "typescript";
+  if (existsSync7(join17(projectRoot, "tsconfig.json"))) return "typescript";
   if (findDotnetProject(projectRoot)) return "csharp";
-  if (existsSync7(join16(projectRoot, "go.mod"))) return "go";
-  if (existsSync7(join16(projectRoot, "pyproject.toml")) || existsSync7(join16(projectRoot, "requirements.txt")) || existsSync7(join16(projectRoot, "setup.py"))) {
+  if (existsSync7(join17(projectRoot, "go.mod"))) return "go";
+  if (existsSync7(join17(projectRoot, "pyproject.toml")) || existsSync7(join17(projectRoot, "requirements.txt")) || existsSync7(join17(projectRoot, "setup.py"))) {
     return "python";
   }
-  if (existsSync7(join16(projectRoot, "package.json"))) return "typescript";
+  if (existsSync7(join17(projectRoot, "package.json"))) return "typescript";
   return "typescript";
 }
 async function indexProject(db, options) {
@@ -9582,7 +9697,7 @@ function resolveCSharpBackend(projectRoot) {
   let setting = config?.indexing?.csharp_indexer;
   if (!setting && error) {
     try {
-      const raw = readFileSync9(join16(projectRoot, ".arcbridge", "config.yaml"), "utf-8");
+      const raw = readFileSync9(join17(projectRoot, ".arcbridge", "config.yaml"), "utf-8");
       const parsed = YAML.parse(raw);
       const rawSetting = parsed?.indexing?.csharp_indexer;
       if (rawSetting === "roslyn" || rawSetting === "tree-sitter") {
@@ -9654,7 +9769,7 @@ function indexTypeScriptProject(db, options) {
   const CLIENT_ONLY_TEMPLATES = /* @__PURE__ */ new Set(["react-vite", "angular-app"]);
   const projectType = db.prepare("SELECT value FROM arcbridge_meta WHERE key = 'project_type'").get()?.value;
   const allClient = projectType ? CLIENT_ONLY_TEMPLATES.has(projectType) : false;
-  const componentsAnalyzed = analyzeComponents(sourceFiles, checker, projectRoot, db, allClient);
+  const componentsAnalyzed = analyzeComponents(sourceFiles, checker, projectRoot, db, allClient, service);
   const routesAnalyzed = analyzeRoutes(projectRoot, db, service);
   return {
     symbolsIndexed: allSymbols.length,
@@ -9980,11 +10095,11 @@ function safeParseJson(value, fallback) {
 }
 
 // src/sync/yaml-writer.ts
-import { join as join17 } from "path";
-import { existsSync as existsSync8, readFileSync as readFileSync10, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, unlinkSync } from "fs";
+import { join as join18 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync10, mkdirSync as mkdirSync5, unlinkSync as unlinkSync2 } from "fs";
 import { parse as parse2, stringify as stringify4 } from "yaml";
 function readTaskFile(projectRoot, phaseId) {
-  const path = join17(projectRoot, ".arcbridge", "plan", "tasks", `${phaseId}.yaml`);
+  const path = join18(projectRoot, ".arcbridge", "plan", "tasks", `${phaseId}.yaml`);
   if (!existsSync8(path)) return { error: "not-found" };
   const raw = readFileSync10(path, "utf-8");
   const result = TaskFileSchema.safeParse(parse2(raw));
@@ -9992,7 +10107,7 @@ function readTaskFile(projectRoot, phaseId) {
   return { data: result.data, path };
 }
 function readPhasesFile(projectRoot) {
-  const path = join17(projectRoot, ".arcbridge", "plan", "phases.yaml");
+  const path = join18(projectRoot, ".arcbridge", "plan", "phases.yaml");
   if (!existsSync8(path)) return { error: "not-found" };
   const raw = readFileSync10(path, "utf-8");
   const result = PhasesFileSchema.safeParse(parse2(raw));
@@ -10011,18 +10126,18 @@ function syncTaskToYaml(projectRoot, phaseId, taskId, status, completedAt) {
   } else if (status !== "done") {
     delete task.completed_at;
   }
-  writeFileSync5(taskPath, stringify4(taskFile), "utf-8");
+  atomicWriteFileSync(taskPath, stringify4(taskFile));
 }
 function addTaskToYaml(projectRoot, phaseId, task) {
-  const tasksDir = join17(projectRoot, ".arcbridge", "plan", "tasks");
+  const tasksDir = join18(projectRoot, ".arcbridge", "plan", "tasks");
   mkdirSync5(tasksDir, { recursive: true });
   const readResult = readTaskFile(projectRoot, phaseId);
   const taskFile = "error" in readResult ? { schema_version: 1, phase_id: phaseId, tasks: [] } : readResult.data;
   if (!taskFile.tasks.some((t) => t.id === task.id)) {
     taskFile.tasks.push(task);
   }
-  const taskPath = join17(tasksDir, `${phaseId}.yaml`);
-  writeFileSync5(taskPath, stringify4(taskFile), "utf-8");
+  const taskPath = join18(tasksDir, `${phaseId}.yaml`);
+  atomicWriteFileSync(taskPath, stringify4(taskFile));
 }
 function syncPhaseToYaml(projectRoot, phaseId, status, startedAt, completedAt) {
   const readResult = readPhasesFile(projectRoot);
@@ -10033,7 +10148,7 @@ function syncPhaseToYaml(projectRoot, phaseId, status, startedAt, completedAt) {
   phase.status = status;
   if (startedAt) phase.started_at = startedAt;
   if (completedAt) phase.completed_at = completedAt;
-  writeFileSync5(phasesPath, stringify4(phasesFile), "utf-8");
+  atomicWriteFileSync(phasesPath, stringify4(phasesFile));
 }
 function addPhaseToYaml(projectRoot, phase) {
   try {
@@ -10054,14 +10169,13 @@ function addPhaseToYaml(projectRoot, phase) {
         warning: `Phase number ${phase.phase_number} already used by '${conflicting?.id}'`
       };
     }
-    const tasksDir = join17(projectRoot, ".arcbridge", "plan", "tasks");
+    const tasksDir = join18(projectRoot, ".arcbridge", "plan", "tasks");
     mkdirSync5(tasksDir, { recursive: true });
-    const taskFilePath = join17(tasksDir, `${phase.id}.yaml`);
+    const taskFilePath = join18(tasksDir, `${phase.id}.yaml`);
     if (!existsSync8(taskFilePath)) {
-      writeFileSync5(
+      atomicWriteFileSync(
         taskFilePath,
-        stringify4({ schema_version: 1, phase_id: phase.id, tasks: [] }),
-        "utf-8"
+        stringify4({ schema_version: 1, phase_id: phase.id, tasks: [] })
       );
     }
     if (existingById) {
@@ -10076,7 +10190,7 @@ function addPhaseToYaml(projectRoot, phase) {
       gate_requirements: phase.gate_requirements ?? []
     });
     phasesFile.phases.sort((a, b) => a.phase_number - b.phase_number);
-    writeFileSync5(phasesPath, stringify4(phasesFile), "utf-8");
+    atomicWriteFileSync(phasesPath, stringify4(phasesFile));
     return { success: true };
   } catch (err) {
     return {
@@ -10086,7 +10200,7 @@ function addPhaseToYaml(projectRoot, phase) {
   }
 }
 function syncScenarioToYaml(projectRoot, scenarioId, status, linkedTests, verification) {
-  const scenarioPath = join17(
+  const scenarioPath = join18(
     projectRoot,
     ".arcbridge",
     "arc42",
@@ -10107,7 +10221,7 @@ function syncScenarioToYaml(projectRoot, scenarioId, status, linkedTests, verifi
   if (verification) {
     scenario.verification = verification;
   }
-  writeFileSync5(scenarioPath, stringify4(scenariosFile), "utf-8");
+  atomicWriteFileSync(scenarioPath, stringify4(scenariosFile));
 }
 function deleteTaskFromYaml(projectRoot, phaseId, taskId) {
   try {
@@ -10127,7 +10241,7 @@ function deleteTaskFromYaml(projectRoot, phaseId, taskId) {
     if (taskFile.tasks.length === before) {
       return { success: true };
     }
-    writeFileSync5(taskPath, stringify4(taskFile), "utf-8");
+    atomicWriteFileSync(taskPath, stringify4(taskFile));
     return { success: true };
   } catch (err) {
     return {
@@ -10151,10 +10265,10 @@ function deletePhaseFromYaml(projectRoot, phaseId) {
     if (phasesFile.phases.length === before) {
       return { success: false, warning: `Phase '${phaseId}' not found in phases.yaml` };
     }
-    writeFileSync5(phasesPath, stringify4(phasesFile), "utf-8");
-    const taskFilePath = join17(projectRoot, ".arcbridge", "plan", "tasks", `${phaseId}.yaml`);
+    atomicWriteFileSync(phasesPath, stringify4(phasesFile));
+    const taskFilePath = join18(projectRoot, ".arcbridge", "plan", "tasks", `${phaseId}.yaml`);
     try {
-      unlinkSync(taskFilePath);
+      unlinkSync2(taskFilePath);
     } catch (e) {
       if (e.code !== "ENOENT") throw e;
     }
@@ -10295,8 +10409,8 @@ function safeParseJson2(value, fallback) {
 }
 
 // src/generators/sync-generator.ts
-import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "fs";
-import { join as join18, dirname as dirname6 } from "path";
+import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync5 } from "fs";
+import { join as join19, dirname as dirname7 } from "path";
 
 // src/templates/sync/claude-skill.ts
 function claudeSkillTemplate(config) {
@@ -10474,30 +10588,30 @@ To enable automatic sync:
 function generateSyncFiles(targetDir, config) {
   const generated = [];
   const action = githubActionTemplate(config);
-  const actionPath = join18(targetDir, action.relativePath);
-  mkdirSync6(dirname6(actionPath), { recursive: true });
-  writeFileSync6(actionPath, action.content, "utf-8");
+  const actionPath = join19(targetDir, action.relativePath);
+  mkdirSync6(dirname7(actionPath), { recursive: true });
+  writeFileSync5(actionPath, action.content, "utf-8");
   generated.push(action.relativePath);
   if (config.platforms.includes("claude")) {
     const skill = claudeSkillTemplate(config);
-    const skillPath = join18(targetDir, skill.relativePath);
-    mkdirSync6(dirname6(skillPath), { recursive: true });
-    writeFileSync6(skillPath, skill.content, "utf-8");
+    const skillPath = join19(targetDir, skill.relativePath);
+    mkdirSync6(dirname7(skillPath), { recursive: true });
+    writeFileSync5(skillPath, skill.content, "utf-8");
     generated.push(skill.relativePath);
   }
   if (config.platforms.includes("copilot")) {
     const hook = copilotHookTemplate(config);
-    const hookPath = join18(targetDir, hook.relativePath);
-    mkdirSync6(dirname6(hookPath), { recursive: true });
-    writeFileSync6(hookPath, hook.content, "utf-8");
+    const hookPath = join19(targetDir, hook.relativePath);
+    mkdirSync6(dirname7(hookPath), { recursive: true });
+    writeFileSync5(hookPath, hook.content, "utf-8");
     generated.push(hook.relativePath);
   }
   return generated;
 }
 
 // src/metrics/activity.ts
-import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync7 } from "fs";
-import { join as join19 } from "path";
+import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync7 } from "fs";
+import { join as join20 } from "path";
 function insertActivity(db, params) {
   const totalTokens = params.totalTokens ?? (params.inputTokens != null && params.outputTokens != null ? params.inputTokens + params.outputTokens : null);
   const stmt = db.prepare(`
@@ -10655,7 +10769,7 @@ function exportMetrics(db, projectRoot, format, params, maxRows = 1e5) {
   });
   const rows = result.rows;
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const dir = join19(projectRoot, ".arcbridge", "metrics");
+  const dir = join20(projectRoot, ".arcbridge", "metrics");
   mkdirSync7(dir, { recursive: true });
   let content;
   let filename;
@@ -10752,8 +10866,8 @@ function exportMetrics(db, projectRoot, format, params, maxRows = 1e5) {
       break;
     }
   }
-  const filePath = join19(dir, filename);
-  writeFileSync7(filePath, content, "utf-8");
+  const filePath = join20(dir, filename);
+  writeFileSync6(filePath, content, "utf-8");
   return filePath;
 }
 function getGroupColumn(groupBy) {
@@ -10820,7 +10934,7 @@ function esc(val) {
 
 // src/git/helpers.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { realpathSync } from "fs";
+import { realpathSync as realpathSync2 } from "fs";
 import { relative as relative6 } from "path";
 function resolveRef(projectRoot, since, db) {
   switch (since) {
@@ -10929,7 +11043,7 @@ function scopeToProject(changedFiles, projectRoot) {
   if (!repoRoot) return changedFiles;
   let projectRel;
   try {
-    projectRel = relative6(realpathSync(repoRoot), realpathSync(projectRoot));
+    projectRel = relative6(realpathSync2(repoRoot), realpathSync2(projectRoot));
   } catch {
     return changedFiles;
   }
@@ -11063,10 +11177,10 @@ ${output}`;
 
 // src/roles/loader.ts
 import { readdirSync as readdirSync6, readFileSync as readFileSync11 } from "fs";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 import matter4 from "gray-matter";
 function loadRoles(projectRoot) {
-  const agentsDir = join20(projectRoot, ".arcbridge", "agents");
+  const agentsDir = join21(projectRoot, ".arcbridge", "agents");
   const roles = [];
   const errors = [];
   let files;
@@ -11076,7 +11190,7 @@ function loadRoles(projectRoot) {
     return { roles: [], errors: [`Agent directory not found: ${agentsDir}`] };
   }
   for (const file of files) {
-    const filePath = join20(agentsDir, file);
+    const filePath = join21(agentsDir, file);
     try {
       const raw = readFileSync11(filePath, "utf-8");
       const parsed = matter4(raw);
@@ -11103,7 +11217,7 @@ function loadRole(projectRoot, roleId) {
   if (!/^[a-z0-9-]+$/.test(roleId)) {
     return { role: null, error: `Invalid role ID: "${roleId}" (must be kebab-case)` };
   }
-  const filePath = join20(projectRoot, ".arcbridge", "agents", `${roleId}.md`);
+  const filePath = join21(projectRoot, ".arcbridge", "agents", `${roleId}.md`);
   try {
     const raw = readFileSync11(filePath, "utf-8");
     const parsed = matter4(raw);
@@ -11139,11 +11253,13 @@ export {
   QualityScenarioSchema,
   QualityScenarioStatusSchema,
   QualityScenariosFileSchema,
+  RefreshValidationError,
   TaskFileSchema,
   TaskSchema,
   addPhaseToYaml,
   addTaskToYaml,
   applyInferences,
+  atomicWriteFileSync,
   deletePhaseFromYaml,
   deleteTaskFromYaml,
   detectDrift,
@@ -11168,6 +11284,7 @@ export {
   loadConfig,
   loadRole,
   loadRoles,
+  logWarn,
   migrate,
   openDatabase,
   openMemoryDatabase,