cc-codeconductor 1.6.0 → 1.6.1

package/dist/index.js

@@ -72,7 +72,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "cc-codeconductor",
-    version: "1.6.0",
+    version: "1.6.1",
     description: "A multi-agent orchestration framework for AI-assisted software engineering workflows.",
     keywords: [
       "ai",
@@ -126,6 +126,7 @@ var init_package = __esm(() => {
       "test:fast": "bun run scripts/test-fast.ts",
       typecheck: "tsc --noEmit",
       lint: "bun run scripts/lint.ts",
+      "check:council-redirect": "bun run scripts/check-council-redirect.ts",
       "check:coverage": "bun run scripts/check-coverage.ts",
       "check:prompt-changelog": "bun run scripts/check-prompt-changelog.ts",
       "check:drift": "bun run scripts/check-drift.ts",
@@ -13733,6 +13734,12 @@ function profileFor(agentId) {
 function checklistFor(agentId) {
   return profileFor(agentId).checklist;
 }
+function responsibilitiesFor(agentId) {
+  return profileFor(agentId).responsibilities;
+}
+function vetoNoteFor(agentId) {
+  return profileFor(agentId).vetoNote;
+}
 function generateAgentContent(agent) {
   const profile = profileFor(agent.id);
   const vetoSection = profile.vetoNote ? `
@@ -14256,13 +14263,16 @@ ${agentTables}
 }
 function generateCodexAgent(agent) {
   const focusAreas = agent.focus.join(", ");
+  const responsibilities = responsibilitiesFor(agent.id).join("; ");
   const checklist = checklistFor(agent.id).join("; ");
+  const veto = vetoNoteFor(agent.id);
+  const vetoSentence = veto ? ` ${veto}` : "";
   return `model = "gpt-6.1-sol"
 model_reasoning_effort = "medium"
 name = "${agent.role}"
 description = "${agent.role} council agent. Focus: ${focusAreas}. Context: ${agent.context}. Model hint: ${agent.modelHint}."
 nickname_candidates = ["${agent.role}", "Council ${agent.role}"]
-developer_instructions = "You are the ${agent.role} council agent. Your focus areas are: ${focusAreas}. Context: ${agent.context}. Apply ${agent.modelHint} reasoning to your analysis. Review checklist: ${checklist}. Categorize findings as CRITICAL (blocks the verdict), WARNING, or SUGGESTION."
+developer_instructions = "You are the ${agent.role} council agent. Your focus areas are: ${focusAreas}. Context: ${agent.context}. Apply ${agent.modelHint} reasoning to your analysis. Responsibilities: ${responsibilities}. Review checklist: ${checklist}.${vetoSentence} Categorize findings as CRITICAL (blocks the verdict), WARNING, or SUGGESTION."
 `;
 }
 function generateCodexSkill(spec) {
@@ -15408,10 +15418,90 @@ var init_config_writer = __esm(() => {
   init_codeconductor_config();
 });
 
+// src/core/ccep/council-fallback.generated.ts
+var COUNCIL_FALLBACK_PROFILE;
+var init_council_fallback_generated = __esm(() => {
+  COUNCIL_FALLBACK_PROFILE = {
+    id: "council",
+    version: 1,
+    command: "council",
+    phases: [
+      {
+        id: "wayfinding",
+        agent: "repo-explorer",
+        outputSchema: "agent-output"
+      },
+      {
+        id: "deliberation",
+        agents: [
+          "task-coach",
+          "architect",
+          "devil"
+        ],
+        skill: "council",
+        outputSchema: "planner-output",
+        stopGate: "confirmation"
+      },
+      {
+        id: "tdd",
+        agent: "tester",
+        requires: "red-state"
+      },
+      {
+        id: "implement",
+        agent: "implementer"
+      },
+      {
+        id: "council-review",
+        agents: [
+          "architect",
+          "product",
+          "delivery",
+          "data-ops",
+          "security-reviewer",
+          "devil"
+        ],
+        skill: "council",
+        outputSchema: "council-verdict"
+      }
+    ],
+    routing: {
+      default: [
+        "wayfinding",
+        "deliberation",
+        "tdd",
+        "implement",
+        "council-review"
+      ]
+    },
+    confirmationGate: {
+      stopOnHighRisk: true,
+      stopOnQuestions: true
+    }
+  };
+});
+
 // src/core/ccep/profiles.ts
-var baseGate, WORKFLOW_PROFILES;
+import { readFileSync as readFileSync2 } from "node:fs";
+import { dirname as dirname5, join as join7 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+function loadCouncilMirror() {
+  try {
+    const raw = readFileSync2(join7(dirname5(fileURLToPath2(import.meta.url)), "workflows", "council.yml"), "utf-8");
+    return validateWorkflowProfile($parse(raw));
+  } catch (error) {
+    if (error?.code !== "ENOENT")
+      throw error;
+    return COUNCIL_FALLBACK_PROFILE;
+  }
+}
+var baseGate, councilMirror, WORKFLOW_PROFILES;
 var init_profiles = __esm(() => {
+  init_dist();
+  init_schemas();
+  init_council_fallback_generated();
   baseGate = { stopOnHighRisk: true, stopOnQuestions: true };
+  councilMirror = loadCouncilMirror();
   WORKFLOW_PROFILES = {
     feature: {
       id: "feature",
@@ -15645,31 +15735,7 @@ var init_profiles = __esm(() => {
       routing: { default: ["analyze", "create", "evaluate"] },
       confirmationGate: { stopOnHighRisk: false, stopOnQuestions: false }
     },
-    council: {
-      id: "council",
-      version: 1,
-      command: "council",
-      phases: [
-        { id: "wayfinding", agent: "repo-explorer", outputSchema: "agent-output" },
-        {
-          id: "deliberation",
-          agents: ["task-coach", "architect", "devil"],
-          skill: "council",
-          outputSchema: "planner-output",
-          stopGate: "confirmation"
-        },
-        { id: "tdd", agent: "tester", requires: "red-state" },
-        { id: "implement", agent: "implementer" },
-        {
-          id: "council-review",
-          agents: ["architect", "product", "delivery", "data-ops", "security-reviewer", "devil"],
-          skill: "council",
-          outputSchema: "council-verdict"
-        }
-      ],
-      routing: { default: ["wayfinding", "deliberation", "tdd", "implement", "council-review"] },
-      confirmationGate: baseGate
-    },
+    council: councilMirror,
     iterative: {
       id: "iterative",
       version: 1,
@@ -15797,17 +15863,17 @@ var init_profiles = __esm(() => {
 });
 
 // src/core/ccep/profile-yaml.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
-import { dirname as dirname5, join as join7 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
+import { dirname as dirname6, join as join8 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 function workflowYamlPath(command, projectRoot) {
   if (projectRoot) {
-    const projectPath = join7(projectRoot, ".codeconductor", "workflows", `${command}.yml`);
+    const projectPath = join8(projectRoot, ".codeconductor", "workflows", `${command}.yml`);
     if (existsSync2(projectPath)) {
       return projectPath;
     }
   }
-  const bundledPath = join7(BUNDLED_WORKFLOWS_DIR, `${command}.yml`);
+  const bundledPath = join8(BUNDLED_WORKFLOWS_DIR, `${command}.yml`);
   if (existsSync2(bundledPath)) {
     return bundledPath;
   }
@@ -15822,7 +15888,7 @@ function loadWorkflowProfileFromYaml(command, projectRoot) {
   if (!path) {
     return null;
   }
-  const content = readFileSync2(path, "utf-8");
+  const content = readFileSync3(path, "utf-8");
   return parseWorkflowYaml(content);
 }
 function loadWorkflowProfileFallback(command) {
@@ -15837,12 +15903,12 @@ var init_profile_yaml = __esm(() => {
   init_dist();
   init_schemas();
   init_profiles();
-  BUNDLED_WORKFLOWS_DIR = join7(dirname5(fileURLToPath2(import.meta.url)), "workflows");
+  BUNDLED_WORKFLOWS_DIR = join8(dirname6(fileURLToPath3(import.meta.url)), "workflows");
 });
 
 // src/core/ccep/workflow-init.ts
 import { access as access3, copyFile, mkdir as mkdir4, readdir as readdir2 } from "node:fs/promises";
-import { join as join8, resolve as resolve9 } from "node:path";
+import { join as join9, resolve as resolve9 } from "node:path";
 async function fileExists4(path) {
   try {
     await access3(path);
@@ -15862,11 +15928,11 @@ async function initWorkflowArtifacts(baseDir, force) {
   for (const file of files) {
     if (!file.endsWith(".yml"))
       continue;
-    const destPath = join8(destDir, file);
+    const destPath = join9(destDir, file);
     if (!force && await fileExists4(destPath)) {
       continue;
     }
-    await copyFile(join8(BUNDLED_WORKFLOWS_DIR, file), destPath);
+    await copyFile(join9(BUNDLED_WORKFLOWS_DIR, file), destPath);
     created.push(`.codeconductor/workflows/${file}`);
   }
   return created;
@@ -15924,12 +15990,12 @@ async function detectDjango(rootDir) {
 }
 async function detectFastApi(rootDir) {
   const { fileExists: fileExists5 } = await Promise.resolve().then(() => (init_safety(), exports_safety));
-  const { join: join9 } = await import("node:path");
+  const { join: join10 } = await import("node:path");
   const { readFile: readFile9 } = await import("node:fs/promises");
   const signals = [];
   if (await fileExists5(rootDir, "requirements.txt")) {
     try {
-      const content = await readFile9(join9(rootDir, "requirements.txt"), "utf-8");
+      const content = await readFile9(join10(rootDir, "requirements.txt"), "utf-8");
       if (content.includes("fastapi")) {
         signals.push("fastapi-requirements");
       }
@@ -15937,7 +16003,7 @@ async function detectFastApi(rootDir) {
   }
   if (await fileExists5(rootDir, "pyproject.toml")) {
     try {
-      const content = await readFile9(join9(rootDir, "pyproject.toml"), "utf-8");
+      const content = await readFile9(join10(rootDir, "pyproject.toml"), "utf-8");
       if (content.includes("fastapi")) {
         signals.push("fastapi-pyproject");
       }
@@ -15946,7 +16012,7 @@ async function detectFastApi(rootDir) {
   for (const filename of ["main.py", "app.py", "app/main.py", "app/app.py"]) {
     if (await fileExists5(rootDir, filename)) {
       try {
-        const content = await readFile9(join9(rootDir, filename), "utf-8");
+        const content = await readFile9(join10(rootDir, filename), "utf-8");
         if (content.includes("FastAPI") && content.includes("fastapi")) {
           signals.push(`${filename}-fastapi`);
         }
@@ -16008,7 +16074,7 @@ async function detectAstro(rootDir) {
 }
 async function detectNext(rootDir) {
   const { fileExists: fileExists5 } = await Promise.resolve().then(() => (init_safety(), exports_safety));
-  const { join: join9 } = await import("node:path");
+  const { join: join10 } = await import("node:path");
   const { readFile: readFile9 } = await import("node:fs/promises");
   const signals = [];
   if (await fileExists5(rootDir, "next.config.js") || await fileExists5(rootDir, "next.config.mjs") || await fileExists5(rootDir, "next.config.ts")) {
@@ -16016,7 +16082,7 @@ async function detectNext(rootDir) {
   }
   if (await fileExists5(rootDir, "package.json")) {
     try {
-      const content = await readFile9(join9(rootDir, "package.json"), "utf-8");
+      const content = await readFile9(join10(rootDir, "package.json"), "utf-8");
       const pkg = JSON.parse(content);
       if (pkg.dependencies?.next || pkg.devDependencies?.next) {
         signals.push("package.json-next");
@@ -16027,7 +16093,7 @@ async function detectNext(rootDir) {
 }
 async function detectGenericFrontend(rootDir) {
   const { fileExists: fileExists5 } = await Promise.resolve().then(() => (init_safety(), exports_safety));
-  const { join: join9 } = await import("node:path");
+  const { join: join10 } = await import("node:path");
   const { readFile: readFile9 } = await import("node:fs/promises");
   const signals = [];
   if (await fileExists5(rootDir, "index.html")) {
@@ -16041,7 +16107,7 @@ async function detectGenericFrontend(rootDir) {
   }
   if (await fileExists5(rootDir, "package.json")) {
     try {
-      const content = await readFile9(join9(rootDir, "package.json"), "utf-8");
+      const content = await readFile9(join10(rootDir, "package.json"), "utf-8");
       const pkg = JSON.parse(content);
       const frontendDeps = ["react", "vue", "svelte", "solid-js", "angular", "@angular/core"];
       const hasFrontendDep = frontendDeps.some((dep) => pkg.dependencies?.[dep] || pkg.devDependencies?.[dep]);
@@ -16056,7 +16122,7 @@ async function detectGenericFrontend(rootDir) {
 // src/core/detection/detectors/monorepo.ts
 async function detectMonorepo(rootDir) {
   const { fileExists: fileExists5 } = await Promise.resolve().then(() => (init_safety(), exports_safety));
-  const { join: join9 } = await import("node:path");
+  const { join: join10 } = await import("node:path");
   const { readFile: readFile9 } = await import("node:fs/promises");
   const signals = [];
   if (await fileExists5(rootDir, "pnpm-workspace.yaml")) {
@@ -16070,7 +16136,7 @@ async function detectMonorepo(rootDir) {
   }
   if (await fileExists5(rootDir, "package.json")) {
     try {
-      const content = await readFile9(join9(rootDir, "package.json"), "utf-8");
+      const content = await readFile9(join10(rootDir, "package.json"), "utf-8");
       const pkg = JSON.parse(content);
       if (pkg.workspaces) {
         signals.push("package.json-workspaces");
@@ -16079,7 +16145,7 @@ async function detectMonorepo(rootDir) {
   }
   if (await fileExists5(rootDir, "Cargo.toml")) {
     try {
-      const content = await readFile9(join9(rootDir, "Cargo.toml"), "utf-8");
+      const content = await readFile9(join10(rootDir, "Cargo.toml"), "utf-8");
       if (content.includes("[workspace]")) {
         signals.push("Cargo.toml-workspace");
       }
@@ -17125,7 +17191,7 @@ __export(exports_install_command, {
 });
 import { readFile as readFile12 } from "node:fs/promises";
 import { homedir as homedir7 } from "node:os";
-import { basename as basename5, dirname as dirname6, resolve as resolve12, sep as sep3 } from "node:path";
+import { basename as basename5, dirname as dirname7, resolve as resolve12, sep as sep3 } from "node:path";
 async function installCommand(options) {
   const { target, dryRun, force, global: isGlobal, output, projectRoot } = options;
   const baseDir = isGlobal ? homedir7() : projectRoot;
@@ -17271,7 +17337,7 @@ async function verifyRenderedFiles(manifest, baseDir, results) {
       if (!parsed.ok) {
         warnings.push(`${r.dest}: ${parsed.error.kind} — ${parsed.error.message}`);
       } else {
-        const dir = basename5(dirname6(r.dest));
+        const dir = basename5(dirname7(r.dest));
         const ident = skillIdentifier(parsed.frontmatter);
         if (ident !== dir) {
           warnings.push(`${r.dest}: identifier "${ident}" does not match its directory "${dir}"`);
@@ -18515,7 +18581,7 @@ var init_binary_downloader = __esm(() => {
 import { execFile as execFile2 } from "node:child_process";
 import { access as access6, mkdir as mkdir6, mkdtemp, rename as rename2, rm, writeFile as writeFile5 } from "node:fs/promises";
 import { homedir as homedir8, tmpdir } from "node:os";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 import { promisify as promisify2 } from "node:util";
 async function assertTarArchiveSafe(archivePath, destRoot) {
   const { stdout } = await execFileAsync2("tar", ["-tzf", archivePath], {
@@ -18536,7 +18602,7 @@ async function extractHardenedTar(archivePath, destRoot) {
 class LspInstaller {
   lspBinDir;
   constructor() {
-    this.lspBinDir = join9(homedir8(), ".codeconductor", "lsp", "bin");
+    this.lspBinDir = join10(homedir8(), ".codeconductor", "lsp", "bin");
   }
   async checkInstalled(def) {
     try {
@@ -18664,7 +18730,7 @@ class LspInstaller {
     }
     assertBinaryArtifact(binary);
     await mkdir6(this.lspBinDir, { recursive: true });
-    const destPath = join9(this.lspBinDir, def.binaryName);
+    const destPath = join10(this.lspBinDir, def.binaryName);
     try {
       await access6(destPath);
       return;
@@ -18676,16 +18742,16 @@ class LspInstaller {
       throw new Error(`Failed to download ${def.serverName}: ${error instanceof Error ? error.message : String(error)}`);
     }
     assertSha256Hex(bytes, binary.sha256);
-    const workDir = await mkdtemp(join9(tmpdir(), "cc-lsp-"));
+    const workDir = await mkdtemp(join10(tmpdir(), "cc-lsp-"));
     try {
       const archiveName = binary.url.endsWith(".zip") ? "server.zip" : "server.tar.gz";
-      const archivePath = join9(workDir, archiveName);
+      const archivePath = join10(workDir, archiveName);
       await writeFile5(archivePath, bytes);
       if (archiveName.endsWith(".zip")) {
         throw new Error(`Zip binary installs are not supported yet for ${def.serverName}; use a .tar.gz artifact`);
       }
       await extractHardenedTar(archivePath, workDir);
-      const candidate = join9(workDir, def.binaryName);
+      const candidate = join10(workDir, def.binaryName);
       try {
         await access6(candidate);
         await rename2(candidate, destPath);
@@ -18964,7 +19030,7 @@ var init_install_lsp_command = __esm(() => {
 
 // src/core/install/update-transaction.ts
 import { mkdir as mkdir7, readFile as readFile13, rm as rm2, unlink, writeFile as writeFile6 } from "node:fs/promises";
-import { dirname as dirname7, isAbsolute as isAbsolute4, join as join10, relative as relative5, resolve as resolve16, sep as sep5 } from "node:path";
+import { dirname as dirname8, isAbsolute as isAbsolute4, join as join11, relative as relative5, resolve as resolve16, sep as sep5 } from "node:path";
 function assertInsideBase(basePath, destination) {
   const base = resolve16(basePath);
   const absolute = resolve16(base, destination);
@@ -18996,8 +19062,8 @@ class UpdateTransaction {
       try {
         const content = await readFile13(destination);
         snapshots.push({ path: destination, existed: true, content });
-        const backupPath = join10(backupDir, relative5(resolve16(basePath), resolve16(destination)));
-        await mkdir7(dirname7(backupPath), { recursive: true });
+        const backupPath = join11(backupDir, relative5(resolve16(basePath), resolve16(destination)));
+        await mkdir7(dirname8(backupPath), { recursive: true });
         await writeFile6(backupPath, content);
       } catch (error) {
         if (error.code === "ENOENT") {
@@ -19017,7 +19083,7 @@ class UpdateTransaction {
         throw new Error(`Rollback destination is no longer contained: ${snapshot.path}`);
       }
       if (snapshot.existed) {
-        await mkdir7(dirname7(gated), { recursive: true });
+        await mkdir7(dirname8(gated), { recursive: true });
         await writeFile6(gated, snapshot.content);
       } else {
         await unlink(gated).catch((error) => {
@@ -19042,7 +19108,7 @@ __export(exports_update_command, {
   updateCommand: () => updateCommand
 });
 import { homedir as homedir10 } from "node:os";
-import { join as join11, resolve as resolve17 } from "node:path";
+import { join as join12, resolve as resolve17 } from "node:path";
 import { readFile as readFile14, stat as stat3 } from "node:fs/promises";
 async function updateCommand(options) {
   const { dryRun, force, global: isGlobal, output, projectRoot, check = false } = options;
@@ -19152,7 +19218,7 @@ async function updateCommand(options) {
       const bundledCouncil = resolve17(SRC_PRESETS_DIR, "council", "council.yml");
       try {
         const content = await readFile14(bundledCouncil, "utf-8");
-        const written = await writeContainedFile(basePath, join11(".codeconductor", "presets", "council.yml"), content, { force: true });
+        const written = await writeContainedFile(basePath, join12(".codeconductor", "presets", "council.yml"), content, { force: true });
         updated.push(written);
       } catch (e) {
         throw new Error(`Failed to update council.yml: ${e}`);
@@ -19161,7 +19227,7 @@ async function updateCommand(options) {
     if (updateResults.policy) {
       try {
         const content = await readFile14(POLICY_PATH, "utf-8");
-        const written = await writeContainedFile(basePath, join11(".codeconductor", "presets", "policy.yml"), content, { force: true });
+        const written = await writeContainedFile(basePath, join12(".codeconductor", "presets", "policy.yml"), content, { force: true });
         updated.push(written);
       } catch (e) {
         throw new Error(`Failed to update policy.yml: ${e}`);
@@ -19240,13 +19306,13 @@ async function updateCommand(options) {
       for (const s of updateResults.skills) {
         newSkillsLock[s.id] = s.latestVersion;
       }
-      let lockRel = join11(".codeconductor", "skills-lock.json");
+      let lockRel = join12(".codeconductor", "skills-lock.json");
       try {
         const statAgents = await stat3(resolve17(basePath, ".agents"));
         if (statAgents.isDirectory()) {
           const statCodeConductor = await stat3(resolve17(basePath, ".codeconductor")).catch(() => null);
           if (!statCodeConductor) {
-            lockRel = join11(".agents", "skills-lock.json");
+            lockRel = join12(".agents", "skills-lock.json");
           }
         }
       } catch {}
@@ -19319,7 +19385,7 @@ __export(exports_migrate_command, {
 });
 import { readFile as readFile15, readdir as readdir3, rm as rm3, writeFile as writeFile7 } from "node:fs/promises";
 import { homedir as homedir11 } from "node:os";
-import { join as join12, resolve as resolve18 } from "node:path";
+import { join as join13, resolve as resolve18 } from "node:path";
 function migratePermissionRules(settings) {
   const permissions = settings.permissions;
   if (typeof permissions !== "object" || permissions === null) {
@@ -19366,7 +19432,7 @@ function resolveSettingsPath(options) {
   if (options.file)
     return resolve18(options.projectRoot, options.file);
   const base = options.global ? homedir11() : options.projectRoot;
-  return join12(base, ".claude", "settings.json");
+  return join13(base, ".claude", "settings.json");
 }
 async function findOrphanedPromptVersions(basePath, isGlobal) {
   const found = [];
@@ -19376,7 +19442,7 @@ async function findOrphanedPromptVersions(basePath, isGlobal) {
     if (!installed)
       continue;
     const installPath = getTargetInstallationPath(target, basePath, isGlobal);
-    const promptsDir = join12(installPath, "prompts");
+    const promptsDir = join13(installPath, "prompts");
     if (seenDirs.has(promptsDir))
       continue;
     seenDirs.add(promptsDir);
@@ -19391,7 +19457,7 @@ async function findOrphanedPromptVersions(basePath, isGlobal) {
         continue;
       if (entry.name === CURRENT_PRESET_VERSION)
         continue;
-      found.push({ target, path: join12(promptsDir, entry.name), version: entry.name });
+      found.push({ target, path: join13(promptsDir, entry.name), version: entry.name });
     }
   }
   return found;
@@ -19673,7 +19739,7 @@ __export(exports_help_command, {
   helpCommand: () => helpCommand
 });
 import { readdir as readdir4 } from "node:fs/promises";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 async function scanPresetDir(projectRoot, target) {
   const inventory = {
     target,
@@ -19682,12 +19748,12 @@ async function scanPresetDir(projectRoot, target) {
     agents: [],
     workflows: []
   };
-  const presetDir = join13(projectRoot, "presets", target);
+  const presetDir = join14(projectRoot, "presets", target);
   try {
     const entries = await readdir4(presetDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const subDir = join13(presetDir, entry.name);
+        const subDir = join14(presetDir, entry.name);
         const subEntries = await readdir4(subDir, { withFileTypes: true });
         for (const sub of subEntries) {
           if (sub.isFile()) {
@@ -19814,13 +19880,13 @@ __export(exports_debt_harvest_command, {
   debtHarvestCommand: () => debtHarvestCommand
 });
 import { readdir as readdir5, readFile as readFile16, writeFile as writeFile8, mkdir as mkdir8 } from "node:fs/promises";
-import { join as join14, relative as relative6, extname } from "node:path";
+import { join as join15, relative as relative6, extname } from "node:path";
 async function walkDir(dir, extensions) {
   const results = [];
   try {
     const entries = await readdir5(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join14(dir, entry.name);
+      const fullPath = join15(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name.startsWith(".") || entry.name === "node_modules")
           continue;
@@ -19887,7 +19953,7 @@ function renderLedger(entries) {
 async function debtHarvestCommand(options) {
   const { projectRoot, dir = "src", output } = options;
   try {
-    const targetDir = join14(projectRoot, dir);
+    const targetDir = join15(projectRoot, dir);
     const files = await walkDir(targetDir, SOURCE_EXTENSIONS);
     const allEntries = [];
     for (const file of files) {
@@ -19895,9 +19961,9 @@ async function debtHarvestCommand(options) {
       const entries = extractDefers(content, relative6(projectRoot, file));
       allEntries.push(...entries);
     }
-    const ledgerDir = join14(projectRoot, ".codeconductor");
+    const ledgerDir = join15(projectRoot, ".codeconductor");
     await mkdir8(ledgerDir, { recursive: true });
-    const ledgerPath = join14(ledgerDir, "debt-ledger.md");
+    const ledgerPath = join15(ledgerDir, "debt-ledger.md");
     const ledgerContent = renderLedger(allEntries);
     await writeFile8(ledgerPath, ledgerContent, "utf-8");
     if (output === "json") {
@@ -20332,27 +20398,27 @@ var init_goal_planner = __esm(() => {
 });
 
 // src/core/product-graph/paths.ts
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 function productGraphPath(projectRoot) {
-  return join15(projectRoot, PRODUCT_DIR, PRODUCT_GRAPH_FILE);
+  return join16(projectRoot, PRODUCT_DIR, PRODUCT_GRAPH_FILE);
 }
 function productMetaPath(projectRoot) {
-  return join15(projectRoot, PRODUCT_DIR, PRODUCT_META_FILE);
+  return join16(projectRoot, PRODUCT_DIR, PRODUCT_META_FILE);
 }
 function eventsPath(projectRoot) {
-  return join15(projectRoot, PRODUCT_DIR, EVENTS_FILE);
+  return join16(projectRoot, PRODUCT_DIR, EVENTS_FILE);
 }
 function operationalStatePath(projectRoot) {
-  return join15(projectRoot, PRODUCT_DIR, OPERATIONAL_STATE_FILE);
+  return join16(projectRoot, PRODUCT_DIR, OPERATIONAL_STATE_FILE);
 }
 function strategicPath(projectRoot) {
-  return join15(projectRoot, PRODUCT_DIR, STRATEGIC_FILE);
+  return join16(projectRoot, PRODUCT_DIR, STRATEGIC_FILE);
 }
 function productReportPath(projectRoot) {
-  return join15(projectRoot, PRODUCT_DIR, PRODUCT_REPORT_FILE);
+  return join16(projectRoot, PRODUCT_DIR, PRODUCT_REPORT_FILE);
 }
 function evidenceDir(projectRoot) {
-  return join15(projectRoot, PRODUCT_DIR, EVIDENCE_DIR);
+  return join16(projectRoot, PRODUCT_DIR, EVIDENCE_DIR);
 }
 var PRODUCT_DIR = ".codeconductor", PRODUCT_GRAPH_FILE = "product-graph.json", PRODUCT_META_FILE = "product-meta.json", EVENTS_FILE = "events.jsonl", OPERATIONAL_STATE_FILE = "operational-state.json", STRATEGIC_FILE = "strategic.json", PRODUCT_REPORT_FILE = "product-report.md", EVIDENCE_DIR = "evidence";
 var init_paths = () => {};
@@ -20370,7 +20436,7 @@ __export(exports_graph_store, {
   upsertNode: () => upsertNode
 });
 import { mkdir as mkdir9, readFile as readFile17, writeFile as writeFile9 } from "node:fs/promises";
-import { dirname as dirname8 } from "node:path";
+import { dirname as dirname9 } from "node:path";
 async function loadGraph(projectRoot) {
   try {
     const raw = await readFile17(productGraphPath(projectRoot), "utf-8");
@@ -20386,7 +20452,7 @@ async function saveGraph(projectRoot, graph) {
   try {
     const validated = ProductGraphSchema.parse(graph);
     const path = productGraphPath(projectRoot);
-    await mkdir9(dirname8(path), { recursive: true });
+    await mkdir9(dirname9(path), { recursive: true });
     await writeFile9(path, JSON.stringify(validated, null, 2), "utf-8");
     return ok(undefined);
   } catch (e) {
@@ -20996,7 +21062,7 @@ function slugify(text) {
 
 // src/core/knowledge/source-parsers.ts
 import { readFile as readFile20 } from "node:fs/promises";
-import { basename as basename6, join as join16, relative as relative7, sep as sep6 } from "node:path";
+import { basename as basename6, join as join17, relative as relative7, sep as sep6 } from "node:path";
 async function parseAdrFile(filePath) {
   try {
     const content = await readFile20(filePath, "utf-8");
@@ -21048,7 +21114,7 @@ function adrToEntities(adr, source) {
 }
 async function parseReadmeEntities(projectRoot, productName) {
   try {
-    const content = await readFile20(join16(projectRoot, "README.md"), "utf-8");
+    const content = await readFile20(join17(projectRoot, "README.md"), "utf-8");
     const firstPara = content.split(`
 
 `).find((p) => p.trim() && !p.startsWith("#") && !p.startsWith(">")) ?? "";
@@ -21069,7 +21135,7 @@ async function parseReadmeEntities(projectRoot, productName) {
 }
 async function parseGraphifyEntities(projectRoot) {
   try {
-    const raw = await readFile20(join16(projectRoot, "graphify-out", "graph.json"), "utf-8");
+    const raw = await readFile20(join17(projectRoot, "graphify-out", "graph.json"), "utf-8");
     const graph = JSON.parse(raw);
     const entities = [];
     for (const node2 of graph.nodes ?? []) {
@@ -21093,14 +21159,14 @@ async function parseGraphifyEntities(projectRoot) {
 async function scanSrcComponents(projectRoot) {
   const { readdir: readdir6 } = await import("node:fs/promises");
   const entities = [];
-  const srcDir = join16(projectRoot, "src");
+  const srcDir = join17(projectRoot, "src");
   async function walk(dir, prefix) {
     try {
       const entries = await readdir6(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.name.startsWith("."))
           continue;
-        const full = join16(dir, entry.name);
+        const full = join17(dir, entry.name);
         if (entry.isDirectory()) {
           if (entry.name === "node_modules")
             continue;
@@ -21173,7 +21239,7 @@ var init_episodic_store = __esm(() => {
 // src/core/knowledge/ingest-pipeline.ts
 import { createHash as createHash3 } from "node:crypto";
 import { readFile as readFile22 } from "node:fs/promises";
-import { join as join17, relative as relative8, sep as sep7 } from "node:path";
+import { join as join18, relative as relative8, sep as sep7 } from "node:path";
 import { mkdir as mkdir12, writeFile as writeFile11 } from "node:fs/promises";
 async function mapLimit(items, limit, fn) {
   if (items.length === 0)
@@ -21209,7 +21275,7 @@ async function collectDeferRisks(projectRoot) {
       for (const entry of entries) {
         if (entry.name.startsWith(".") || entry.name === "node_modules")
           continue;
-        const full = join17(dir, entry.name);
+        const full = join18(dir, entry.name);
         if (entry.isDirectory()) {
           await walk(full);
         } else if (entry.name.endsWith(".ts")) {
@@ -21218,7 +21284,7 @@ async function collectDeferRisks(projectRoot) {
       }
     } catch {}
   }
-  await walk(join17(projectRoot, "src"));
+  await walk(join18(projectRoot, "src"));
   const perFile = await mapLimit(files, WALK_READ_CONCURRENCY, async (full) => {
     const entities = [];
     const content = await readFile22(full, "utf-8");
@@ -21281,12 +21347,12 @@ async function parseBacklogEntities(projectRoot) {
 }
 async function parseAdrEntities(projectRoot) {
   const { readdir: readdir6 } = await import("node:fs/promises");
-  const adrDir = join17(projectRoot, "docs", "adr");
+  const adrDir = join18(projectRoot, "docs", "adr");
   const entities = [];
   try {
     const files = (await readdir6(adrDir)).filter((file) => file.endsWith(".md"));
     const parsed = await Promise.all(files.map(async (file) => {
-      const adr = await parseAdrFile(join17(adrDir, file));
+      const adr = await parseAdrFile(join18(adrDir, file));
       return adr ? adrToEntities(adr, `docs/adr/${file}`) : [];
     }));
     entities.push(...parsed.flat());
@@ -21378,7 +21444,7 @@ async function runIngest(projectRoot, productName) {
   await saveGraph2(projectRoot, graph);
   const sourceHashes = {};
   for (const src of ["README.md", "BACKLOG.md", "ROADMAP.md"]) {
-    const h = await hashFile(join17(projectRoot, src));
+    const h = await hashFile(join18(projectRoot, src));
     if (h)
       sourceHashes[src] = h;
   }
@@ -21388,7 +21454,7 @@ async function runIngest(projectRoot, productName) {
     lastIngestAt: new Date().toISOString(),
     sourceHashes
   };
-  await mkdir12(join17(projectRoot, ".codeconductor"), { recursive: true });
+  await mkdir12(join18(projectRoot, ".codeconductor"), { recursive: true });
   await writeFile11(productMetaPath(projectRoot), JSON.stringify(ProductMetaSchema.parse(meta), null, 2), "utf-8");
   await appendEvent(projectRoot, {
     type: "ingest.completed",
@@ -21813,10 +21879,10 @@ var init_outcome_store = __esm(() => {
 
 // src/core/feedback/feedback-ingestor.ts
 import { readFile as readFile27 } from "node:fs/promises";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 async function parseChangelogLearnings(projectRoot) {
   try {
-    const content = await readFile27(join18(projectRoot, "CHANGELOG.md"), "utf-8");
+    const content = await readFile27(join19(projectRoot, "CHANGELOG.md"), "utf-8");
     const unreleased = content.match(/## \[Unreleased\]([\s\S]*?)(?=## \[|\n## )/i);
     if (!unreleased)
       return [];
@@ -22417,11 +22483,12 @@ __export(exports_rdd_receipt, {
   captureReceipt: () => captureReceipt,
   collectReceiptPaths: () => collectReceiptPaths,
   isRddReceipt: () => isRddReceipt,
-  verifyReceipt: () => verifyReceipt
+  verifyReceipt: () => verifyReceipt,
+  verifyReceiptLock: () => verifyReceiptLock
 });
-import { createHash as createHash4 } from "node:crypto";
-import { readdir as readdir7, readFile as readFile28 } from "node:fs/promises";
-import { join as join19, relative as relative9, resolve as resolve26, sep as sep8 } from "node:path";
+import { createHash as createHash4, randomBytes } from "node:crypto";
+import { mkdir as mkdir17, readdir as readdir7, readFile as readFile28, writeFile as writeFile17 } from "node:fs/promises";
+import { join as join20, relative as relative9, resolve as resolve26, sep as sep8 } from "node:path";
 function sha2562(content) {
   return createHash4("sha256").update(content).digest("hex");
 }
@@ -22453,6 +22520,23 @@ function manifestHash(paths) {
   return sha2562(paths.map((entry) => `${entry.path}\x00${entry.hash}`).join(`
 `));
 }
+function receiptRegistryDir(projectRoot) {
+  return join20(resolve26(projectRoot), ".codeconductor", "rdd-receipts");
+}
+function isWellFormedNonce(nonce) {
+  return typeof nonce === "string" && /^[0-9a-f]{32}$/.test(nonce);
+}
+async function isRegisteredReceipt(projectRoot, receipt) {
+  if (!isWellFormedNonce(receipt.nonce))
+    return false;
+  try {
+    const raw = await readFile28(join20(receiptRegistryDir(projectRoot), `${receipt.nonce}.json`), "utf-8");
+    const entry = JSON.parse(raw);
+    return entry.manifestHash === receipt.manifestHash;
+  } catch {
+    return false;
+  }
+}
 function isRddReceipt(value) {
   if (!value || typeof value !== "object")
     return false;
@@ -22466,17 +22550,26 @@ async function captureReceipt(projectRoot, input) {
     throw new Error("RDD receipts require at least one protected path");
   }
   const paths = await fingerprint(projectRoot, input.paths);
-  return {
+  const hashed = manifestHash(paths);
+  const nonce = randomBytes(16).toString("hex");
+  const capturedAt = new Date().toISOString();
+  const receipt = {
     version: 1,
     taskId: input.taskId,
     phase: input.phase,
     paths,
     coverage: input.coverage ?? "paths",
-    manifestHash: manifestHash(paths),
+    manifestHash: hashed,
     command: input.command,
     outcome: input.outcome,
-    capturedAt: new Date().toISOString()
+    capturedAt,
+    nonce
   };
+  const directory = receiptRegistryDir(projectRoot);
+  await mkdir17(directory, { recursive: true });
+  const entry = { manifestHash: hashed, taskId: input.taskId, capturedAt };
+  await writeFile17(join20(directory, `${nonce}.json`), JSON.stringify(entry, null, 2), "utf-8");
+  return receipt;
 }
 async function collectReceiptPaths(projectRoot) {
   const root = resolve26(projectRoot);
@@ -22486,17 +22579,18 @@ async function collectReceiptPaths(projectRoot) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (!EXCLUDED_DIRECTORIES.has(entry.name))
-          await visit2(join19(current, entry.name));
+          await visit2(join20(current, entry.name));
         continue;
       }
       if (entry.isFile())
-        paths.push(relative9(root, join19(current, entry.name)).split(sep8).join("/"));
+        paths.push(relative9(root, join20(current, entry.name)).split(sep8).join("/"));
     }
   }
   await visit2(root);
   return paths.sort();
 }
 async function verifyReceipt(projectRoot, receipt) {
+  const registered = await isRegisteredReceipt(projectRoot, receipt);
   const expected = new Map(receipt.paths.map((entry) => [entry.path, entry.hash]));
   const changedPaths = [];
   const current = [];
@@ -22522,12 +22616,24 @@ async function verifyReceipt(projectRoot, receipt) {
   changedPaths.sort();
   const actualHash = manifestHash(current.sort((left, right) => left.path.localeCompare(right.path)));
   return {
-    valid: changedPaths.length === 0 && actualHash === receipt.manifestHash,
+    valid: registered && changedPaths.length === 0 && actualHash === receipt.manifestHash,
     expectedHash: receipt.manifestHash,
     actualHash,
     changedPaths
   };
 }
+async function verifyReceiptLock(projectRoot, lockPath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile28(resolve26(projectRoot, lockPath), "utf-8"));
+  } catch {
+    return { valid: false, changedPaths: [] };
+  }
+  if (!isRddReceipt(parsed))
+    return { valid: false, changedPaths: [] };
+  const verification = await verifyReceipt(projectRoot, parsed);
+  return { valid: verification.valid, changedPaths: verification.changedPaths };
+}
 var EXCLUDED_DIRECTORIES;
 var init_rdd_receipt = __esm(() => {
   EXCLUDED_DIRECTORIES = new Set([
@@ -22543,8 +22649,8 @@ var init_rdd_receipt = __esm(() => {
 // src/core/verification/verification-runner.ts
 import { existsSync as existsSync3 } from "node:fs";
 import { readFile as readFile29 } from "node:fs/promises";
-import { dirname as dirname9, join as join20, resolve as resolve27 } from "node:path";
-import { mkdir as mkdir17, readdir as readdir8, writeFile as writeFile17 } from "node:fs/promises";
+import { dirname as dirname10, join as join21, resolve as resolve27 } from "node:path";
+import { mkdir as mkdir18, readdir as readdir8, writeFile as writeFile18 } from "node:fs/promises";
 function isPassingEvidence(ev) {
   switch (ev.type) {
     case "verification":
@@ -22571,7 +22677,7 @@ async function isCurrentPassingEvidence(projectRoot, ev) {
 }
 function evidenceFilePath(evDir, id) {
   const path = resolve27(evDir, `${id.replace(/[^A-Za-z0-9_-]/g, "_")}.json`);
-  if (dirname9(path) !== resolve27(evDir)) {
+  if (dirname10(path) !== resolve27(evDir)) {
     return err(new Error(`Refusing to write evidence for "${id}" outside ${evDir}`));
   }
   return ok(path);
@@ -22582,8 +22688,8 @@ async function persistEvidence(projectRoot, evidence) {
   if (!evidencePath.success)
     return evidencePath;
   try {
-    await mkdir17(evDir, { recursive: true });
-    await writeFile17(evidencePath.data, JSON.stringify(evidence, null, 2), "utf-8");
+    await mkdir18(evDir, { recursive: true });
+    await writeFile18(evidencePath.data, JSON.stringify(evidence, null, 2), "utf-8");
   } catch (e) {
     return err(e instanceof Error ? e : new Error(String(e)));
   }
@@ -22605,7 +22711,7 @@ async function collectTaskEvidence(projectRoot, taskId) {
     if (!file.endsWith(".json"))
       continue;
     try {
-      const raw = await readFile29(join20(evDir, file), "utf-8");
+      const raw = await readFile29(join21(evDir, file), "utf-8");
       const ev = EvidenceSchema.parse(JSON.parse(raw));
       if (ev.relatedTask === taskId)
         records.push(ev);
@@ -23984,13 +24090,13 @@ __export(exports_rdd_command, {
 });
 import { execFile as execFile4 } from "node:child_process";
 import { existsSync as existsSync4 } from "node:fs";
-import { mkdir as mkdir18, readFile as readFile30, readdir as readdir9, rename as rename3, writeFile as writeFile18, chmod } from "node:fs/promises";
-import { dirname as dirname10, resolve as resolve28 } from "node:path";
+import { mkdir as mkdir19, readFile as readFile30, readdir as readdir9, rename as rename3, writeFile as writeFile19, chmod } from "node:fs/promises";
+import { dirname as dirname11, resolve as resolve28 } from "node:path";
 import { promisify as promisify4 } from "node:util";
 function receiptPath(projectRoot, id) {
   const directory = resolve28(evidenceDir(projectRoot));
   const path = resolve28(directory, `${id.replace(/[^A-Za-z0-9_-]/g, "_")}.json`);
-  if (dirname10(path) !== directory)
+  if (dirname11(path) !== directory)
     throw new Error(`Invalid RDD receipt id: ${id}`);
   return path;
 }
@@ -24038,7 +24144,7 @@ async function installHooks(projectRoot) {
     encoding: "utf8"
   });
   const hooksDir = resolve28(projectRoot, stdout.trim());
-  await mkdir18(hooksDir, { recursive: true });
+  await mkdir19(hooksDir, { recursive: true });
   const installed = [];
   const skipped = [];
   for (const hook of ["pre-commit", "pre-push"]) {
@@ -24065,7 +24171,7 @@ if [ -x "$HOOK_DIR/${hook}.rdd-original" ]; then
 fi
 cc-codeconductor rdd git-check
 `;
-    await writeFile18(path, script, "utf8");
+    await writeFile19(path, script, "utf8");
     await chmod(path, 493);
     installed.push(hook);
   }
@@ -24097,8 +24203,8 @@ async function rddCommand(options) {
         data: { rddReceipt: receipt }
       };
       const directory = evidenceDir(options.projectRoot);
-      await mkdir18(directory, { recursive: true });
-      await writeFile18(receiptPath(options.projectRoot, id), JSON.stringify(evidence, null, 2), "utf-8");
+      await mkdir19(directory, { recursive: true });
+      await writeFile19(receiptPath(options.projectRoot, id), JSON.stringify(evidence, null, 2), "utf-8");
       return { code: 0, data: { success: true, receiptId: id, receipt } };
     }
     if (options.subcommand === "verify") {
@@ -24324,15 +24430,7 @@ var init_output_validator = __esm(() => {
 
 // src/core/ccep/prompt-compiler.ts
 function buildSystemLayer() {
-  return [
-    "You are a CodeConductor agent operating under CCEP-1.",
-    "Rules:",
-    "- Do not invent context.",
-    "- If critical data is missing, return questions in structured output.",
-    "- Produce valid JSON only — no free-form prose as the final answer.",
-    "- Match the output schema exactly."
-  ].join(`
-`);
+  return "You are a CodeConductor agent (CCEP-1): never invent context; missing critical data goes to structured output as questions; the final answer is valid JSON only, matching the output schema exactly.";
 }
 function buildAgentLayer(role, phase, outputSchema) {
   const label = ROLE_LABELS[role] ?? role;
@@ -24342,11 +24440,11 @@ function buildAgentLayer(role, phase, outputSchema) {
 Convert product intent into a structured plan without writing code.`;
   } else if (role === "implementer") {
     instruction = `You are the ${label}.
-Execute only your assigned phase: ${phase}.
+Work only on phase ${phase}.
 Write the minimal diff.`;
   } else {
     instruction = `You are the ${label}.
-Execute only your assigned phase: ${phase}.`;
+Work only on phase ${phase}.`;
   }
   return `${instruction}
 Return ${outputSchema} JSON only.`;
@@ -24511,13 +24609,13 @@ var init_prompt_compiler = __esm(() => {
 });
 
 // src/core/ccep/command-parser.ts
-import { existsSync as existsSync5, readFileSync as readFileSync3 } from "node:fs";
-import { basename as basename7, join as join21 } from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "node:fs";
+import { basename as basename7, join as join22 } from "node:path";
 function readProjectId(projectRoot) {
-  const packageJsonPath = join21(projectRoot, "package.json");
+  const packageJsonPath = join22(projectRoot, "package.json");
   if (existsSync5(packageJsonPath)) {
     try {
-      const pkg = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync4(packageJsonPath, "utf-8"));
       if (pkg.name) {
         return pkg.name;
       }
@@ -24544,10 +24642,10 @@ function parseCommand(command, userRequest, projectRoot) {
       maxVariance: "low"
     }
   };
-  const packageJsonPath = join21(projectRoot, "package.json");
+  const packageJsonPath = join22(projectRoot, "package.json");
   if (existsSync5(packageJsonPath)) {
     try {
-      const pkg = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync4(packageJsonPath, "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
       const stack = ["typescript"];
       if (deps?.next)
@@ -24618,9 +24716,9 @@ var init_workflow_profile_loader = __esm(() => {
 
 // src/core/evaluation/harness-catalog.ts
 import { createHash as createHash5 } from "node:crypto";
-import { existsSync as existsSync6, readFileSync as readFileSync4 } from "node:fs";
-import { copyFile as copyFile2, mkdir as mkdir19, readFile as readFile31, readdir as readdir10, rm as rm4, writeFile as writeFile19 } from "node:fs/promises";
-import { dirname as dirname11, join as join22, resolve as resolve29 } from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync5 } from "node:fs";
+import { copyFile as copyFile2, mkdir as mkdir20, readFile as readFile31, readdir as readdir10, rm as rm4, writeFile as writeFile20 } from "node:fs/promises";
+import { dirname as dirname12, join as join23, resolve as resolve29 } from "node:path";
 function catalogIds(catalog = DEFAULT_HARNESS_CATALOG) {
   return catalog.components.map((c) => c.id);
 }
@@ -24697,7 +24795,7 @@ function isProductGraphDisabled(projectRoot) {
     const path = activeOverlayPath(projectRoot);
     if (!existsSync6(path))
       return false;
-    const overlay = HarnessOverlaySchema.parse($parse(readFileSync4(path, "utf-8")));
+    const overlay = HarnessOverlaySchema.parse($parse(readFileSync5(path, "utf-8")));
     return overlay.disableProductGraph === true || overlay.disabledComponents.includes("product_graph");
   } catch {
     return false;
@@ -24743,22 +24841,22 @@ async function restoreOverlayBackup(projectRoot) {
   const backupRoot = resolve29(projectRoot, EVAL_DIR2, OVERLAY_BACKUP_DIR);
   if (!existsSync6(backupRoot))
     return;
-  const configBackup = join22(backupRoot, "config.yml");
+  const configBackup = join23(backupRoot, "config.yml");
   const configDest = resolve29(projectRoot, ".codeconductor", "config.yml");
   if (existsSync6(configBackup)) {
-    await mkdir19(dirname11(configDest), { recursive: true });
+    await mkdir20(dirname12(configDest), { recursive: true });
     await copyFile2(configBackup, configDest);
   }
-  const workflowsBackup = join22(backupRoot, "workflows");
+  const workflowsBackup = join23(backupRoot, "workflows");
   const workflowsDest = resolve29(projectRoot, ".codeconductor", "workflows");
   if (existsSync6(workflowsBackup)) {
-    await mkdir19(workflowsDest, { recursive: true });
+    await mkdir20(workflowsDest, { recursive: true });
     const files = await readdir10(workflowsBackup);
     for (const file of files) {
-      await copyFile2(join22(workflowsBackup, file), join22(workflowsDest, file));
+      await copyFile2(join23(workflowsBackup, file), join23(workflowsDest, file));
     }
   }
-  const overlayBackup = join22(backupRoot, ACTIVE_OVERLAY_FILE);
+  const overlayBackup = join23(backupRoot, ACTIVE_OVERLAY_FILE);
   const overlayDest = activeOverlayPath(projectRoot);
   if (existsSync6(overlayBackup)) {
     await copyFile2(overlayBackup, overlayDest);
@@ -24770,25 +24868,25 @@ async function snapshotForBackup(projectRoot) {
   const backupRoot = resolve29(projectRoot, EVAL_DIR2, OVERLAY_BACKUP_DIR);
   if (existsSync6(backupRoot))
     return;
-  await mkdir19(backupRoot, { recursive: true });
+  await mkdir20(backupRoot, { recursive: true });
   const configPath = resolve29(projectRoot, ".codeconductor", "config.yml");
   if (existsSync6(configPath)) {
-    await copyFile2(configPath, join22(backupRoot, "config.yml"));
+    await copyFile2(configPath, join23(backupRoot, "config.yml"));
   }
   const workflowsDir = resolve29(projectRoot, ".codeconductor", "workflows");
   if (existsSync6(workflowsDir)) {
-    const dest = join22(backupRoot, "workflows");
-    await mkdir19(dest, { recursive: true });
+    const dest = join23(backupRoot, "workflows");
+    await mkdir20(dest, { recursive: true });
     const files = await readdir10(workflowsDir);
     for (const file of files) {
       if (file.endsWith(".yml")) {
-        await copyFile2(join22(workflowsDir, file), join22(dest, file));
+        await copyFile2(join23(workflowsDir, file), join23(dest, file));
       }
     }
   }
   const overlay = activeOverlayPath(projectRoot);
   if (existsSync6(overlay)) {
-    await copyFile2(overlay, join22(backupRoot, ACTIVE_OVERLAY_FILE));
+    await copyFile2(overlay, join23(backupRoot, ACTIVE_OVERLAY_FILE));
   }
 }
 async function applyHarnessOverlay(projectRoot, disabled, options = {}) {
@@ -24798,12 +24896,12 @@ async function applyHarnessOverlay(projectRoot, disabled, options = {}) {
       await snapshotForBackup(projectRoot);
     }
     const workflowsDir = resolve29(projectRoot, ".codeconductor", "workflows");
-    await mkdir19(workflowsDir, { recursive: true });
-    await mkdir19(resolve29(projectRoot, EVAL_DIR2), { recursive: true });
+    await mkdir20(workflowsDir, { recursive: true });
+    await mkdir20(resolve29(projectRoot, EVAL_DIR2), { recursive: true });
     for (const command of WORKFLOW_OVERLAY_COMMANDS) {
       const base = loadWorkflowProfile(command);
       const next = applyCatalogToProfile(base, disabled);
-      await writeFile19(join22(workflowsDir, `${command}.yml`), $stringify(next), "utf-8");
+      await writeFile20(join23(workflowsDir, `${command}.yml`), $stringify(next), "utf-8");
     }
     const needsConfig = disabled.includes("compile_loop") || disabled.includes("council");
     if (needsConfig) {
@@ -24831,7 +24929,7 @@ async function applyHarnessOverlay(projectRoot, disabled, options = {}) {
       contractVersion: options.contractVersion,
       ccepProfile: options.ccepProfile ?? "feature"
     });
-    await writeFile19(activeOverlayPath(projectRoot), $stringify(overlay), "utf-8");
+    await writeFile20(activeOverlayPath(projectRoot), $stringify(overlay), "utf-8");
     return ok(overlay);
   } catch (e) {
     return err(e instanceof Error ? e : new Error(String(e)));
@@ -24943,7 +25041,7 @@ var init_harness_catalog = __esm(() => {
 
 // src/core/openspec/openspec-state.ts
 import { createHash as createHash6 } from "node:crypto";
-import { mkdir as mkdir20, readFile as readFile32, rename as rename4, writeFile as writeFile20 } from "node:fs/promises";
+import { mkdir as mkdir21, readFile as readFile32, rename as rename4, writeFile as writeFile21 } from "node:fs/promises";
 import { resolve as resolve30 } from "node:path";
 function canTransition(from, to) {
   return ALLOWED_TRANSITIONS[from]?.includes(to) ?? false;
@@ -24965,7 +25063,7 @@ function applyBacklogTransition(content, itemId, from, to, progress) {
 }
 async function writeFileAtomic(path, content) {
   const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
-  await writeFile20(tmp, content, "utf-8");
+  await writeFile21(tmp, content, "utf-8");
   await rename4(tmp, path);
 }
 async function loadOpenspecState(projectRoot) {
@@ -24989,7 +25087,7 @@ async function loadOpenspecState(projectRoot) {
 async function writeOpenspecState(projectRoot, state) {
   try {
     const dir = resolve30(projectRoot, ".codeconductor");
-    await mkdir20(dir, { recursive: true });
+    await mkdir21(dir, { recursive: true });
     const validated = OpenspecStateSchema.parse(state);
     await writeFileAtomic(resolve30(dir, "openspec-state.json"), JSON.stringify(validated, null, 2));
     return ok(undefined);
@@ -25097,7 +25195,7 @@ var init_openspec_state = __esm(() => {
 // src/core/ccep/context-resolver.ts
 import { existsSync as existsSync7 } from "node:fs";
 import { readFile as readFile33 } from "node:fs/promises";
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 async function loadProductKnowledge(projectRoot) {
   if (isProductGraphDisabled(projectRoot)) {
     return {};
@@ -25123,7 +25221,7 @@ async function loadProductKnowledge(projectRoot) {
 }
 async function resolveAstSource(projectRoot) {
   if (isProductGraphDisabled(projectRoot)) {
-    const graphifyPath2 = join23(projectRoot, "graphify-out", "graph.json");
+    const graphifyPath2 = join24(projectRoot, "graphify-out", "graph.json");
     if (existsSync7(graphifyPath2)) {
       return { source: "graphify", confidence: "medium" };
     }
@@ -25133,7 +25231,7 @@ async function resolveAstSource(projectRoot) {
   if (existsSync7(graphPath)) {
     return { source: "product-graph", confidence: "high" };
   }
-  const graphifyPath = join23(projectRoot, "graphify-out", "graph.json");
+  const graphifyPath = join24(projectRoot, "graphify-out", "graph.json");
   if (existsSync7(graphifyPath)) {
     return { source: "graphify", confidence: "medium" };
   }
@@ -26781,7 +26879,7 @@ var init_backlog_planner = __esm(() => {
 });
 
 // src/core/openspec/openspec-generator.ts
-import { access as access7, mkdir as mkdir21, rename as rename5, writeFile as writeFile21 } from "node:fs/promises";
+import { access as access7, mkdir as mkdir22, rename as rename5, writeFile as writeFile22 } from "node:fs/promises";
 import { basename as basename8, resolve as resolve32 } from "node:path";
 function pad3(n) {
   return String(n).padStart(3, "0");
@@ -26869,8 +26967,8 @@ ${blocks.join(`
 `;
 }
 async function writeTasksMarkdown(projectRoot, changePath, cards, options = {}) {
-  await mkdir21(resolve32(projectRoot, changePath), { recursive: true });
-  await writeFile21(resolve32(projectRoot, changePath, "tasks.md"), tasksContent(cards, options), "utf-8");
+  await mkdir22(resolve32(projectRoot, changePath), { recursive: true });
+  await writeFile22(resolve32(projectRoot, changePath, "tasks.md"), tasksContent(cards, options), "utf-8");
 }
 function tasksContent(cards, options = {}) {
   const criteria = options.acceptanceCriteria ?? [];
@@ -26916,18 +27014,18 @@ function tasksContent(cards, options = {}) {
 async function generateOpenspecChange(projectRoot, item, taskCards, options = {}) {
   const slug = buildChangeSlug(item);
   const changeDir = resolve32(projectRoot, "openspec", "changes", slug);
-  await mkdir21(resolve32(changeDir, "specs"), { recursive: true });
+  await mkdir22(resolve32(changeDir, "specs"), { recursive: true });
   const taskOpts = {
     tddRequired: options.tddRequired,
     acceptanceCriteria: options.acceptanceCriteria ?? item.acceptanceCriteria
   };
-  await writeFile21(resolve32(changeDir, "proposal.md"), proposalContent(item), "utf-8");
-  await writeFile21(resolve32(changeDir, "design.md"), designContent(item), "utf-8");
-  await writeFile21(resolve32(changeDir, "tasks.md"), tasksContent(taskCards, taskOpts), "utf-8");
+  await writeFile22(resolve32(changeDir, "proposal.md"), proposalContent(item), "utf-8");
+  await writeFile22(resolve32(changeDir, "design.md"), designContent(item), "utf-8");
+  await writeFile22(resolve32(changeDir, "tasks.md"), tasksContent(taskCards, taskOpts), "utf-8");
   const capability = capabilitySlug(item.title);
-  await mkdir21(resolve32(changeDir, "specs", capability), { recursive: true });
-  await writeFile21(resolve32(changeDir, "specs", capability, "spec.md"), specDelta(item), "utf-8");
-  await writeFile21(resolve32(changeDir, "change.yaml"), `version: 1
+  await mkdir22(resolve32(changeDir, "specs", capability), { recursive: true });
+  await writeFile22(resolve32(changeDir, "specs", capability, "spec.md"), specDelta(item), "utf-8");
+  await writeFile22(resolve32(changeDir, "change.yaml"), `version: 1
 backlogId: ${item.id}
 profile: standard
 capabilities:
@@ -26939,7 +27037,7 @@ async function archiveChangeFolder(projectRoot, changePath) {
   const src = resolve32(projectRoot, changePath);
   const slug = basename8(changePath);
   const destDir = resolve32(projectRoot, "openspec", "changes", "archive");
-  await mkdir21(destDir, { recursive: true });
+  await mkdir22(destDir, { recursive: true });
   const dest = resolve32(destDir, slug);
   try {
     await access7(dest);
@@ -26958,11 +27056,11 @@ async function ensureOpenspecConfig(projectRoot) {
     const { access: access8 } = await import("node:fs/promises");
     await access8(configPath);
   } catch {
-    await mkdir21(resolve32(projectRoot, "openspec"), { recursive: true });
+    await mkdir22(resolve32(projectRoot, "openspec"), { recursive: true });
     const stub = `# OpenSpec project config (CodeConductor native compatible)
 schema: spec-driven
 `;
-    await writeFile21(configPath, stub, "utf-8");
+    await writeFile22(configPath, stub, "utf-8");
   }
 }
 var init_openspec_generator = __esm(() => {
@@ -26972,7 +27070,7 @@ var init_openspec_generator = __esm(() => {
 
 // src/core/openspec/spec-files.ts
 import { readFile as readFile35, readdir as readdir11 } from "node:fs/promises";
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 async function walkMarkdownFiles(dir) {
   let entries;
   try {
@@ -26982,7 +27080,7 @@ async function walkMarkdownFiles(dir) {
   }
   const files = [];
   for (const entry of entries) {
-    const path = join24(dir, entry.name);
+    const path = join25(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...await walkMarkdownFiles(path));
     } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -27015,7 +27113,7 @@ var init_spec_files = __esm(() => {
 
 // src/core/openspec/spec-quality.ts
 import { readFile as readFile36 } from "node:fs/promises";
-import { join as join25, relative as relative10, resolve as resolve33 } from "node:path";
+import { join as join26, relative as relative10, resolve as resolve33 } from "node:path";
 function uniqueIds(matches) {
   return [...new Set(matches ?? [])];
 }
@@ -27145,9 +27243,9 @@ async function assessChangeFolder(projectRoot, changePath) {
       successCriteria: []
     };
   }
-  const specDir = join25(changeRoot, "specs");
+  const specDir = join26(changeRoot, "specs");
   const specFiles = await walkMarkdownFiles(specDir);
-  const extra = ["proposal.md", "design.md"].map((name) => join25(changeRoot, name));
+  const extra = ["proposal.md", "design.md"].map((name) => join26(changeRoot, name));
   const reports = [];
   for (const file of specFiles) {
     const content = await readFile36(file, "utf-8");
@@ -27213,7 +27311,7 @@ var init_spec_quality = __esm(() => {
 
 // src/core/openspec/spec-analyzer.ts
 import { readFile as readFile37 } from "node:fs/promises";
-import { join as join26, resolve as resolve34 } from "node:path";
+import { join as join27, resolve as resolve34 } from "node:path";
 function unique(ids) {
   return [...new Set(ids)];
 }
@@ -27315,16 +27413,16 @@ function analyzeSpecArtifacts(input) {
 }
 async function analyzeChangeFolder(projectRoot, changePath, options) {
   const changeRoot = resolve34(projectRoot, changePath);
-  const specMarkdown = await readDeltaSpecs(join26(changeRoot, "specs"));
+  const specMarkdown = await readDeltaSpecs(join27(changeRoot, "specs"));
   let tasksMarkdown = "";
   try {
-    tasksMarkdown = await readFile37(join26(changeRoot, "tasks.md"), "utf-8");
+    tasksMarkdown = await readFile37(join27(changeRoot, "tasks.md"), "utf-8");
   } catch {
     tasksMarkdown = "";
   }
   let designMarkdown;
   try {
-    designMarkdown = await readFile37(join26(changeRoot, "design.md"), "utf-8");
+    designMarkdown = await readFile37(join27(changeRoot, "design.md"), "utf-8");
   } catch {
     designMarkdown = undefined;
   }
@@ -27344,8 +27442,8 @@ var init_spec_analyzer = __esm(() => {
 });
 
 // src/core/openspec/spec-sync.ts
-import { mkdir as mkdir22, readFile as readFile38 } from "node:fs/promises";
-import { join as join27, relative as relative11, resolve as resolve35 } from "node:path";
+import { mkdir as mkdir23, readFile as readFile38 } from "node:fs/promises";
+import { join as join28, relative as relative11, resolve as resolve35 } from "node:path";
 function deltaRequirements(markdown) {
   const sections = [...markdown.matchAll(SECTION_HEADING)];
   return sections.flatMap((section, index) => {
@@ -27407,7 +27505,7 @@ ${delta.markdown}`;
 async function syncChangeSpecs(projectRoot, changePath) {
   const root = resolve35(projectRoot);
   const changeRoot = resolve35(root, changePath);
-  const changeSpecs = join27(changeRoot, "specs");
+  const changeSpecs = join28(changeRoot, "specs");
   if (changeRoot !== root && !changeRoot.startsWith(`${root}/`)) {
     return { success: false, syncedPaths: [], errors: ["Change path escapes project root"] };
   }
@@ -27427,7 +27525,7 @@ async function syncChangeSpecs(projectRoot, changePath) {
       };
     }
     const relativeSpec = relative11(changeSpecs, file);
-    const target = join27(root, "openspec", "specs", relativeSpec);
+    const target = join28(root, "openspec", "specs", relativeSpec);
     let existing = `# ${relativeSpec.replace(/\\/g, "/")}
 `;
     try {
@@ -27439,7 +27537,7 @@ async function syncChangeSpecs(projectRoot, changePath) {
     writes.push({ path: target, content: merged.content });
   }
   for (const write of writes) {
-    await mkdir22(resolve35(write.path, ".."), { recursive: true });
+    await mkdir23(resolve35(write.path, ".."), { recursive: true });
     await writeFileAtomic(write.path, write.content);
   }
   return {
@@ -27457,7 +27555,7 @@ var init_spec_sync = __esm(() => {
 
 // src/core/openspec/artifact-progress.ts
 import { access as access8, readdir as readdir12, readFile as readFile39 } from "node:fs/promises";
-import { join as join28, resolve as resolve36 } from "node:path";
+import { join as join29, resolve as resolve36 } from "node:path";
 function countCheckboxes(markdown) {
   let total = 0;
   let complete = 0;
@@ -27488,7 +27586,7 @@ async function hasMarkdown(dir) {
     return false;
   }
   for (const entry of entries) {
-    const full = join28(dir, entry.name);
+    const full = join29(dir, entry.name);
     if (entry.isFile() && entry.name.endsWith(".md"))
       return true;
     if (entry.isDirectory() && await hasMarkdown(full))
@@ -27503,15 +27601,15 @@ async function readArtifactProgress(projectRoot, changePath) {
     return ABSENT;
   }
   const [proposal, design, tasks, specs] = await Promise.all([
-    exists(join28(changeRoot, "proposal.md")),
-    exists(join28(changeRoot, "design.md")),
-    exists(join28(changeRoot, "tasks.md")),
-    hasMarkdown(join28(changeRoot, "specs"))
+    exists(join29(changeRoot, "proposal.md")),
+    exists(join29(changeRoot, "design.md")),
+    exists(join29(changeRoot, "tasks.md")),
+    hasMarkdown(join29(changeRoot, "specs"))
   ]);
   let checkboxes = { total: 0, complete: 0, remaining: 0 };
   if (tasks) {
     try {
-      checkboxes = countCheckboxes(await readFile39(join28(changeRoot, "tasks.md"), "utf-8"));
+      checkboxes = countCheckboxes(await readFile39(join29(changeRoot, "tasks.md"), "utf-8"));
     } catch {
       checkboxes = { total: 0, complete: 0, remaining: 0 };
     }
@@ -28473,7 +28571,7 @@ var init_handoff_envelope = __esm(() => {
 
 // src/core/delivery/delivery-ledger.ts
 import { createHash as createHash7 } from "node:crypto";
-import { mkdir as mkdir23, readFile as readFile41, writeFile as writeFile22 } from "node:fs/promises";
+import { mkdir as mkdir24, readFile as readFile41, writeFile as writeFile23 } from "node:fs/promises";
 import { resolve as resolve38, sep as sep9 } from "node:path";
 function ledgerPath(projectRoot, id) {
   if (!/^[a-z0-9][a-z0-9-]{0,63}$/.test(id))
@@ -28538,9 +28636,9 @@ async function createDeliveryLedger(projectRoot, input) {
     createdAt: now,
     updatedAt: now
   });
-  await mkdir23(resolve38(projectRoot, DELIVERY_DIR), { recursive: true });
+  await mkdir24(resolve38(projectRoot, DELIVERY_DIR), { recursive: true });
   try {
-    await writeFile22(path, render(ledger), { encoding: "utf-8", flag: "wx" });
+    await writeFile23(path, render(ledger), { encoding: "utf-8", flag: "wx" });
     return { created: true, ledger };
   } catch (error) {
     if (error instanceof Error && error.message.includes("EEXIST")) {
@@ -28871,9 +28969,9 @@ __export(exports_hook_command, {
   readStdinText: () => readStdinText
 });
 import { spawnSync } from "node:child_process";
-import { existsSync as existsSync8, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync6 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname12, resolve as resolve39 } from "node:path";
+import { dirname as dirname13, resolve as resolve39 } from "node:path";
 function parseHookFormat(raw) {
   return raw === "agy" || raw === "claude" || raw === "muse" ? raw : undefined;
 }
@@ -28972,10 +29070,10 @@ function formatWrittenFile(filePath, projectRoot) {
   function runNodeTool(name, args) {
     try {
       const manifestPath = require2.resolve(`${name}/package.json`);
-      const manifest = JSON.parse(readFileSync5(manifestPath, "utf8"));
+      const manifest = JSON.parse(readFileSync6(manifestPath, "utf8"));
       const bin = typeof manifest.bin === "string" ? manifest.bin : manifest.bin?.[name];
       if (typeof bin === "string")
-        spawnSync(process.execPath, [resolve39(dirname12(manifestPath), bin), ...args], opts);
+        spawnSync(process.execPath, [resolve39(dirname13(manifestPath), bin), ...args], opts);
     } catch {}
   }
   if (prettier.test(filePath)) {
@@ -29514,13 +29612,13 @@ var init_scorecard_signals = __esm(() => {
 
 // src/core/evaluation/harness-experiment.ts
 import { existsSync as existsSync9 } from "node:fs";
-import { cp, mkdir as mkdir24, readFile as readFile42, readdir as readdir13, writeFile as writeFile23 } from "node:fs/promises";
-import { dirname as dirname13, join as join29, resolve as resolve40 } from "node:path";
+import { cp, mkdir as mkdir25, readFile as readFile42, readdir as readdir13, writeFile as writeFile24 } from "node:fs/promises";
+import { dirname as dirname14, join as join30, resolve as resolve40 } from "node:path";
 function experimentDir(projectRoot, experimentId) {
   return resolve40(projectRoot, EVAL_DIR2, EXPERIMENTS_DIR, experimentId);
 }
 function experimentYamlPath(projectRoot, experimentId) {
-  return join29(experimentDir(projectRoot, experimentId), "experiment.yml");
+  return join30(experimentDir(projectRoot, experimentId), "experiment.yml");
 }
 async function loadHarnessSuite(projectRoot, suiteId, suitePath) {
   const candidates = suitePath ? [suitePath] : [
@@ -29630,8 +29728,8 @@ function generateExperimentId(suiteId, now = new Date) {
   return `abl-${date}-${suiteId}-${rand}`;
 }
 async function copyFixture(suitePath, fixtureDir, dest) {
-  const source = fixtureDir ? resolve40(dirname13(suitePath), fixtureDir) : join29(dirname13(suitePath), "fixture");
-  await mkdir24(dest, { recursive: true });
+  const source = fixtureDir ? resolve40(dirname14(suitePath), fixtureDir) : join30(dirname14(suitePath), "fixture");
+  await mkdir25(dest, { recursive: true });
   if (existsSync9(source)) {
     await cp(source, dest, { recursive: true });
   }
@@ -29653,12 +29751,12 @@ async function startHarnessExperiment(projectRoot, options) {
     suitePath: suite.data.path
   };
   const root = experimentDir(projectRoot, experimentId);
-  await mkdir24(root, { recursive: true });
-  await writeFile23(experimentYamlPath(projectRoot, experimentId), $stringify(experiment), "utf-8");
-  await writeFile23(join29(root, "EXPERIMENT.md"), formatExperimentMarkdown(experiment), "utf-8");
+  await mkdir25(root, { recursive: true });
+  await writeFile24(experimentYamlPath(projectRoot, experimentId), $stringify(experiment), "utf-8");
+  await writeFile24(join30(root, "EXPERIMENT.md"), formatExperimentMarkdown(experiment), "utf-8");
   for (const task of suite.data.tasks) {
     for (const variantId of variants) {
-      const runRoot = join29(root, "runs", task.id, variantDirName(variantId));
+      const runRoot = join30(root, "runs", task.id, variantDirName(variantId));
       await copyFixture(suite.data.path, suite.data.fixtureDir, runRoot);
       await writeConfig(runRoot, structuredClone(DEFAULT_CONFIG), true);
       const disabled = variantId === "baseline" ? [] : options.components.filter((id) => variantIdFor(id) === variantId);
@@ -29670,7 +29768,7 @@ async function startHarnessExperiment(projectRoot, options) {
       });
       if (!overlay.success)
         return overlay;
-      await writeFile23(join29(runRoot, "TASK.md"), formatTaskCard(task, experimentId, variantId), "utf-8");
+      await writeFile24(join30(runRoot, "TASK.md"), formatTaskCard(task, experimentId, variantId), "utf-8");
     }
   }
   return ok(experiment);
@@ -29901,7 +29999,7 @@ var init_execution_profile = __esm(() => {
 
 // src/core/evaluation/prompt-diff.ts
 import { readFile as readFile44, readdir as readdir14 } from "node:fs/promises";
-import { join as join30, resolve as resolve43 } from "node:path";
+import { join as join31, resolve as resolve43 } from "node:path";
 function normalizeVersion(v) {
   return v.startsWith("v") ? v : `v${v}`;
 }
@@ -29951,29 +30049,29 @@ async function diffPromptVersions(fromVersion, toVersion, options = {}) {
   const toV = normalizeVersion(toVersion);
   const searchRoots = [
     resolve43(options.projectRoot ?? PACKAGE_ROOT, ".agents", "prompts"),
-    join30(ROOT_PRESETS_DIR, target, "prompts"),
-    join30(ROOT_PRESETS_DIR, "opencode", "prompts")
+    join31(ROOT_PRESETS_DIR, target, "prompts"),
+    join31(ROOT_PRESETS_DIR, "opencode", "prompts")
   ];
   let fromDir = "";
   let toDir = "";
   for (const root of searchRoots) {
-    const f = join30(root, fromV);
-    const t = join30(root, toV);
+    const f = join31(root, fromV);
+    const t = join31(root, toV);
     try {
-      await readFile44(join30(f, "orchestrator.md"), "utf-8");
+      await readFile44(join31(f, "orchestrator.md"), "utf-8");
       fromDir = f;
       toDir = t;
       break;
     } catch {}
   }
   if (!fromDir) {
-    fromDir = join30(ROOT_PRESETS_DIR, "opencode", "prompts", fromV);
-    toDir = join30(ROOT_PRESETS_DIR, "opencode", "prompts", toV);
+    fromDir = join31(ROOT_PRESETS_DIR, "opencode", "prompts", fromV);
+    toDir = join31(ROOT_PRESETS_DIR, "opencode", "prompts", toV);
   } else {
     try {
-      await readFile44(join30(toDir, "orchestrator.md"), "utf-8");
+      await readFile44(join31(toDir, "orchestrator.md"), "utf-8");
     } catch {
-      toDir = join30(ROOT_PRESETS_DIR, "opencode", "prompts", toV);
+      toDir = join31(ROOT_PRESETS_DIR, "opencode", "prompts", toV);
     }
   }
   const fromFiles = await listPromptFiles(fromDir);
@@ -29991,12 +30089,12 @@ async function diffPromptVersions(fromVersion, toVersion, options = {}) {
     let oldText = "";
     let newText = "";
     try {
-      oldText = await readFile44(join30(fromDir, name), "utf-8");
+      oldText = await readFile44(join31(fromDir, name), "utf-8");
     } catch {
       oldText = "";
     }
     try {
-      newText = await readFile44(join30(toDir, name), "utf-8");
+      newText = await readFile44(join31(toDir, name), "utf-8");
     } catch {
       newText = "";
     }
@@ -30036,8 +30134,8 @@ var init_prompt_diff = __esm(() => {
 
 // src/core/evaluation/regression-checklist.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { mkdir as mkdir25, readFile as readFile45, writeFile as writeFile24 } from "node:fs/promises";
-import { dirname as dirname14, resolve as resolve44 } from "node:path";
+import { mkdir as mkdir26, readFile as readFile45, writeFile as writeFile25 } from "node:fs/promises";
+import { dirname as dirname15, resolve as resolve44 } from "node:path";
 async function loadRegressionChecklist() {
   try {
     const path = resolve44(ROOT_PRESETS_DIR, "templates", "regression-checklist.yml");
@@ -30097,8 +30195,8 @@ async function runRegressionChecklist(projectRoot, options = {}) {
       timestamp: new Date().toISOString()
     };
     const outPath = resolve44(projectRoot, ".codeconductor/evaluation/regression-last.json");
-    await mkdir25(dirname14(outPath), { recursive: true });
-    await writeFile24(outPath, JSON.stringify(report, null, 2), "utf-8");
+    await mkdir26(dirname15(outPath), { recursive: true });
+    await writeFile25(outPath, JSON.stringify(report, null, 2), "utf-8");
     return ok(report);
   } catch (e) {
     return err(e instanceof Error ? e : new Error(String(e)));
@@ -30140,7 +30238,7 @@ var init_model_comparison = __esm(() => {
 });
 
 // src/core/evaluation/cost-quality-matrix.ts
-import { writeFile as writeFile25 } from "node:fs/promises";
+import { writeFile as writeFile26 } from "node:fs/promises";
 import { resolve as resolve45 } from "node:path";
 async function buildCostQualityMatrix(projectRoot, outcomes) {
   const agg = aggregateOutcomes(outcomes);
@@ -30161,7 +30259,7 @@ async function buildCostQualityMatrix(projectRoot, outcomes) {
     rows
   };
   const dir = await ensureEvaluationDir(projectRoot);
-  await writeFile25(resolve45(dir, "matrix.yml"), $stringify(matrix), "utf-8");
+  await writeFile26(resolve45(dir, "matrix.yml"), $stringify(matrix), "utf-8");
   return matrix;
 }
 function formatMatrixMarkdown(matrix) {
@@ -30185,7 +30283,7 @@ var init_cost_quality_matrix = __esm(() => {
 });
 
 // src/core/evaluation/ablation-report.ts
-import { mkdir as mkdir26, writeFile as writeFile26 } from "node:fs/promises";
+import { mkdir as mkdir27, writeFile as writeFile27 } from "node:fs/promises";
 import { resolve as resolve46 } from "node:path";
 function isPass(o) {
   return o.verdict === "PASS" || o.status === "pass";
@@ -30355,9 +30453,9 @@ function formatAblationMarkdown(report) {
 }
 async function persistAblationReport(projectRoot, markdown) {
   const dir = resolve46(projectRoot, EVAL_DIR2);
-  await mkdir26(dir, { recursive: true });
+  await mkdir27(dir, { recursive: true });
   const path = resolve46(dir, "ablation-last.md");
-  await writeFile26(path, markdown, "utf-8");
+  await writeFile27(path, markdown, "utf-8");
   return path;
 }
 var SCORE_THRESHOLD = 0.1, PASS_RATE_THRESHOLD = 0.05;
@@ -30664,9 +30762,9 @@ async function handleCompareModels(projectRoot, options) {
   try {
     await readFile46(templatePath);
   } catch {}
-  const { writeFile: writeFile27, mkdir: mkdir27 } = await import("node:fs/promises");
-  await mkdir27(resolve47(projectRoot, ".codeconductor/evaluation"), { recursive: true });
-  await writeFile27(templatePath, markdown, "utf-8");
+  const { writeFile: writeFile28, mkdir: mkdir28 } = await import("node:fs/promises");
+  await mkdir28(resolve47(projectRoot, ".codeconductor/evaluation"), { recursive: true });
+  await writeFile28(templatePath, markdown, "utf-8");
   return {
     code: 0,
     data: {
@@ -32135,7 +32233,7 @@ var exports_seo_audit_command = {};
 __export(exports_seo_audit_command, {
   seoAuditCommand: () => seoAuditCommand
 });
-import { join as join31 } from "node:path";
+import { join as join32 } from "node:path";
 async function seoAuditCommand(options) {
   const { url, sitemap, format, failOn, delay: delay2, output, followRedirects, force } = options;
   if (!url && !sitemap) {
@@ -32148,7 +32246,7 @@ async function seoAuditCommand(options) {
       }
     };
   }
-  const defaultMarkdownPath = output === undefined && format === "markdown" ? join31("seo-reports", `audit-report-${new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19)}.md`) : undefined;
+  const defaultMarkdownPath = output === undefined && format === "markdown" ? join32("seo-reports", `audit-report-${new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19)}.md`) : undefined;
   const outputPathToWrite = output ?? defaultMarkdownPath;
   if (outputPathToWrite !== undefined) {
     const preflightError = await preflightContainedOutput(options.projectRoot, outputPathToWrite, { force });