cc-codeconductor 1.5.1 → 1.6.0

package/dist/index.js

@@ -72,7 +72,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "cc-codeconductor",
-    version: "1.5.1",
+    version: "1.6.0",
     description: "A multi-agent orchestration framework for AI-assisted software engineering workflows.",
     keywords: [
       "ai",
@@ -4140,9 +4140,10 @@ var init_runner_target = __esm(() => {
     "cursor",
     "agy",
     "pi",
+    "muse",
     "all"
   ];
-  INDIVIDUAL_TARGETS = ["opencode", "claude", "codex", "gemini", "cursor", "agy", "pi"];
+  INDIVIDUAL_TARGETS = ["opencode", "claude", "codex", "gemini", "cursor", "agy", "pi", "muse"];
 });
 
 // src/utils/cli-bin.ts
@@ -11324,6 +11325,12 @@ __export(exports_schemas, {
   validateTaskOutcome: () => validateTaskOutcome,
   validateWorkflowProfile: () => validateWorkflowProfile
 });
+import { isAbsolute } from "node:path";
+function isContainedRelativePath(value) {
+  if (value === "" || isAbsolute(value))
+    return false;
+  return !value.replace(/\\/g, "/").split("/").includes("..");
+}
 function validateCouncilSpec(data) {
   return CouncilSpecSchema.parse(data);
 }
@@ -11441,7 +11448,7 @@ function validateProductEvent(data) {
 function validateSkillsRegistry(data) {
   return SkillsRegistrySchema.parse(data);
 }
-var CouncilAgentSpecSchema, CouncilSpecSchema, ProjectProfileSchema, CompileCheckConfigSchema, LoopConfigSchema, CodeConductorConfigSchema, RunnerTargetSchema, InstallStrategySchema, ManifestEntrySchema, InstallManifestSchema, ToolProviderNamesSchema, PermissionProviderNamesSchema, ModelConfigSchema, SkillFrontmatterSchema, CommandFrontmatterSchema, TargetCapabilitiesSchema, ContractTargetSchema, ContractFormatSchema, AgentContractSchema, CouncilFindingSchema, CouncilVerdictInputSchema, ConsensusConfigSchema, CouncilVerdictSchema, ClaudeAgentFileSchema, OpenCodeAgentFileSchema, SentryStackFrameSchema, SentryWebhookSchema, MemoryPointerSchema, MemoryIndexSchema, GoalTaskSchema, GoalGraphSchema, ConfidenceLevelSchema, ProductNodeTypeSchema, GraphRelationSchema, KnowledgeEntitySchema, DecisionSchema, EvidenceSchema, CanonicalTaskCardStatusSchema, CanonicalTaskCardSchema, ProductGraphNodeSchema, ProductGraphEdgeSchema, ProductGraphSchema, ProductMetaSchema, ProductEventTypeSchema, ProductEventSchema, OperationalStateSchema, StrategicMemorySchema, ImpactReportSchema, BusinessReviewOutputSchema, VerificationReportSchema, BacklogStatusSchema, BacklogTypeSchema, BacklogPrioritySchema, BacklogGlobalSchema, BacklogItemSchema, BacklogDocumentSchema, OpenspecTaskCardPhaseSchema, OpenspecTaskCardStatusSchema, OpenspecTaskCardSchema, OpenspecStateSchema, SpecAnalyzeFindingSchema, SpecAnalyzeReportSchema, WorkflowCommandSchema, CcepOutputFormatSchema, CommandEnvelopeSchema, WorkflowPhaseSchema, WorkflowRiskRuleSchema, WorkflowProfileSchema, ExecutionContextSchema, PlannerOutputSchema, AgentArtifactSchema, AgentOutputSchema, ImplementerTestsSchema, ImplementerOutputSchema, ReviewAxisSchema, ReviewFindingSchema, ReviewerOutputSchema, TechnicalPlanOutputSchema, FixIntakeOutputSchema, ScorecardVerdictSchema, ScorecardCriterionIdSchema, ScorecardCriterionSchema, ScorecardRecordSchema, TaskOutcomeSourceSchema, TaskOutcomeStatusSchema, DeliveryRouteSchema, TokenUsageSchema, DeliveryTelemetrySchema, DeliveryLedgerTaskSchema, DeliveryLedgerSchema, HandoffEnvelopeSchema, RepoRelativePathSchema, DeliveryLedgerRequestSchema, TaskOutcomeSchema, HarnessComponentIdSchema, HarnessComponentLayerSchema, HarnessToggleKindSchema, HarnessCatalogEntrySchema, HarnessCatalogSchema, HarnessOverlaySchema, HarnessExperimentSchema, HarnessSuiteTaskSchema, HarnessSuiteSchema, EvaluationIndexSchema, ExecutionProfileNameSchema, ExecutionProfileSchema, SkillsRegistrySchema;
+var CouncilAgentSpecSchema, CouncilSpecSchema, ProjectProfileSchema, CompileCheckConfigSchema, LoopConfigSchema, CodeConductorConfigSchema, RunnerTargetSchema, InstallStrategySchema, ContainedRelativePathSchema, ManifestEntrySchema, InstallManifestSchema, ToolProviderNamesSchema, PermissionProviderNamesSchema, ModelConfigSchema, SkillFrontmatterSchema, CommandFrontmatterSchema, TargetCapabilitiesSchema, ContractTargetSchema, ContractFormatSchema, AgentContractSchema, CouncilFindingSchema, CouncilVerdictInputSchema, ConsensusConfigSchema, CouncilVerdictSchema, ClaudeAgentFileSchema, OpenCodeAgentFileSchema, SentryStackFrameSchema, SentryWebhookSchema, MemoryPointerSchema, MemoryIndexSchema, GoalTaskSchema, GoalGraphSchema, ConfidenceLevelSchema, ProductNodeTypeSchema, GraphRelationSchema, KnowledgeEntitySchema, DecisionSchema, EvidenceSchema, CanonicalTaskCardStatusSchema, CanonicalTaskCardSchema, ProductGraphNodeSchema, ProductGraphEdgeSchema, ProductGraphSchema, ProductMetaSchema, ProductEventTypeSchema, ProductEventSchema, OperationalStateSchema, StrategicMemorySchema, ImpactReportSchema, BusinessReviewOutputSchema, VerificationReportSchema, BacklogStatusSchema, BacklogTypeSchema, BacklogPrioritySchema, BacklogGlobalSchema, BacklogItemSchema, BacklogDocumentSchema, OpenspecTaskCardPhaseSchema, OpenspecTaskCardStatusSchema, OpenspecTaskCardSchema, OpenspecStateSchema, SpecAnalyzeFindingSchema, SpecAnalyzeReportSchema, WorkflowCommandSchema, CcepOutputFormatSchema, CommandEnvelopeSchema, WorkflowPhaseSchema, WorkflowRiskRuleSchema, WorkflowProfileSchema, ExecutionContextSchema, PlannerOutputSchema, AgentArtifactSchema, AgentOutputSchema, ImplementerTestsSchema, ImplementerOutputSchema, ReviewAxisSchema, ReviewFindingSchema, ReviewerOutputSchema, TechnicalPlanOutputSchema, FixIntakeOutputSchema, ScorecardVerdictSchema, ScorecardCriterionIdSchema, ScorecardCriterionSchema, ScorecardRecordSchema, TaskOutcomeSourceSchema, TaskOutcomeStatusSchema, DeliveryRouteSchema, TokenUsageSchema, DeliveryTelemetrySchema, DeliveryLedgerTaskSchema, DeliveryLedgerSchema, HandoffEnvelopeSchema, RepoRelativePathSchema, DeliveryLedgerRequestSchema, TaskOutcomeSchema, HarnessComponentIdSchema, HarnessComponentLayerSchema, HarnessToggleKindSchema, HarnessCatalogEntrySchema, HarnessCatalogSchema, HarnessOverlaySchema, HarnessExperimentSchema, HarnessSuiteTaskSchema, HarnessSuiteSchema, EvaluationIndexSchema, ExecutionProfileNameSchema, ExecutionProfileSchema, SkillsRegistrySchema;
 var init_schemas = __esm(() => {
   init_zod();
   init_runner_target();
@@ -11522,9 +11529,12 @@ var init_schemas = __esm(() => {
     "create-only",
     "skip"
   ]);
+  ContainedRelativePathSchema = exports_external.string().refine(isContainedRelativePath, (value) => ({
+    message: `Path must be relative without ".." segments: ${value}`
+  }));
   ManifestEntrySchema = exports_external.object({
-    src: exports_external.string(),
-    dest: exports_external.string(),
+    src: ContainedRelativePathSchema,
+    dest: ContainedRelativePathSchema,
     strategy: InstallStrategySchema,
     globalStrategy: InstallStrategySchema.optional(),
     template: exports_external.boolean().optional()
@@ -11545,7 +11555,8 @@ var init_schemas = __esm(() => {
       cursor: exports_external.string().optional(),
       agy: exports_external.string().optional(),
       pi: exports_external.string().optional(),
-      grok: exports_external.string().optional()
+      grok: exports_external.string().optional(),
+      muse: exports_external.string().optional()
     })),
     tools: exports_external.record(exports_external.string(), ToolProviderNamesSchema).optional(),
     permissions: PermissionProviderNamesSchema.optional()
@@ -12514,30 +12525,45 @@ var init_target_compatibility = __esm(() => {
 import { readFile as readFile3 } from "node:fs/promises";
 import { join } from "node:path";
 async function loadManifest(target) {
+  const cached = manifestCache.get(target);
+  if (cached)
+    return cached;
   const manifestPath = join(MANIFESTS_DIR, `${target}.yml`);
   const content = await readFile3(manifestPath, "utf-8");
   const data = $parse(content);
-  return InstallManifestSchema.parse(data);
+  const manifest = InstallManifestSchema.parse(data);
+  manifestCache.set(target, manifest);
+  return manifest;
 }
 async function loadModelConfig(target) {
+  const cached = modelConfigCache.get(target);
+  if (cached)
+    return cached;
   const [rolesRaw, targetRaw] = await Promise.all([
     readFile3(join(MODELS_DIR, "roles.yml"), "utf-8"),
     readFile3(join(MODELS_DIR, `${target}.yml`), "utf-8")
   ]);
   const roles = $parse(rolesRaw);
   const targetData = $parse(targetRaw);
-  return ModelConfigSchema.parse({
+  const config = ModelConfigSchema.parse({
     target: targetData.target,
     agents: roles.agents,
     tools: targetData.permissions ? undefined : roles.tools,
     permissions: targetData.permissions
   });
+  modelConfigCache.set(target, config);
+  return config;
 }
 async function loadTargetCapabilities(target) {
+  const cached = capabilitiesCache.get(target);
+  if (cached)
+    return cached;
   const content = await readFile3(join(TARGETS_DIR, `${target}.yml`), "utf-8");
-  return TargetCapabilitiesSchema.parse($parse(content));
+  const capabilities = TargetCapabilitiesSchema.parse($parse(content));
+  capabilitiesCache.set(target, capabilities);
+  return capabilities;
 }
-var MANIFESTS_DIR, MODELS_DIR, TARGETS_DIR, PRESETS_DIR;
+var MANIFESTS_DIR, MODELS_DIR, TARGETS_DIR, PRESETS_DIR, manifestCache, modelConfigCache, capabilitiesCache;
 var init_manifest_loader = __esm(() => {
   init_dist();
   init_schemas();
@@ -12546,6 +12572,9 @@ var init_manifest_loader = __esm(() => {
   MODELS_DIR = join(SRC_PRESETS_DIR, "models");
   TARGETS_DIR = join(SRC_PRESETS_DIR, "targets");
   PRESETS_DIR = ROOT_PRESETS_DIR;
+  manifestCache = new Map;
+  modelConfigCache = new Map;
+  capabilitiesCache = new Map;
 });
 
 // src/core/i18n/language-instructions.ts
@@ -12796,23 +12825,23 @@ var init_safety = __esm(() => {
 // src/core/filesystem/path-containment.ts
 import { constants as constants2 } from "node:fs";
 import { lstat, mkdir, open, realpath } from "node:fs/promises";
-import { basename as basename2, dirname as dirname2, isAbsolute, join as join2, relative, resolve as resolve3, sep as sep2 } from "node:path";
+import { basename as basename2, dirname as dirname2, isAbsolute as isAbsolute2, join as join2, relative, resolve as resolve3, sep as sep2 } from "node:path";
 function isInside(root, target) {
   const rel = relative(root, target);
-  return rel !== "" && rel !== ".." && !rel.startsWith(`..${sep2}`) && !isAbsolute(rel);
+  return rel !== "" && rel !== ".." && !rel.startsWith(`..${sep2}`) && !isAbsolute2(rel);
 }
 function isProtectedUnderRoot(rootReal, absolutePath) {
   if (absolutePath === rootReal) {
     return false;
   }
   const relFromRoot = relative(rootReal, absolutePath);
-  if (relFromRoot === "" || relFromRoot === ".." || relFromRoot.startsWith(`..${sep2}`) || isAbsolute(relFromRoot)) {
+  if (relFromRoot === "" || relFromRoot === ".." || relFromRoot.startsWith(`..${sep2}`) || isAbsolute2(relFromRoot)) {
     return true;
   }
   return !validateWritePath(relFromRoot);
 }
 async function resolveWithinRoot(projectRoot, relPath) {
-  if (isAbsolute(relPath)) {
+  if (isAbsolute2(relPath)) {
     return;
   }
   const rootAbs = resolve3(projectRoot);
@@ -12877,7 +12906,7 @@ async function canonicalizeExistingPrefix(target) {
   }
 }
 async function resolveOutputWithinRoot(projectRoot, relPath) {
-  if (relPath === "" || isAbsolute(relPath)) {
+  if (relPath === "" || isAbsolute2(relPath)) {
     return;
   }
   const rootAbs = resolve3(projectRoot);
@@ -12996,7 +13025,7 @@ async function writeContainedFile(projectRoot, relPath, content, options) {
   }
 }
 async function preflightContainedOutput(projectRoot, relPath, options) {
-  if (relPath === "" || isAbsolute(relPath)) {
+  if (relPath === "" || isAbsolute2(relPath)) {
     return `Invalid --output path: ${relPath}. It must be relative to the project root.`;
   }
   if (!validateWritePath(relPath)) {
@@ -13385,7 +13414,7 @@ async function injectMcpServers(jsonString, filePath) {
     return jsonString;
   }
 }
-async function applySingleFile(srcPath, destPath, strategy, force, dryRun, isTemplate, modelConfig, locale, baseDir) {
+async function applySingleFile(srcPath, destPath, strategy, force, dryRun, isTemplate, modelConfig, locale, baseDir, preRendered) {
   if (strategy === "skip") {
     return { src: srcPath, dest: destPath, action: "skipped", dryRun };
   }
@@ -13409,13 +13438,18 @@ async function applySingleFile(srcPath, destPath, strategy, force, dryRun, isTem
   if ((strategy === "overwrite" && !force || strategy === "create-only") && await fileExists2(destPath)) {
     return { src: srcPath, dest: destPath, action: "skipped", dryRun };
   }
-  let content;
-  try {
-    content = await readFile4(srcPath, "utf-8");
-  } catch (e) {
-    return { src: srcPath, dest: destPath, action: "error", error: `Cannot read source: ${e}` };
+  let incomingContent;
+  if (preRendered !== undefined) {
+    incomingContent = preRendered;
+  } else {
+    let content;
+    try {
+      content = await readFile4(srcPath, "utf-8");
+    } catch (e) {
+      return { src: srcPath, dest: destPath, action: "error", error: `Cannot read source: ${e}` };
+    }
+    incomingContent = isTemplate && modelConfig ? await renderTemplate(content, modelConfig, srcPath, locale) : content;
   }
-  let incomingContent = isTemplate && modelConfig ? await renderTemplate(content, modelConfig, srcPath, locale) : content;
   incomingContent = await injectMcpServers(incomingContent, destPath);
   let finalContent = incomingContent;
   let action = "written";
@@ -13462,7 +13496,7 @@ async function applySingleFile(srcPath, destPath, strategy, force, dryRun, isTem
     }
   }
   if (dryRun) {
-    return { src: srcPath, dest: destPath, action, dryRun: true };
+    return { src: srcPath, dest: destPath, action, dryRun: true, renderedContent: finalContent };
   }
   if (baseDir === undefined) {
     return {
@@ -13476,12 +13510,12 @@ async function applySingleFile(srcPath, destPath, strategy, force, dryRun, isTem
     await writeContainedFile(baseDir, relative2(baseDir, destPath), finalContent, {
       force: true
     });
-    return { src: srcPath, dest: destPath, action };
+    return { src: srcPath, dest: destPath, action, renderedContent: finalContent };
   } catch (e) {
     return { src: srcPath, dest: destPath, action: "error", error: String(e) };
   }
 }
-async function copyFromManifest(manifest, presetsDir, baseDir, isGlobal, dryRun, force, modelConfig = null, locale = "en") {
+async function copyFromManifest(manifest, presetsDir, baseDir, isGlobal, dryRun, force, modelConfig = null, locale = "en", preRendered) {
   const results = [];
   for (const entry of manifest.entries) {
     const strategy = isGlobal && entry.globalStrategy ? entry.globalStrategy : entry.strategy;
@@ -13495,7 +13529,7 @@ async function copyFromManifest(manifest, presetsDir, baseDir, isGlobal, dryRun,
     const files = await resolveEntryFiles(resolvedEntry, presetsDir, resolvedBaseDir);
     const isTemplate = entry.template === true;
     for (const { src, dest } of files) {
-      results.push(await applySingleFile(src, dest, strategy, force, dryRun, isTemplate, modelConfig, locale, resolvedBaseDir));
+      results.push(await applySingleFile(src, dest, strategy, force, dryRun, isTemplate, modelConfig, locale, resolvedBaseDir, preRendered?.[dest]));
     }
   }
   return results;
@@ -13632,6 +13666,9 @@ __export(exports_preset_loader, {
 import { readFile as readFile6 } from "node:fs/promises";
 import { resolve as resolve6 } from "node:path";
 async function loadPreset(name, projectRoot = process.cwd()) {
+  if (!PRESET_NAME_RE.test(name)) {
+    return err(new ValidationError(`Invalid preset name: ${name}`));
+  }
   const candidates = [
     resolve6(projectRoot, ".codeconductor", "presets", `${name}.yml`),
     resolve6(SRC_PRESETS_DIR, name, `${name}.yml`)
@@ -13659,11 +13696,13 @@ async function loadPreset(name, projectRoot = process.cwd()) {
 async function loadCouncilPreset(projectRoot) {
   return loadPreset("council", projectRoot);
 }
+var PRESET_NAME_RE;
 var init_preset_loader = __esm(() => {
   init_dist();
   init_errors();
   init_schemas();
   init_package_paths();
+  PRESET_NAME_RE = /^[a-z0-9-]+$/;
 });
 
 // src/domain/council/council-agent.ts
@@ -14450,6 +14489,9 @@ function getTargetInstallationPath(target, basePath, isGlobal) {
   if (target === "agy") {
     return isGlobal ? resolve7(basePath, ".gemini", "config") : resolve7(basePath, ".agents");
   }
+  if (target === "muse" && isGlobal) {
+    return resolve7(basePath, ".agents");
+  }
   return resolve7(basePath, `.${target}`);
 }
 async function isTargetInstalled(target, basePath, isGlobal) {
@@ -14676,6 +14718,7 @@ async function checkUpdates(basePath, isGlobal, includeConflicts = false) {
       locale = configResult.data.defaults.locale ?? "en";
     }
   } catch {}
+  const rendered = {};
   const checkTarget = async (target) => {
     const isInstalled = await isTargetInstalled(target, basePath, isGlobal);
     if (!isInstalled) {
@@ -14710,6 +14753,7 @@ async function checkUpdates(basePath, isGlobal, includeConflicts = false) {
         try {
           const srcContent = await readFile7(src, "utf-8");
           expectedContent = isTemplate && modelConfig ? await renderTemplate(srcContent, modelConfig, src, locale) : srcContent;
+          rendered[dest] = expectedContent;
         } catch {
           continue;
         }
@@ -14848,7 +14892,8 @@ async function checkUpdates(basePath, isGlobal, includeConflicts = false) {
     council: councilHasUpdate,
     policy: policyHasUpdate,
     targets: targetResults,
-    skills: skillResults
+    skills: skillResults,
+    rendered
   };
 }
 var cachedRegistry, registryLoadAttempted = false;
@@ -15617,6 +15662,7 @@ var init_profiles = __esm(() => {
         { id: "implement", agent: "implementer" },
         {
           id: "council-review",
+          agents: ["architect", "product", "delivery", "data-ops", "security-reviewer", "devil"],
           skill: "council",
           outputSchema: "council-verdict"
         }
@@ -16272,6 +16318,8 @@ function resolveAssets(target) {
       return ["AGENTS.md", "rules", "workflows", "skills", "prompts/v1.0.0"];
     case "pi":
       return ["AGENTS.md", "settings.json", "prompts", "skills", "agents", "prompts/v1.0.0"];
+    case "muse":
+      return ["AGENTS.md", "skills", "hooks.json"];
   }
 }
 var CURRENT_PRESET_VERSION = "v1.0.0";
@@ -17206,11 +17254,13 @@ async function verifyRenderedFiles(manifest, baseDir, results) {
     const isTemplateFile = templatePrefixes.some((p) => r.dest === p || r.dest.startsWith(p + sep3));
     if (!isTemplateFile)
       continue;
-    let content;
-    try {
-      content = await readFile12(r.dest, "utf-8");
-    } catch {
-      continue;
+    let content = r.renderedContent;
+    if (content === undefined) {
+      try {
+        content = await readFile12(r.dest, "utf-8");
+      } catch {
+        continue;
+      }
     }
     const leaked = [...new Set(content.match(/\{\{[A-Z_]+\}\}/g) ?? [])];
     if (leaked.length > 0) {
@@ -17834,7 +17884,7 @@ var init_opencode_lsp_generator = __esm(() => {
 
 // src/core/lsp/binary-integrity.ts
 import { createHash as createHash2 } from "node:crypto";
-import { isAbsolute as isAbsolute2, resolve as resolve14, sep as sep4 } from "node:path";
+import { isAbsolute as isAbsolute3, resolve as resolve14, sep as sep4 } from "node:path";
 function assertPinnedBinaryUrl(url) {
   let parsed;
   try {
@@ -17867,7 +17917,7 @@ function assertSha256Hex(content, expectedHex) {
 }
 function resolveSafeArchiveEntry(destRoot, entry) {
   const normalized = entry.replace(/\\/g, "/");
-  if (normalized === "" || isAbsolute2(normalized) || normalized.startsWith("/") || /^[A-Za-z]:\//.test(normalized) || normalized.split("/").includes("..")) {
+  if (normalized === "" || isAbsolute3(normalized) || normalized.startsWith("/") || /^[A-Za-z]:\//.test(normalized) || normalized.split("/").includes("..")) {
     throw new Error(`Unsafe archive entry rejected: ${entry}`);
   }
   const root = resolve14(destRoot);
@@ -18914,17 +18964,31 @@ 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, join as join10, relative as relative5, resolve as resolve16 } from "node:path";
+import { dirname as dirname7, isAbsolute as isAbsolute4, join as join10, 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);
+  const rel = relative5(base, absolute);
+  if (rel === "" || rel === ".." || rel.startsWith(`..${sep5}`) || isAbsolute4(rel)) {
+    throw new Error(`Update destination escapes the base path: ${destination}`);
+  }
+  return rel;
+}
 
 class UpdateTransaction {
   snapshots;
   backupDir;
-  constructor(snapshots, backupDir) {
+  basePath;
+  constructor(snapshots, backupDir, basePath) {
     this.snapshots = snapshots;
     this.backupDir = backupDir;
+    this.basePath = basePath;
   }
   static async begin(basePath, destinations) {
     const unique = [...new Set(destinations)];
+    for (const destination of unique) {
+      assertInsideBase(basePath, destination);
+    }
     const backupDir = resolve16(basePath, ".codeconductor", "backups", `update-${Date.now()}`);
     await mkdir7(backupDir, { recursive: true });
     const snapshots = [];
@@ -18932,7 +18996,7 @@ class UpdateTransaction {
       try {
         const content = await readFile13(destination);
         snapshots.push({ path: destination, existed: true, content });
-        const backupPath = join10(backupDir, relative5(basePath, destination));
+        const backupPath = join10(backupDir, relative5(resolve16(basePath), resolve16(destination)));
         await mkdir7(dirname7(backupPath), { recursive: true });
         await writeFile6(backupPath, content);
       } catch (error) {
@@ -18943,15 +19007,20 @@ class UpdateTransaction {
         }
       }
     }
-    return new UpdateTransaction(snapshots, backupDir);
+    return new UpdateTransaction(snapshots, backupDir, basePath);
   }
   async rollback() {
     for (const snapshot of this.snapshots) {
+      const rel = assertInsideBase(this.basePath, snapshot.path);
+      const gated = await resolveOutputWithinRoot(this.basePath, rel);
+      if (gated === undefined) {
+        throw new Error(`Rollback destination is no longer contained: ${snapshot.path}`);
+      }
       if (snapshot.existed) {
-        await mkdir7(dirname7(snapshot.path), { recursive: true });
-        await writeFile6(snapshot.path, snapshot.content);
+        await mkdir7(dirname7(gated), { recursive: true });
+        await writeFile6(gated, snapshot.content);
       } else {
-        await unlink(snapshot.path).catch((error) => {
+        await unlink(gated).catch((error) => {
           if (error.code !== "ENOENT")
             throw error;
         });
@@ -18963,7 +19032,9 @@ class UpdateTransaction {
     await rm2(this.backupDir, { recursive: true, force: true });
   }
 }
-var init_update_transaction = () => {};
+var init_update_transaction = __esm(() => {
+  init_path_containment();
+});
 
 // src/commands/update.command.ts
 var exports_update_command = {};
@@ -18971,8 +19042,8 @@ __export(exports_update_command, {
   updateCommand: () => updateCommand
 });
 import { homedir as homedir10 } from "node:os";
-import { resolve as resolve17, dirname as dirname8 } from "node:path";
-import { mkdir as mkdir8, readFile as readFile14, writeFile as writeFile7, stat as stat3 } from "node:fs/promises";
+import { join as join11, 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;
   const basePath = isGlobal ? homedir10() : projectRoot;
@@ -19078,24 +19149,20 @@ async function updateCommand(options) {
     ];
     transaction = await UpdateTransaction.begin(basePath, plannedDestinations);
     if (updateResults.council) {
-      const localCouncil = resolve17(basePath, ".codeconductor", "presets", "council.yml");
       const bundledCouncil = resolve17(SRC_PRESETS_DIR, "council", "council.yml");
       try {
         const content = await readFile14(bundledCouncil, "utf-8");
-        await mkdir8(dirname8(localCouncil), { recursive: true });
-        await writeFile7(localCouncil, content, "utf-8");
-        updated.push(localCouncil);
+        const written = await writeContainedFile(basePath, join11(".codeconductor", "presets", "council.yml"), content, { force: true });
+        updated.push(written);
       } catch (e) {
         throw new Error(`Failed to update council.yml: ${e}`);
       }
     }
     if (updateResults.policy) {
-      const localPolicy = resolve17(basePath, ".codeconductor", "presets", "policy.yml");
       try {
         const content = await readFile14(POLICY_PATH, "utf-8");
-        await mkdir8(dirname8(localPolicy), { recursive: true });
-        await writeFile7(localPolicy, content, "utf-8");
-        updated.push(localPolicy);
+        const written = await writeContainedFile(basePath, join11(".codeconductor", "presets", "policy.yml"), content, { force: true });
+        updated.push(written);
       } catch (e) {
         throw new Error(`Failed to update policy.yml: ${e}`);
       }
@@ -19106,7 +19173,7 @@ async function updateCommand(options) {
         const targetName = t.target;
         const manifest = await loadManifest(targetName);
         const modelConfig = await loadModelConfig(targetName);
-        const results = await copyFromManifest(manifest, PRESETS_DIR, basePath, isGlobal, false, force, modelConfig, locale);
+        const results = await copyFromManifest(manifest, PRESETS_DIR, basePath, isGlobal, false, force, modelConfig, locale, updateResults.rendered);
         for (const r of results) {
           if (r.action !== "skipped" && r.action !== "error") {
             updated.push(r.dest);
@@ -19173,20 +19240,19 @@ async function updateCommand(options) {
       for (const s of updateResults.skills) {
         newSkillsLock[s.id] = s.latestVersion;
       }
-      let lockDest = resolve17(basePath, ".codeconductor", "skills-lock.json");
+      let lockRel = join11(".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) {
-            lockDest = resolve17(basePath, ".agents", "skills-lock.json");
+            lockRel = join11(".agents", "skills-lock.json");
           }
         }
       } catch {}
       try {
-        await mkdir8(dirname8(lockDest), { recursive: true });
-        await writeFile7(lockDest, JSON.stringify(newSkillsLock, null, 2), "utf-8");
-        updated.push(lockDest);
+        const written = await writeContainedFile(basePath, lockRel, JSON.stringify(newSkillsLock, null, 2), { force: true });
+        updated.push(written);
       } catch (e) {
         throw new Error(`Failed to write skills-lock.json: ${e}`);
       }
@@ -19233,6 +19299,7 @@ async function updateCommand(options) {
   }
 }
 var init_update_command = __esm(() => {
+  init_path_containment();
   init_config_loader();
   init_update_checker();
   init_file_copier();
@@ -19250,9 +19317,9 @@ __export(exports_migrate_command, {
   migrateCommand: () => migrateCommand,
   migratePermissionRules: () => migratePermissionRules
 });
-import { readFile as readFile15, readdir as readdir3, rm as rm3, writeFile as writeFile8 } from "node:fs/promises";
+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 join11, resolve as resolve18 } from "node:path";
+import { join as join12, resolve as resolve18 } from "node:path";
 function migratePermissionRules(settings) {
   const permissions = settings.permissions;
   if (typeof permissions !== "object" || permissions === null) {
@@ -19299,7 +19366,7 @@ function resolveSettingsPath(options) {
   if (options.file)
     return resolve18(options.projectRoot, options.file);
   const base = options.global ? homedir11() : options.projectRoot;
-  return join11(base, ".claude", "settings.json");
+  return join12(base, ".claude", "settings.json");
 }
 async function findOrphanedPromptVersions(basePath, isGlobal) {
   const found = [];
@@ -19309,7 +19376,7 @@ async function findOrphanedPromptVersions(basePath, isGlobal) {
     if (!installed)
       continue;
     const installPath = getTargetInstallationPath(target, basePath, isGlobal);
-    const promptsDir = join11(installPath, "prompts");
+    const promptsDir = join12(installPath, "prompts");
     if (seenDirs.has(promptsDir))
       continue;
     seenDirs.add(promptsDir);
@@ -19324,7 +19391,7 @@ async function findOrphanedPromptVersions(basePath, isGlobal) {
         continue;
       if (entry.name === CURRENT_PRESET_VERSION)
         continue;
-      found.push({ target, path: join11(promptsDir, entry.name), version: entry.name });
+      found.push({ target, path: join12(promptsDir, entry.name), version: entry.name });
     }
   }
   return found;
@@ -19368,7 +19435,7 @@ async function migrateCommand(options) {
     duplicatesRemoved = migration.duplicatesRemoved;
     settingsChanged = migration.changes.length > 0 || migration.duplicatesRemoved.length > 0;
     if (settingsChanged && !options.dryRun) {
-      await writeFile8(settingsPath, `${JSON.stringify(migration.settings, null, 2)}
+      await writeFile7(settingsPath, `${JSON.stringify(migration.settings, null, 2)}
 `, "utf-8");
     }
   }
@@ -19606,7 +19673,7 @@ __export(exports_help_command, {
   helpCommand: () => helpCommand
 });
 import { readdir as readdir4 } from "node:fs/promises";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 async function scanPresetDir(projectRoot, target) {
   const inventory = {
     target,
@@ -19615,12 +19682,12 @@ async function scanPresetDir(projectRoot, target) {
     agents: [],
     workflows: []
   };
-  const presetDir = join12(projectRoot, "presets", target);
+  const presetDir = join13(projectRoot, "presets", target);
   try {
     const entries = await readdir4(presetDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        const subDir = join12(presetDir, entry.name);
+        const subDir = join13(presetDir, entry.name);
         const subEntries = await readdir4(subDir, { withFileTypes: true });
         for (const sub of subEntries) {
           if (sub.isFile()) {
@@ -19746,14 +19813,14 @@ var exports_debt_harvest_command = {};
 __export(exports_debt_harvest_command, {
   debtHarvestCommand: () => debtHarvestCommand
 });
-import { readdir as readdir5, readFile as readFile16, writeFile as writeFile9, mkdir as mkdir9 } from "node:fs/promises";
-import { join as join13, relative as relative6, extname } from "node:path";
+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";
 async function walkDir(dir, extensions) {
   const results = [];
   try {
     const entries = await readdir5(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join13(dir, entry.name);
+      const fullPath = join14(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name.startsWith(".") || entry.name === "node_modules")
           continue;
@@ -19820,7 +19887,7 @@ function renderLedger(entries) {
 async function debtHarvestCommand(options) {
   const { projectRoot, dir = "src", output } = options;
   try {
-    const targetDir = join13(projectRoot, dir);
+    const targetDir = join14(projectRoot, dir);
     const files = await walkDir(targetDir, SOURCE_EXTENSIONS);
     const allEntries = [];
     for (const file of files) {
@@ -19828,11 +19895,11 @@ async function debtHarvestCommand(options) {
       const entries = extractDefers(content, relative6(projectRoot, file));
       allEntries.push(...entries);
     }
-    const ledgerDir = join13(projectRoot, ".codeconductor");
-    await mkdir9(ledgerDir, { recursive: true });
-    const ledgerPath = join13(ledgerDir, "debt-ledger.md");
+    const ledgerDir = join14(projectRoot, ".codeconductor");
+    await mkdir8(ledgerDir, { recursive: true });
+    const ledgerPath = join14(ledgerDir, "debt-ledger.md");
     const ledgerContent = renderLedger(allEntries);
-    await writeFile9(ledgerPath, ledgerContent, "utf-8");
+    await writeFile8(ledgerPath, ledgerContent, "utf-8");
     if (output === "json") {
       return {
         code: 0,
@@ -20265,27 +20332,27 @@ var init_goal_planner = __esm(() => {
 });
 
 // src/core/product-graph/paths.ts
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 function productGraphPath(projectRoot) {
-  return join14(projectRoot, PRODUCT_DIR, PRODUCT_GRAPH_FILE);
+  return join15(projectRoot, PRODUCT_DIR, PRODUCT_GRAPH_FILE);
 }
 function productMetaPath(projectRoot) {
-  return join14(projectRoot, PRODUCT_DIR, PRODUCT_META_FILE);
+  return join15(projectRoot, PRODUCT_DIR, PRODUCT_META_FILE);
 }
 function eventsPath(projectRoot) {
-  return join14(projectRoot, PRODUCT_DIR, EVENTS_FILE);
+  return join15(projectRoot, PRODUCT_DIR, EVENTS_FILE);
 }
 function operationalStatePath(projectRoot) {
-  return join14(projectRoot, PRODUCT_DIR, OPERATIONAL_STATE_FILE);
+  return join15(projectRoot, PRODUCT_DIR, OPERATIONAL_STATE_FILE);
 }
 function strategicPath(projectRoot) {
-  return join14(projectRoot, PRODUCT_DIR, STRATEGIC_FILE);
+  return join15(projectRoot, PRODUCT_DIR, STRATEGIC_FILE);
 }
 function productReportPath(projectRoot) {
-  return join14(projectRoot, PRODUCT_DIR, PRODUCT_REPORT_FILE);
+  return join15(projectRoot, PRODUCT_DIR, PRODUCT_REPORT_FILE);
 }
 function evidenceDir(projectRoot) {
-  return join14(projectRoot, PRODUCT_DIR, EVIDENCE_DIR);
+  return join15(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 = () => {};
@@ -20302,8 +20369,8 @@ __export(exports_graph_store, {
   saveGraph: () => saveGraph,
   upsertNode: () => upsertNode
 });
-import { mkdir as mkdir10, readFile as readFile17, writeFile as writeFile10 } from "node:fs/promises";
-import { dirname as dirname9 } from "node:path";
+import { mkdir as mkdir9, readFile as readFile17, writeFile as writeFile9 } from "node:fs/promises";
+import { dirname as dirname8 } from "node:path";
 async function loadGraph(projectRoot) {
   try {
     const raw = await readFile17(productGraphPath(projectRoot), "utf-8");
@@ -20319,8 +20386,8 @@ async function saveGraph(projectRoot, graph) {
   try {
     const validated = ProductGraphSchema.parse(graph);
     const path = productGraphPath(projectRoot);
-    await mkdir10(dirname9(path), { recursive: true });
-    await writeFile10(path, JSON.stringify(validated, null, 2), "utf-8");
+    await mkdir9(dirname8(path), { recursive: true });
+    await writeFile9(path, JSON.stringify(validated, null, 2), "utf-8");
     return ok(undefined);
   } catch (e) {
     return err(e instanceof Error ? e : new Error(String(e)));
@@ -20488,7 +20555,7 @@ __export(exports_goal_state, {
   markTaskBlocked: () => markTaskBlocked,
   writeGoal: () => writeGoal
 });
-import { mkdir as mkdir11, readFile as readFile18, writeFile as writeFile11 } from "node:fs/promises";
+import { mkdir as mkdir10, readFile as readFile18, writeFile as writeFile10 } from "node:fs/promises";
 import { resolve as resolve19 } from "node:path";
 function validateGoalGraph2(graph) {
   const ids = new Set(graph.tasks.map((t) => t.id));
@@ -20533,9 +20600,9 @@ async function writeGoal(projectRoot, graph) {
   if (!validation.success)
     return validation;
   const dir = resolve19(projectRoot, ".codeconductor");
-  await mkdir11(dir, { recursive: true });
+  await mkdir10(dir, { recursive: true });
   const yaml = $stringify(graph);
-  await writeFile11(resolve19(dir, "current-goal.yml"), yaml, "utf-8");
+  await writeFile10(resolve19(dir, "current-goal.yml"), yaml, "utf-8");
   return ok(undefined);
 }
 async function loadGoal(projectRoot) {
@@ -20929,7 +20996,7 @@ function slugify(text) {
 
 // src/core/knowledge/source-parsers.ts
 import { readFile as readFile20 } from "node:fs/promises";
-import { basename as basename6, join as join15, relative as relative7, sep as sep5 } from "node:path";
+import { basename as basename6, join as join16, relative as relative7, sep as sep6 } from "node:path";
 async function parseAdrFile(filePath) {
   try {
     const content = await readFile20(filePath, "utf-8");
@@ -20981,7 +21048,7 @@ function adrToEntities(adr, source) {
 }
 async function parseReadmeEntities(projectRoot, productName) {
   try {
-    const content = await readFile20(join15(projectRoot, "README.md"), "utf-8");
+    const content = await readFile20(join16(projectRoot, "README.md"), "utf-8");
     const firstPara = content.split(`
 
 `).find((p) => p.trim() && !p.startsWith("#") && !p.startsWith(">")) ?? "";
@@ -21002,7 +21069,7 @@ async function parseReadmeEntities(projectRoot, productName) {
 }
 async function parseGraphifyEntities(projectRoot) {
   try {
-    const raw = await readFile20(join15(projectRoot, "graphify-out", "graph.json"), "utf-8");
+    const raw = await readFile20(join16(projectRoot, "graphify-out", "graph.json"), "utf-8");
     const graph = JSON.parse(raw);
     const entities = [];
     for (const node2 of graph.nodes ?? []) {
@@ -21026,14 +21093,14 @@ async function parseGraphifyEntities(projectRoot) {
 async function scanSrcComponents(projectRoot) {
   const { readdir: readdir6 } = await import("node:fs/promises");
   const entities = [];
-  const srcDir = join15(projectRoot, "src");
+  const srcDir = join16(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 = join15(dir, entry.name);
+        const full = join16(dir, entry.name);
         if (entry.isDirectory()) {
           if (entry.name === "node_modules")
             continue;
@@ -21045,7 +21112,7 @@ async function scanSrcComponents(projectRoot) {
             source: "src/",
             confidence: "medium",
             relations: [],
-            data: { path: relative7(projectRoot, full).split(sep5).join("/") }
+            data: { path: relative7(projectRoot, full).split(sep6).join("/") }
           });
           await walk(full, prefix ? `${prefix}-${domainSlug}` : domainSlug);
         }
@@ -21058,7 +21125,7 @@ async function scanSrcComponents(projectRoot) {
 var init_source_parsers = () => {};
 
 // src/core/memory/episodic-store.ts
-import { appendFile, mkdir as mkdir12, readFile as readFile21 } from "node:fs/promises";
+import { appendFile, mkdir as mkdir11, readFile as readFile21 } from "node:fs/promises";
 import { resolve as resolve21 } from "node:path";
 async function appendEvent(projectRoot, event) {
   try {
@@ -21067,7 +21134,7 @@ async function appendEvent(projectRoot, event) {
       id: event.id ?? `evt-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
     });
     const path = eventsPath(projectRoot);
-    await mkdir12(resolve21(projectRoot, ".codeconductor"), { recursive: true });
+    await mkdir11(resolve21(projectRoot, ".codeconductor"), { recursive: true });
     await appendFile(path, JSON.stringify(full) + `
 `, "utf-8");
     return ok(full);
@@ -21106,8 +21173,8 @@ 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 join16, relative as relative8, sep as sep6 } from "node:path";
-import { mkdir as mkdir13, writeFile as writeFile12 } from "node:fs/promises";
+import { join as join17, 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)
     return [];
@@ -21142,7 +21209,7 @@ async function collectDeferRisks(projectRoot) {
       for (const entry of entries) {
         if (entry.name.startsWith(".") || entry.name === "node_modules")
           continue;
-        const full = join16(dir, entry.name);
+        const full = join17(dir, entry.name);
         if (entry.isDirectory()) {
           await walk(full);
         } else if (entry.name.endsWith(".ts")) {
@@ -21151,11 +21218,11 @@ async function collectDeferRisks(projectRoot) {
       }
     } catch {}
   }
-  await walk(join16(projectRoot, "src"));
+  await walk(join17(projectRoot, "src"));
   const perFile = await mapLimit(files, WALK_READ_CONCURRENCY, async (full) => {
     const entities = [];
     const content = await readFile22(full, "utf-8");
-    const rel = relative8(projectRoot, full).split(sep6).join("/");
+    const rel = relative8(projectRoot, full).split(sep7).join("/");
     const deferRe = new RegExp(DEFER_REGEX_SOURCE, "gm");
     let match;
     while ((match = deferRe.exec(content)) !== null) {
@@ -21214,12 +21281,12 @@ async function parseBacklogEntities(projectRoot) {
 }
 async function parseAdrEntities(projectRoot) {
   const { readdir: readdir6 } = await import("node:fs/promises");
-  const adrDir = join16(projectRoot, "docs", "adr");
+  const adrDir = join17(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(join16(adrDir, file));
+      const adr = await parseAdrFile(join17(adrDir, file));
       return adr ? adrToEntities(adr, `docs/adr/${file}`) : [];
     }));
     entities.push(...parsed.flat());
@@ -21311,7 +21378,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(join16(projectRoot, src));
+    const h = await hashFile(join17(projectRoot, src));
     if (h)
       sourceHashes[src] = h;
   }
@@ -21321,8 +21388,8 @@ async function runIngest(projectRoot, productName) {
     lastIngestAt: new Date().toISOString(),
     sourceHashes
   };
-  await mkdir13(join16(projectRoot, ".codeconductor"), { recursive: true });
-  await writeFile12(productMetaPath(projectRoot), JSON.stringify(ProductMetaSchema.parse(meta), null, 2), "utf-8");
+  await mkdir12(join17(projectRoot, ".codeconductor"), { recursive: true });
+  await writeFile11(productMetaPath(projectRoot), JSON.stringify(ProductMetaSchema.parse(meta), null, 2), "utf-8");
   await appendEvent(projectRoot, {
     type: "ingest.completed",
     timestamp: new Date().toISOString(),
@@ -21403,7 +21470,7 @@ var init_ingest_command = __esm(() => {
 });
 
 // src/core/memory/operational-state.ts
-import { mkdir as mkdir14, readFile as readFile23, writeFile as writeFile13 } from "node:fs/promises";
+import { mkdir as mkdir13, readFile as readFile23, writeFile as writeFile12 } from "node:fs/promises";
 import { resolve as resolve22 } from "node:path";
 async function loadOperationalState(projectRoot) {
   try {
@@ -21429,8 +21496,8 @@ async function saveOperationalState(projectRoot, state) {
       updatedAt: new Date().toISOString()
     });
     const path = operationalStatePath(projectRoot);
-    await mkdir14(resolve22(projectRoot, ".codeconductor"), { recursive: true });
-    await writeFile13(path, JSON.stringify(validated, null, 2), "utf-8");
+    await mkdir13(resolve22(projectRoot, ".codeconductor"), { recursive: true });
+    await writeFile12(path, JSON.stringify(validated, null, 2), "utf-8");
     return ok(undefined);
   } catch (e) {
     return err(e instanceof Error ? e : new Error(String(e)));
@@ -21464,7 +21531,7 @@ var init_operational_state = __esm(() => {
 });
 
 // src/core/memory/strategic-memory.ts
-import { mkdir as mkdir15, readFile as readFile24, writeFile as writeFile14 } from "node:fs/promises";
+import { mkdir as mkdir14, readFile as readFile24, writeFile as writeFile13 } from "node:fs/promises";
 import { resolve as resolve23 } from "node:path";
 async function loadStrategicMemory(projectRoot) {
   try {
@@ -21489,8 +21556,8 @@ async function saveStrategicMemory(projectRoot, memory) {
       updatedAt: new Date().toISOString()
     });
     const path = strategicPath(projectRoot);
-    await mkdir15(resolve23(projectRoot, ".codeconductor"), { recursive: true });
-    await writeFile14(path, JSON.stringify(validated, null, 2), "utf-8");
+    await mkdir14(resolve23(projectRoot, ".codeconductor"), { recursive: true });
+    await writeFile13(path, JSON.stringify(validated, null, 2), "utf-8");
     return ok(undefined);
   } catch (e) {
     return err(e instanceof Error ? e : new Error(String(e)));
@@ -21502,7 +21569,7 @@ var init_strategic_memory = __esm(() => {
 });
 
 // src/core/memory/memory-index.ts
-import { mkdir as mkdir16, readFile as readFile25, writeFile as writeFile15 } from "node:fs/promises";
+import { mkdir as mkdir15, readFile as readFile25, writeFile as writeFile14 } from "node:fs/promises";
 import { resolve as resolve24 } from "node:path";
 function parseMarkdown(content) {
   const startIdx = content.indexOf(SENTINEL_START);
@@ -21540,12 +21607,12 @@ var init_memory_index = __esm(() => {
 });
 
 // src/core/evaluation/outcome-store.ts
-import { appendFile as appendFile2, mkdir as mkdir17, readFile as readFile26, readdir as readdir6, writeFile as writeFile16 } from "node:fs/promises";
+import { appendFile as appendFile2, mkdir as mkdir16, readFile as readFile26, readdir as readdir6, writeFile as writeFile15 } from "node:fs/promises";
 import { resolve as resolve25 } from "node:path";
 async function ensureEvaluationDir(projectRoot) {
   const dir = resolve25(projectRoot, EVAL_DIR);
-  await mkdir17(dir, { recursive: true });
-  await mkdir17(resolve25(dir, SCORECARDS_DIR), { recursive: true });
+  await mkdir16(dir, { recursive: true });
+  await mkdir16(resolve25(dir, SCORECARDS_DIR), { recursive: true });
   return dir;
 }
 async function appendOutcome(projectRoot, outcome) {
@@ -21561,7 +21628,7 @@ async function appendOutcome(projectRoot, outcome) {
       index = EvaluationIndexSchema.parse(JSON.parse(raw));
       index.lastOutcomeId = validated.id;
     } catch {}
-    await writeFile16(indexPath, JSON.stringify(index, null, 2), "utf-8");
+    await writeFile15(indexPath, JSON.stringify(index, null, 2), "utf-8");
     return ok(undefined);
   } catch (e) {
     return err(e instanceof Error ? e : new Error(String(e)));
@@ -21609,7 +21676,7 @@ async function saveScorecard(projectRoot, record) {
     const dir = await ensureEvaluationDir(projectRoot);
     const validated = ScorecardRecordSchema.parse(record);
     const filePath = resolve25(dir, SCORECARDS_DIR, `${validated.id}.json`);
-    await writeFile16(filePath, JSON.stringify(validated, null, 2), "utf-8");
+    await writeFile15(filePath, JSON.stringify(validated, null, 2), "utf-8");
     return ok(filePath);
   } catch (e) {
     return err(e instanceof Error ? e : new Error(String(e)));
@@ -21746,10 +21813,10 @@ var init_outcome_store = __esm(() => {
 
 // src/core/feedback/feedback-ingestor.ts
 import { readFile as readFile27 } from "node:fs/promises";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 async function parseChangelogLearnings(projectRoot) {
   try {
-    const content = await readFile27(join17(projectRoot, "CHANGELOG.md"), "utf-8");
+    const content = await readFile27(join18(projectRoot, "CHANGELOG.md"), "utf-8");
     const unreleased = content.match(/## \[Unreleased\]([\s\S]*?)(?=## \[|\n## )/i);
     if (!unreleased)
       return [];
@@ -21869,7 +21936,7 @@ var exports_product_command = {};
 __export(exports_product_command, {
   productCommand: () => productCommand
 });
-import { writeFile as writeFile17 } from "node:fs/promises";
+import { writeFile as writeFile16 } from "node:fs/promises";
 async function productCommand(options) {
   const { subcommand, projectRoot, output, query, from, to, since, format } = options;
   try {
@@ -22072,7 +22139,7 @@ async function handleExport(projectRoot, format, output) {
     ...queryNodes(graph.data, "risk").map((n) => `- ${n.name}`)
   ].join(`
 `);
-  await writeFile17(productReportPath(projectRoot), md, "utf-8");
+  await writeFile16(productReportPath(projectRoot), md, "utf-8");
   return {
     code: 0,
     data: {
@@ -22354,21 +22421,21 @@ __export(exports_rdd_receipt, {
 });
 import { createHash as createHash4 } from "node:crypto";
 import { readdir as readdir7, readFile as readFile28 } from "node:fs/promises";
-import { join as join18, relative as relative9, resolve as resolve26, sep as sep7 } from "node:path";
+import { join as join19, relative as relative9, resolve as resolve26, sep as sep8 } from "node:path";
 function sha2562(content) {
   return createHash4("sha256").update(content).digest("hex");
 }
 function canonicalPath(projectRoot, input) {
   const root = resolve26(projectRoot);
   const absolute = resolve26(root, input);
-  if (absolute !== root && !absolute.startsWith(`${root}${sep7}`)) {
+  if (absolute !== root && !absolute.startsWith(`${root}${sep8}`)) {
     throw new Error(`RDD receipt path "${input}" is outside the project root`);
   }
   const normalized = relative9(root, absolute);
   if (!normalized || normalized === ".") {
     throw new Error("RDD receipts require file paths, not the project root");
   }
-  return { absolute, relative: normalized.split(sep7).join("/") };
+  return { absolute, relative: normalized.split(sep8).join("/") };
 }
 async function fingerprint(projectRoot, paths) {
   const deduplicated = new Map;
@@ -22419,11 +22486,11 @@ async function collectReceiptPaths(projectRoot) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (!EXCLUDED_DIRECTORIES.has(entry.name))
-          await visit2(join18(current, entry.name));
+          await visit2(join19(current, entry.name));
         continue;
       }
       if (entry.isFile())
-        paths.push(relative9(root, join18(current, entry.name)).split(sep7).join("/"));
+        paths.push(relative9(root, join19(current, entry.name)).split(sep8).join("/"));
     }
   }
   await visit2(root);
@@ -22476,8 +22543,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 dirname10, join as join19, resolve as resolve27 } from "node:path";
-import { mkdir as mkdir18, readdir as readdir8, writeFile as writeFile18 } 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";
 function isPassingEvidence(ev) {
   switch (ev.type) {
     case "verification":
@@ -22504,7 +22571,7 @@ async function isCurrentPassingEvidence(projectRoot, ev) {
 }
 function evidenceFilePath(evDir, id) {
   const path = resolve27(evDir, `${id.replace(/[^A-Za-z0-9_-]/g, "_")}.json`);
-  if (dirname10(path) !== resolve27(evDir)) {
+  if (dirname9(path) !== resolve27(evDir)) {
     return err(new Error(`Refusing to write evidence for "${id}" outside ${evDir}`));
   }
   return ok(path);
@@ -22515,8 +22582,8 @@ async function persistEvidence(projectRoot, evidence) {
   if (!evidencePath.success)
     return evidencePath;
   try {
-    await mkdir18(evDir, { recursive: true });
-    await writeFile18(evidencePath.data, JSON.stringify(evidence, null, 2), "utf-8");
+    await mkdir17(evDir, { recursive: true });
+    await writeFile17(evidencePath.data, JSON.stringify(evidence, null, 2), "utf-8");
   } catch (e) {
     return err(e instanceof Error ? e : new Error(String(e)));
   }
@@ -22538,7 +22605,7 @@ async function collectTaskEvidence(projectRoot, taskId) {
     if (!file.endsWith(".json"))
       continue;
     try {
-      const raw = await readFile29(join19(evDir, file), "utf-8");
+      const raw = await readFile29(join20(evDir, file), "utf-8");
       const ev = EvidenceSchema.parse(JSON.parse(raw));
       if (ev.relatedTask === taskId)
         records.push(ev);
@@ -23917,13 +23984,13 @@ __export(exports_rdd_command, {
 });
 import { execFile as execFile4 } from "node:child_process";
 import { existsSync as existsSync4 } from "node:fs";
-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 { 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 { 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 (dirname11(path) !== directory)
+  if (dirname10(path) !== directory)
     throw new Error(`Invalid RDD receipt id: ${id}`);
   return path;
 }
@@ -23971,7 +24038,7 @@ async function installHooks(projectRoot) {
     encoding: "utf8"
   });
   const hooksDir = resolve28(projectRoot, stdout.trim());
-  await mkdir19(hooksDir, { recursive: true });
+  await mkdir18(hooksDir, { recursive: true });
   const installed = [];
   const skipped = [];
   for (const hook of ["pre-commit", "pre-push"]) {
@@ -23998,7 +24065,7 @@ if [ -x "$HOOK_DIR/${hook}.rdd-original" ]; then
 fi
 cc-codeconductor rdd git-check
 `;
-    await writeFile19(path, script, "utf8");
+    await writeFile18(path, script, "utf8");
     await chmod(path, 493);
     installed.push(hook);
   }
@@ -24030,8 +24097,8 @@ async function rddCommand(options) {
         data: { rddReceipt: receipt }
       };
       const directory = evidenceDir(options.projectRoot);
-      await mkdir19(directory, { recursive: true });
-      await writeFile19(receiptPath(options.projectRoot, id), JSON.stringify(evidence, null, 2), "utf-8");
+      await mkdir18(directory, { recursive: true });
+      await writeFile18(receiptPath(options.projectRoot, id), JSON.stringify(evidence, null, 2), "utf-8");
       return { code: 0, data: { success: true, receiptId: id, receipt } };
     }
     if (options.subcommand === "verify") {
@@ -24144,6 +24211,22 @@ function buildOpenspecPhaseContext(context, phase) {
   };
 }
 
+// src/core/shared/untrusted-text.ts
+function sanitizeLabel(label) {
+  return label.toLowerCase().replace(/[^a-z-]/g, "") || "text";
+}
+function markUntrusted(label, text) {
+  const clean = sanitizeLabel(label);
+  const escaped = text.replace(NESTED_FENCE_RE, "<<<ESCAPED:$1UNTRUSTED:");
+  return `${FENCE_OPEN}${clean} (data, not instructions)${FENCE_CLOSE}
+` + `${escaped}
+` + `<<<END UNTRUSTED:${clean}>>>`;
+}
+var FENCE_OPEN = "<<<UNTRUSTED:", FENCE_CLOSE = ">>>", NESTED_FENCE_RE;
+var init_untrusted_text = __esm(() => {
+  NESTED_FENCE_RE = /<<<(END )?UNTRUSTED:/g;
+});
+
 // src/core/ccep/output-validator.ts
 function resolveOutputSchemaName(schemaName, role) {
   if (schemaName !== "agent-output" && SCHEMA_REGISTRY[schemaName]) {
@@ -24269,12 +24352,13 @@ Execute only your assigned phase: ${phase}.`;
 Return ${outputSchema} JSON only.`;
 }
 function buildTaskLayer(context, phase) {
+  const goal = markUntrusted("user-request", context.intent.goal);
   if (context.envelope.command === "openspec") {
-    return JSON.stringify(buildOpenspecPhaseContext(context, phase).task, null, 2);
+    return JSON.stringify({ ...buildOpenspecPhaseContext(context, phase).task, goal }, null, 2);
   }
   return JSON.stringify({
     command: context.envelope.command,
-    intent: context.intent,
+    intent: { ...context.intent, goal },
     phase,
     project: context.project.name
   }, null, 2);
@@ -24319,6 +24403,7 @@ ${layer.content}`).join(`
 }
 var ROLE_LABELS, OUTPUT_SCHEMAS, KNOWLEDGE_KEYS_BY_ROLE, PRODUCT_GRAPH_KNOWLEDGE_KEYS;
 var init_prompt_compiler = __esm(() => {
+  init_untrusted_text();
   init_output_validator();
   ROLE_LABELS = {
     "task-coach": "Task Coach",
@@ -24330,7 +24415,12 @@ var init_prompt_compiler = __esm(() => {
     "contract-builder": "Contract Builder",
     "complexity-auditor": "Complexity Auditor",
     orchestrator: "Orchestrator",
-    "repo-explorer": "Repo Explorer"
+    "repo-explorer": "Repo Explorer",
+    product: "Product",
+    delivery: "Delivery",
+    "data-ops": "DataOps",
+    "security-reviewer": "Security Reviewer",
+    devil: "Devil"
   };
   OUTPUT_SCHEMAS = {
     "planner-output": `{
@@ -24403,7 +24493,12 @@ var init_prompt_compiler = __esm(() => {
     "contract-builder": ["productName", "domains", "decisions", "requirements"],
     "complexity-auditor": ["productName", "decisions", "requirements", "risks"],
     orchestrator: ["productName", "domains", "decisions", "requirements", "risks"],
-    "repo-explorer": ["productName", "domains", "requirements"]
+    "repo-explorer": ["productName", "domains", "requirements"],
+    product: ["productName", "requirements"],
+    delivery: ["productName", "requirements", "risks"],
+    "data-ops": ["productName", "domains", "requirements"],
+    "security-reviewer": ["productName", "decisions", "requirements", "risks"],
+    devil: ["decisions", "requirements", "risks"]
   };
   PRODUCT_GRAPH_KNOWLEDGE_KEYS = new Set([
     "productName",
@@ -24417,9 +24512,9 @@ 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 join20 } from "node:path";
+import { basename as basename7, join as join21 } from "node:path";
 function readProjectId(projectRoot) {
-  const packageJsonPath = join20(projectRoot, "package.json");
+  const packageJsonPath = join21(projectRoot, "package.json");
   if (existsSync5(packageJsonPath)) {
     try {
       const pkg = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
@@ -24449,7 +24544,7 @@ function parseCommand(command, userRequest, projectRoot) {
       maxVariance: "low"
     }
   };
-  const packageJsonPath = join20(projectRoot, "package.json");
+  const packageJsonPath = join21(projectRoot, "package.json");
   if (existsSync5(packageJsonPath)) {
     try {
       const pkg = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
@@ -24505,9 +24600,9 @@ function resolveWorkflowPhase(profile, phaseId) {
   if (!phase) {
     return null;
   }
-  const role = phase.agent ?? phase.agents?.[0] ?? "orchestrator";
+  const roles = phase.agent !== undefined ? [phase.agent] : phase.agents !== undefined && phase.agents.length > 0 ? [...phase.agents] : ["orchestrator"];
   const outputSchema = phase.outputSchema ?? profile.intakeSchema ?? "agent-output";
-  return { id: phase.id, role, outputSchema };
+  return { id: phase.id, role: roles[0], roles, outputSchema };
 }
 function loadWorkflowProfile(command, projectRoot) {
   const fromYaml = loadWorkflowProfileFromYaml(command, projectRoot);
@@ -24524,8 +24619,8 @@ 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 mkdir20, readFile as readFile31, readdir as readdir10, rm as rm4, writeFile as writeFile20 } from "node:fs/promises";
-import { dirname as dirname12, join as join21, resolve as resolve29 } from "node:path";
+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";
 function catalogIds(catalog = DEFAULT_HARNESS_CATALOG) {
   return catalog.components.map((c) => c.id);
 }
@@ -24648,22 +24743,22 @@ async function restoreOverlayBackup(projectRoot) {
   const backupRoot = resolve29(projectRoot, EVAL_DIR2, OVERLAY_BACKUP_DIR);
   if (!existsSync6(backupRoot))
     return;
-  const configBackup = join21(backupRoot, "config.yml");
+  const configBackup = join22(backupRoot, "config.yml");
   const configDest = resolve29(projectRoot, ".codeconductor", "config.yml");
   if (existsSync6(configBackup)) {
-    await mkdir20(dirname12(configDest), { recursive: true });
+    await mkdir19(dirname11(configDest), { recursive: true });
     await copyFile2(configBackup, configDest);
   }
-  const workflowsBackup = join21(backupRoot, "workflows");
+  const workflowsBackup = join22(backupRoot, "workflows");
   const workflowsDest = resolve29(projectRoot, ".codeconductor", "workflows");
   if (existsSync6(workflowsBackup)) {
-    await mkdir20(workflowsDest, { recursive: true });
+    await mkdir19(workflowsDest, { recursive: true });
     const files = await readdir10(workflowsBackup);
     for (const file of files) {
-      await copyFile2(join21(workflowsBackup, file), join21(workflowsDest, file));
+      await copyFile2(join22(workflowsBackup, file), join22(workflowsDest, file));
     }
   }
-  const overlayBackup = join21(backupRoot, ACTIVE_OVERLAY_FILE);
+  const overlayBackup = join22(backupRoot, ACTIVE_OVERLAY_FILE);
   const overlayDest = activeOverlayPath(projectRoot);
   if (existsSync6(overlayBackup)) {
     await copyFile2(overlayBackup, overlayDest);
@@ -24675,25 +24770,25 @@ async function snapshotForBackup(projectRoot) {
   const backupRoot = resolve29(projectRoot, EVAL_DIR2, OVERLAY_BACKUP_DIR);
   if (existsSync6(backupRoot))
     return;
-  await mkdir20(backupRoot, { recursive: true });
+  await mkdir19(backupRoot, { recursive: true });
   const configPath = resolve29(projectRoot, ".codeconductor", "config.yml");
   if (existsSync6(configPath)) {
-    await copyFile2(configPath, join21(backupRoot, "config.yml"));
+    await copyFile2(configPath, join22(backupRoot, "config.yml"));
   }
   const workflowsDir = resolve29(projectRoot, ".codeconductor", "workflows");
   if (existsSync6(workflowsDir)) {
-    const dest = join21(backupRoot, "workflows");
-    await mkdir20(dest, { recursive: true });
+    const dest = join22(backupRoot, "workflows");
+    await mkdir19(dest, { recursive: true });
     const files = await readdir10(workflowsDir);
     for (const file of files) {
       if (file.endsWith(".yml")) {
-        await copyFile2(join21(workflowsDir, file), join21(dest, file));
+        await copyFile2(join22(workflowsDir, file), join22(dest, file));
       }
     }
   }
   const overlay = activeOverlayPath(projectRoot);
   if (existsSync6(overlay)) {
-    await copyFile2(overlay, join21(backupRoot, ACTIVE_OVERLAY_FILE));
+    await copyFile2(overlay, join22(backupRoot, ACTIVE_OVERLAY_FILE));
   }
 }
 async function applyHarnessOverlay(projectRoot, disabled, options = {}) {
@@ -24703,12 +24798,12 @@ async function applyHarnessOverlay(projectRoot, disabled, options = {}) {
       await snapshotForBackup(projectRoot);
     }
     const workflowsDir = resolve29(projectRoot, ".codeconductor", "workflows");
-    await mkdir20(workflowsDir, { recursive: true });
-    await mkdir20(resolve29(projectRoot, EVAL_DIR2), { recursive: true });
+    await mkdir19(workflowsDir, { recursive: true });
+    await mkdir19(resolve29(projectRoot, EVAL_DIR2), { recursive: true });
     for (const command of WORKFLOW_OVERLAY_COMMANDS) {
       const base = loadWorkflowProfile(command);
       const next = applyCatalogToProfile(base, disabled);
-      await writeFile20(join21(workflowsDir, `${command}.yml`), $stringify(next), "utf-8");
+      await writeFile19(join22(workflowsDir, `${command}.yml`), $stringify(next), "utf-8");
     }
     const needsConfig = disabled.includes("compile_loop") || disabled.includes("council");
     if (needsConfig) {
@@ -24736,7 +24831,7 @@ async function applyHarnessOverlay(projectRoot, disabled, options = {}) {
       contractVersion: options.contractVersion,
       ccepProfile: options.ccepProfile ?? "feature"
     });
-    await writeFile20(activeOverlayPath(projectRoot), $stringify(overlay), "utf-8");
+    await writeFile19(activeOverlayPath(projectRoot), $stringify(overlay), "utf-8");
     return ok(overlay);
   } catch (e) {
     return err(e instanceof Error ? e : new Error(String(e)));
@@ -24848,7 +24943,7 @@ var init_harness_catalog = __esm(() => {
 
 // src/core/openspec/openspec-state.ts
 import { createHash as createHash6 } from "node:crypto";
-import { mkdir as mkdir21, readFile as readFile32, rename as rename4, writeFile as writeFile21 } from "node:fs/promises";
+import { mkdir as mkdir20, readFile as readFile32, rename as rename4, writeFile as writeFile20 } from "node:fs/promises";
 import { resolve as resolve30 } from "node:path";
 function canTransition(from, to) {
   return ALLOWED_TRANSITIONS[from]?.includes(to) ?? false;
@@ -24870,7 +24965,7 @@ function applyBacklogTransition(content, itemId, from, to, progress) {
 }
 async function writeFileAtomic(path, content) {
   const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
-  await writeFile21(tmp, content, "utf-8");
+  await writeFile20(tmp, content, "utf-8");
   await rename4(tmp, path);
 }
 async function loadOpenspecState(projectRoot) {
@@ -24894,7 +24989,7 @@ async function loadOpenspecState(projectRoot) {
 async function writeOpenspecState(projectRoot, state) {
   try {
     const dir = resolve30(projectRoot, ".codeconductor");
-    await mkdir21(dir, { recursive: true });
+    await mkdir20(dir, { recursive: true });
     const validated = OpenspecStateSchema.parse(state);
     await writeFileAtomic(resolve30(dir, "openspec-state.json"), JSON.stringify(validated, null, 2));
     return ok(undefined);
@@ -25002,7 +25097,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 join22 } from "node:path";
+import { join as join23 } from "node:path";
 async function loadProductKnowledge(projectRoot) {
   if (isProductGraphDisabled(projectRoot)) {
     return {};
@@ -25028,7 +25123,7 @@ async function loadProductKnowledge(projectRoot) {
 }
 async function resolveAstSource(projectRoot) {
   if (isProductGraphDisabled(projectRoot)) {
-    const graphifyPath2 = join22(projectRoot, "graphify-out", "graph.json");
+    const graphifyPath2 = join23(projectRoot, "graphify-out", "graph.json");
     if (existsSync7(graphifyPath2)) {
       return { source: "graphify", confidence: "medium" };
     }
@@ -25038,7 +25133,7 @@ async function resolveAstSource(projectRoot) {
   if (existsSync7(graphPath)) {
     return { source: "product-graph", confidence: "high" };
   }
-  const graphifyPath = join22(projectRoot, "graphify-out", "graph.json");
+  const graphifyPath = join23(projectRoot, "graphify-out", "graph.json");
   if (existsSync7(graphifyPath)) {
     return { source: "graphify", confidence: "medium" };
   }
@@ -25114,6 +25209,9 @@ function canonicalAgentId(agentId) {
 function isSecurityCategory(category) {
   return SECURITY_CATEGORIES.has(category.trim().toLowerCase());
 }
+function isSecurityEmitter(agentId) {
+  return canonicalAgentId(agentId).includes("security");
+}
 function resolveQuorum(config, ballotCount) {
   if (typeof config.quorum === "number") {
     const required = Math.max(1, config.quorum);
@@ -25238,7 +25336,7 @@ function councilConsensus(verdicts, config = DEFAULT_CONFIG2) {
     if (confidence < 0.6) {
       hasLowConfidence = true;
     }
-    if (config.allowSecurityVeto && v.securityVeto && v.status === "REJECTED") {
+    if (config.allowSecurityVeto && v.securityVeto && v.status === "REJECTED" && isSecurityEmitter(v.agentId)) {
       vetoApplied = true;
       vetoByAgentId = v.agentId;
     }
@@ -25248,7 +25346,7 @@ function councilConsensus(verdicts, config = DEFAULT_CONFIG2) {
     }
     for (const finding of v.findings) {
       allFindings.push(finding);
-      if (config.allowSecurityVeto && finding.severity === "critical" && isSecurityCategory(finding.category)) {
+      if (config.allowSecurityVeto && finding.severity === "critical" && isSecurityCategory(finding.category) && isSecurityEmitter(v.agentId)) {
         vetoApplied = true;
         vetoByAgentId = v.agentId;
       }
@@ -25387,6 +25485,148 @@ var init_council_consensus = __esm(() => {
   ]);
 });
 
+// src/domain/council/council-spec.ts
+function defaultCouncilSpec() {
+  return {
+    name: "council",
+    version: "0.1.0",
+    description: "Multi-agent council",
+    outputContract: "v1",
+    agents: DEFAULT_COUNCIL_AGENTS
+  };
+}
+function hasSecurityFocusedAgent(spec) {
+  return spec.agents.some((agent) => {
+    const haystack = [agent.id, agent.role, ...agent.focus].join(" ").toLowerCase();
+    return SECURITY_HINTS.some((hint) => haystack.includes(hint));
+  });
+}
+function deriveConsensusConfig(spec, overrides = {}) {
+  const expectedAgentIds = overrides.expectedAgentIds ?? spec.agents.map((agent) => agent.id);
+  const allowSecurityVeto = overrides.allowSecurityVeto ?? true;
+  if (allowSecurityVeto && !hasSecurityFocusedAgent(spec)) {
+    throw new Error("allowSecurityVeto requires at least one security-focused agent in the council roster");
+  }
+  return {
+    algorithm: overrides.algorithm ?? "majority",
+    allowSecurityVeto,
+    allowComplianceVeto: overrides.allowComplianceVeto ?? true,
+    expectedAgentIds,
+    quorum: overrides.quorum ?? Math.ceil(expectedAgentIds.length / 2),
+    criticalFindingsPolicy: overrides.criticalFindingsPolicy ?? "escalate",
+    candidateHash: overrides.candidateHash
+  };
+}
+function selectCouncilPanel(spec, request) {
+  const type = request.type.trim().toLowerCase();
+  const scope = request.scope.join(" ").toLowerCase();
+  const selected = new Set(["delivery", "security-reviewer", "devil"]);
+  const isFeature = type === "feature" || type === "api";
+  const isStructural = ["feature", "api", "refactor", "migration", "database"].includes(type);
+  if (isFeature || request.risk !== "low")
+    selected.add("architect");
+  if (isFeature || request.risk === "high")
+    selected.add("product");
+  if (DATA_HINTS.some((hint) => scope.includes(hint)) || ["migration", "database"].includes(type)) {
+    selected.add("data-ops");
+  }
+  if (request.risk === "high" || SECURITY_HINTS.some((hint) => scope.includes(hint))) {
+    selected.add("security-reviewer");
+  }
+  if (isStructural)
+    selected.add("architect");
+  const expectedAgentIds = spec.agents.map((agent) => agent.id).filter((id) => selected.has(id));
+  return deriveConsensusConfig(spec, {
+    expectedAgentIds,
+    quorum: Math.ceil(expectedAgentIds.length / 2)
+  });
+}
+var SECURITY_HINTS, DEFAULT_COUNCIL_AGENTS, DATA_HINTS;
+var init_council_spec = __esm(() => {
+  SECURITY_HINTS = ["security", "auth", "injection", "credentials", "supply-chain"];
+  DEFAULT_COUNCIL_AGENTS = [
+    {
+      id: "architect",
+      role: "Architect",
+      context: "repo-readonly",
+      modelHint: "strong-reasoning",
+      focus: ["architecture", "design-patterns", "code-structure"]
+    },
+    {
+      id: "product",
+      role: "Product",
+      context: "prompt-only",
+      modelHint: "balanced",
+      focus: ["requirements", "ux", "business-value"]
+    },
+    {
+      id: "delivery",
+      role: "Delivery",
+      context: "repo-readonly",
+      modelHint: "practical-coding",
+      focus: ["delivery", "testing", "deployment"]
+    },
+    {
+      id: "data-ops",
+      role: "DataOps",
+      context: "repo-readonly",
+      modelHint: "analytical",
+      focus: ["data", "pipelines", "analytics"]
+    },
+    {
+      id: "security-reviewer",
+      role: "Security Reviewer",
+      context: "repo-readonly",
+      modelHint: "security-reasoning",
+      focus: [
+        "security",
+        "vulnerabilities",
+        "compliance",
+        "credentials",
+        "injection",
+        "auth",
+        "supply-chain"
+      ]
+    },
+    {
+      id: "devil",
+      role: "Devil",
+      context: "repo-readonly",
+      modelHint: "adversarial",
+      focus: ["review", "edge-cases", "failure-modes"]
+    }
+  ];
+  DATA_HINTS = ["data", "database", "migration", "analytics", "pipeline", "sql"];
+});
+
+// src/core/ccep/risk-classifier.ts
+function classifyRisk(input) {
+  const type = (input.type ?? "").toLowerCase();
+  const blob = [type, ...input.targetFiles ?? [], ...input.signals ?? []].join(" ");
+  if (HIGH_RE.test(blob) || INFRA_RE.test(blob) || type === "db-migration" || type === "api-contract") {
+    return "high";
+  }
+  if (type === "docs" || type === "review") {
+    return "low";
+  }
+  if (type === "test") {
+    return "low";
+  }
+  if (type === "refactor" && (input.signals ?? []).some((s) => /full[-_ ]?test[-_ ]?coverage/i.test(s))) {
+    return "low";
+  }
+  if (type === "fix") {
+    const isolated = (input.signals ?? []).some((s) => /isolated/i.test(s));
+    return isolated ? "low" : "medium";
+  }
+  return "medium";
+}
+var HIGH_RE, INFRA_RE;
+var init_risk_classifier = __esm(() => {
+  HIGH_RE = /(migrat|schema|auth(?:n|z|entication|orization)?|oauth|payment|billing|credential|password|secret|openapi|public[-_ ]?api|api[-_ ]?contract)/i;
+  INFRA_RE = /(alembic|\.github[/\\]workflows|dockerfile|terraform|\.tf\b|package-lock\.json|go\.sum|cargo\.lock)/i;
+});
+
 // src/core/shared/vague-criterion.ts
 function isVagueCriterion(text) {
   const t = text.trim();
@@ -25547,16 +25787,34 @@ function consensusExitCode(status) {
     return 1;
   return 2;
 }
+function parseConsensusBallots(verdicts) {
+  if (!Array.isArray(verdicts)) {
+    return { ok: false, error: "Consensus input must be a verdicts array or { verdicts, config? }" };
+  }
+  const parsed = [];
+  for (let i = 0;i < verdicts.length; i++) {
+    const ballot = CouncilVerdictInputSchema.safeParse(verdicts[i]);
+    if (!ballot.success) {
+      return {
+        ok: false,
+        error: ballot.error.issues.map((issue) => `verdicts[${i}].${issue.path.join(".")}: ${issue.message}`).join("; ")
+      };
+    }
+    parsed.push(ballot.data);
+  }
+  return { ok: true, verdicts: parsed };
+}
 function parseConsensusPayload(data) {
   if (Array.isArray(data)) {
-    return { ok: true, verdicts: data };
+    return parseConsensusBallots(data);
   }
   if (typeof data !== "object" || data === null) {
     return { ok: false, error: "Consensus input must be a verdicts array or { verdicts, config? }" };
   }
   const record = data;
-  if (!Array.isArray(record.verdicts)) {
-    return { ok: false, error: "Consensus input must be a verdicts array or { verdicts, config? }" };
+  const ballots = parseConsensusBallots(record.verdicts);
+  if (!ballots.ok) {
+    return ballots;
   }
   let config;
   if (record.config !== undefined) {
@@ -25569,7 +25827,19 @@ function parseConsensusPayload(data) {
     }
     config = parsed.data;
   }
-  return { ok: true, verdicts: record.verdicts, config };
+  return { ok: true, verdicts: ballots.verdicts, config };
+}
+function resolvePanelRisk(panelRisk, type, scope) {
+  if (panelRisk === undefined || panelRisk === "") {
+    return { ok: true, risk: classifyRisk({ type, signals: scope }) };
+  }
+  if (panelRisk !== "low" && panelRisk !== "medium" && panelRisk !== "high") {
+    return {
+      ok: false,
+      error: `Invalid --risk: ${panelRisk}. Expected one of: low, medium, high`
+    };
+  }
+  return { ok: true, risk: panelRisk };
 }
 async function ccepCommand(options) {
   const {
@@ -25588,7 +25858,11 @@ async function ccepCommand(options) {
     taskId,
     contextStrategy,
     config,
-    rest
+    rest,
+    panel,
+    panelType,
+    panelScope,
+    panelRisk
   } = options;
   switch (subcommand) {
     case "parse": {
@@ -25779,6 +26053,7 @@ async function ccepCommand(options) {
           command: "ccep compile",
           phase: phaseId,
           role: agentRole,
+          phaseRoles: resolvedPhase.roles,
           outputSchema: compiled.outputSchema,
           promptVersion,
           ...representation
@@ -25890,6 +26165,30 @@ async function ccepCommand(options) {
       };
     }
     case "consensus": {
+      let panelConfig;
+      if (panel) {
+        const type = panelType ?? "";
+        const scope = (panelScope ?? "").split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+        const risk = resolvePanelRisk(panelRisk, type, scope);
+        if (!risk.ok) {
+          return {
+            code: 1,
+            data: { success: false, command: "ccep consensus", errors: [risk.error] }
+          };
+        }
+        panelConfig = selectCouncilPanel(defaultCouncilSpec(), { type, risk: risk.risk, scope });
+        const hasBallots = (input ?? rest?.join(" ").trim() ?? "") !== "";
+        if (!hasBallots) {
+          return {
+            code: 0,
+            data: {
+              success: true,
+              command: "ccep consensus",
+              panel: panelConfig
+            }
+          };
+        }
+      }
       const payload = await readInputPayload(projectRoot, input, rest);
       if (!payload.ok) {
         return {
@@ -25904,7 +26203,7 @@ async function ccepCommand(options) {
           data: { success: false, command: "ccep consensus", errors: [parsedBallots.error] }
         };
       }
-      let mergedConfig = parsedBallots.config;
+      let mergedConfig = panelConfig ?? parsedBallots.config;
       if (config) {
         const configPayload = await readInputPayload(projectRoot, config);
         if (!configPayload.ok) {
@@ -26045,6 +26344,8 @@ var init_ccep_command = __esm(() => {
   init_context_resolver();
   init_workflow_profile_loader();
   init_council_consensus();
+  init_council_spec();
+  init_risk_classifier();
   init_task_card_validator();
   init_schemas();
   CONTEXT_STRATEGIES = ["sticky", "isolated", "artifact", "compact", "fork", "full"];
@@ -26190,8 +26491,6 @@ var init_backlog_validator = __esm(() => {
 
 // src/core/openspec/backlog-scanner.ts
 import { execFileSync } from "node:child_process";
-import { readFile as readFile34 } from "node:fs/promises";
-import { resolve as resolve31 } from "node:path";
 function itemSnapshot(items) {
   const snap = {};
   for (const item of items) {
@@ -26199,67 +26498,106 @@ function itemSnapshot(items) {
   }
   return snap;
 }
-async function scanBacklog(projectRoot, previousSnapshot = {}) {
+function checkBacklogFileChanged(projectRoot) {
   try {
-    const filePath = resolve31(projectRoot, BACKLOG_FILENAME);
-    const content = await readFile34(filePath, "utf-8");
-    const hash = hashContent(content);
-    let fileChanged = true;
-    try {
-      const diff = execFileSync("git", ["diff", "--name-only", "--", BACKLOG_FILENAME], {
-        cwd: projectRoot,
-        encoding: "utf-8",
-        stdio: ["ignore", "pipe", "ignore"]
-      });
-      fileChanged = diff.trim().length > 0;
-    } catch {
-      fileChanged = true;
-    }
-    const parseResult = parseBacklogMarkdown(content);
-    if (!parseResult.success)
-      return parseResult;
-    const doc = parseResult.data;
-    const current = itemSnapshot([...doc.items, ...doc.archive]);
-    const newItems = [];
-    const modifiedItems = [];
-    const closedItems = [];
-    for (const [id, snap] of Object.entries(current)) {
-      if (!previousSnapshot[id]) {
-        newItems.push(id);
-      } else if (previousSnapshot[id] !== snap) {
-        modifiedItems.push(id);
-      }
-    }
-    for (const id of Object.keys(previousSnapshot)) {
-      if (!current[id])
-        closedItems.push(id);
+    const diff = execFileSync("git", ["diff", "--name-only", "--", BACKLOG_FILENAME], {
+      cwd: projectRoot,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    return diff.trim().length > 0;
+  } catch {
+    return true;
+  }
+}
+function computeScanDiff(content, doc, previousSnapshot = {}, fileChanged = true) {
+  const hash = hashContent(content);
+  const current = itemSnapshot([...doc.items, ...doc.archive]);
+  const newItems = [];
+  const modifiedItems = [];
+  const closedItems = [];
+  for (const [id, snap] of Object.entries(current)) {
+    if (!previousSnapshot[id]) {
+      newItems.push(id);
+    } else if (previousSnapshot[id] !== snap) {
+      modifiedItems.push(id);
     }
-    for (const item of doc.archive) {
-      if (!closedItems.includes(item.id))
-        closedItems.push(item.id);
+  }
+  for (const id of Object.keys(previousSnapshot)) {
+    if (!current[id])
+      closedItems.push(id);
+  }
+  for (const item of doc.archive) {
+    if (!closedItems.includes(item.id))
+      closedItems.push(item.id);
+  }
+  for (const item of doc.items) {
+    if (item.status === "DONE" && !closedItems.includes(item.id)) {
+      closedItems.push(item.id);
     }
-    for (const item of doc.items) {
-      if (item.status === "DONE" && !closedItems.includes(item.id)) {
-        closedItems.push(item.id);
-      }
+  }
+  return {
+    fileChanged,
+    contentHash: hash,
+    newItems,
+    modifiedItems,
+    closedItems
+  };
+}
+function buildItemSnapshot(items, archive) {
+  return itemSnapshot([...items, ...archive]);
+}
+var init_backlog_scanner = __esm(() => {
+  init_backlog_parser();
+  init_openspec_state();
+});
+
+// src/core/openspec/backlog-session.ts
+import { readFile as readFile34 } from "node:fs/promises";
+import { resolve as resolve31 } from "node:path";
+async function loadBacklogSession(projectRoot) {
+  try {
+    const raw = await readFile34(resolve31(projectRoot, BACKLOG_FILENAME), "utf-8");
+    const parsed = parseBacklogMarkdown(raw);
+    if (!parsed.success)
+      return parsed;
+    const stateResult = await loadOpenspecState(projectRoot);
+    if (!stateResult.success)
+      return stateResult;
+    const state = stateResult.data;
+    const report = validateBacklog(parsed.data);
+    if (!report.valid) {
+      return err(new BacklogSessionError(parsed.data, report, state));
     }
     return ok({
-      fileChanged,
-      contentHash: hash,
-      newItems,
-      modifiedItems,
-      closedItems
+      raw,
+      doc: parsed.data,
+      state,
+      scan: computeScanDiff(raw, parsed.data, state.itemSnapshots ?? {}, checkBacklogFileChanged(projectRoot)),
+      report
     });
   } catch (e) {
     return err(e instanceof Error ? e : new Error(String(e)));
   }
 }
-function buildItemSnapshot(items, archive) {
-  return itemSnapshot([...items, ...archive]);
-}
-var init_backlog_scanner = __esm(() => {
+var BacklogSessionError;
+var init_backlog_session = __esm(() => {
   init_backlog_parser();
+  init_backlog_validator();
+  init_backlog_scanner();
   init_openspec_state();
+  BacklogSessionError = class BacklogSessionError extends Error {
+    doc;
+    report;
+    state;
+    constructor(doc, report, state) {
+      super(report.errors.map((e) => e.message).join("; ") || "Invalid BACKLOG.md");
+      this.name = "BacklogSessionError";
+      this.doc = doc;
+      this.report = report;
+      this.state = state;
+    }
+  };
 });
 
 // src/core/openspec/agent-router.ts
@@ -26294,8 +26632,11 @@ function phaseTitle(phase, item) {
 function phasePrompt(phase, item) {
   const base = `Backlog item ${item.id} — ${item.title}
 
-Description: ${item.description}
-Scope: ${item.scope}`;
+` + `Description:
+${markUntrusted("description", item.description)}
+
+` + `Scope:
+${markUntrusted("scope", item.scope)}`;
   switch (phase) {
     case "discover":
       return `${base}
@@ -26422,6 +26763,7 @@ var DEFAULT_PHASE_ORDER, TDD_PHASE_ORDER;
 var init_backlog_planner = __esm(() => {
   init_agent_router();
   init_openspec_state();
+  init_untrusted_text();
   DEFAULT_PHASE_ORDER = [
     "discover",
     "design",
@@ -26439,7 +26781,7 @@ var init_backlog_planner = __esm(() => {
 });
 
 // src/core/openspec/openspec-generator.ts
-import { mkdir as mkdir22, rename as rename5, writeFile as writeFile22 } from "node:fs/promises";
+import { access as access7, mkdir as mkdir21, rename as rename5, writeFile as writeFile21 } from "node:fs/promises";
 import { basename as basename8, resolve as resolve32 } from "node:path";
 function pad3(n) {
   return String(n).padStart(3, "0");
@@ -26452,13 +26794,14 @@ function proposalContent(item) {
 
 ## Why
 
-${item.description}
+${markUntrusted("description", item.description)}
 
-${item.businessValue ? `**Business value:** ${item.businessValue}` : ""}
+${item.businessValue ? `**Business value:**
+${markUntrusted("business-value", item.businessValue)}` : ""}
 
 ## What Changes
 
-- ${item.scope}
+- ${markUntrusted("scope", item.scope)}
 
 ## Capabilities
 
@@ -26467,9 +26810,11 @@ ${item.businessValue ? `**Business value:** ${item.businessValue}` : ""}
 
 ## Impact
 
-${item.risks ? `Risks: ${item.risks}` : "See design.md for technical impact."}
+${item.risks ? `Risks:
+${markUntrusted("risks", item.risks)}` : "See design.md for technical impact."}
 
-**Out of scope:** ${item.outOfScope || "None specified."}
+**Out of scope:**
+${markUntrusted("out-of-scope", item.outOfScope || "None specified.")}
 `;
 }
 function designContent(item) {
@@ -26477,15 +26822,20 @@ function designContent(item) {
 
 ## Approach
 
-Deliver "${item.title}" inside ${item.scope}. The architect MUST refine files and risks before implementation.
+Deliver "${item.title}" inside:
+
+${markUntrusted("scope", item.scope)}
+
+The architect MUST refine files and risks before implementation.
 
 ## Files Affected
 
-${item.scope}
+${markUntrusted("scope", item.scope)}
 
 ## Acceptance Criteria
 
-${item.acceptanceCriteria.map((c) => `- ${c}`).join(`
+${item.acceptanceCriteria.map((c) => markUntrusted("acceptance-criterion", c)).join(`
+
 `)}
 
 ## Complexity Tracking
@@ -26519,8 +26869,8 @@ ${blocks.join(`
 `;
 }
 async function writeTasksMarkdown(projectRoot, changePath, cards, options = {}) {
-  await mkdir22(resolve32(projectRoot, changePath), { recursive: true });
-  await writeFile22(resolve32(projectRoot, changePath, "tasks.md"), tasksContent(cards, options), "utf-8");
+  await mkdir21(resolve32(projectRoot, changePath), { recursive: true });
+  await writeFile21(resolve32(projectRoot, changePath, "tasks.md"), tasksContent(cards, options), "utf-8");
 }
 function tasksContent(cards, options = {}) {
   const criteria = options.acceptanceCriteria ?? [];
@@ -26566,18 +26916,18 @@ function tasksContent(cards, options = {}) {
 async function generateOpenspecChange(projectRoot, item, taskCards, options = {}) {
   const slug = buildChangeSlug(item);
   const changeDir = resolve32(projectRoot, "openspec", "changes", slug);
-  await mkdir22(resolve32(changeDir, "specs"), { recursive: true });
+  await mkdir21(resolve32(changeDir, "specs"), { recursive: true });
   const taskOpts = {
     tddRequired: options.tddRequired,
     acceptanceCriteria: options.acceptanceCriteria ?? item.acceptanceCriteria
   };
-  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");
+  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");
   const capability = capabilitySlug(item.title);
-  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
+  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
 backlogId: ${item.id}
 profile: standard
 capabilities:
@@ -26589,38 +26939,86 @@ async function archiveChangeFolder(projectRoot, changePath) {
   const src = resolve32(projectRoot, changePath);
   const slug = basename8(changePath);
   const destDir = resolve32(projectRoot, "openspec", "changes", "archive");
-  await mkdir22(destDir, { recursive: true });
+  await mkdir21(destDir, { recursive: true });
   const dest = resolve32(destDir, slug);
+  try {
+    await access7(dest);
+    throw new Error(`Archive destination already exists: openspec/changes/archive/${slug}`);
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("Archive destination already exists")) {
+      throw error;
+    }
+  }
   await rename5(src, dest);
   return `openspec/changes/archive/${slug}`;
 }
 async function ensureOpenspecConfig(projectRoot) {
   const configPath = resolve32(projectRoot, "openspec", "config.yaml");
   try {
-    const { access: access7 } = await import("node:fs/promises");
-    await access7(configPath);
+    const { access: access8 } = await import("node:fs/promises");
+    await access8(configPath);
   } catch {
-    await mkdir22(resolve32(projectRoot, "openspec"), { recursive: true });
+    await mkdir21(resolve32(projectRoot, "openspec"), { recursive: true });
     const stub = `# OpenSpec project config (CodeConductor native compatible)
 schema: spec-driven
 `;
-    await writeFile22(configPath, stub, "utf-8");
+    await writeFile21(configPath, stub, "utf-8");
   }
 }
 var init_openspec_generator = __esm(() => {
   init_backlog_planner();
+  init_untrusted_text();
+});
+
+// src/core/openspec/spec-files.ts
+import { readFile as readFile35, readdir as readdir11 } from "node:fs/promises";
+import { join as join24 } from "node:path";
+async function walkMarkdownFiles(dir) {
+  let entries;
+  try {
+    entries = await readdir11(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    const path = join24(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await walkMarkdownFiles(path));
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      files.push(path);
+    }
+  }
+  return files;
+}
+async function readMarkdownFiles(dir) {
+  const files = await walkMarkdownFiles(dir);
+  const out = [];
+  for (const path of files) {
+    out.push({ path, content: await readFile35(path, "utf-8") });
+  }
+  return out;
+}
+function requirementBlocks(markdown) {
+  const starts = [...markdown.matchAll(/^### Requirement:.*$/gm)];
+  return starts.map((match, index) => {
+    const start = match.index ?? 0;
+    const end = starts[index + 1]?.index ?? markdown.length;
+    const block = markdown.slice(start, end).trim();
+    return { id: block.match(REQUIREMENT_HEADING)?.[1] ?? null, markdown: block };
+  });
+}
+var REQUIREMENT_HEADING;
+var init_spec_files = __esm(() => {
+  REQUIREMENT_HEADING = /^### Requirement:.*?\b(FR-\d{3})\b.*$/m;
 });
 
 // src/core/openspec/spec-quality.ts
-import { readdir as readdir11, readFile as readFile35 } from "node:fs/promises";
-import { join as join23, relative as relative10, resolve as resolve33 } from "node:path";
+import { readFile as readFile36 } from "node:fs/promises";
+import { join as join25, relative as relative10, resolve as resolve33 } from "node:path";
 function uniqueIds(matches) {
   return [...new Set(matches ?? [])];
 }
-function requirementBlocks(content) {
-  const parts = content.split(/^### Requirement:/m);
-  return parts.slice(1).map((block) => `### Requirement:${block}`);
-}
 function assessSpecMarkdown(content, path) {
   const issues = [];
   const clarifications = content.match(NEEDS_CLARIFICATION) ?? [];
@@ -26663,9 +27061,10 @@ function assessSpecMarkdown(content, path) {
     });
   }
   for (const block of blocks) {
-    const heading = block.split(`
+    const text = block.markdown;
+    const heading = text.split(`
 `, 1)[0] ?? "";
-    if (!RFC2119.test(block)) {
+    if (!RFC2119.test(text)) {
       issues.push({
         code: "MISSING_RFC2119",
         message: `Requirement "${heading}" MUST use RFC 2119 keywords (MUST/SHALL/SHOULD/MAY)`,
@@ -26673,7 +27072,7 @@ function assessSpecMarkdown(content, path) {
         severity: "error"
       });
     }
-    if (!GWT.test(block)) {
+    if (!GWT.test(text)) {
       issues.push({
         code: "MISSING_GWT",
         message: `Requirement "${heading}" MUST include a Given/When/Then scenario`,
@@ -26726,24 +27125,6 @@ function mergeSpecQualityReports(reports) {
     successCriteria
   };
 }
-async function walkMarkdown(dir) {
-  const out = [];
-  let entries;
-  try {
-    entries = await readdir11(dir, { withFileTypes: true });
-  } catch {
-    return out;
-  }
-  for (const entry of entries) {
-    const full = join23(dir, entry.name);
-    if (entry.isDirectory()) {
-      out.push(...await walkMarkdown(full));
-    } else if (entry.isFile() && entry.name.endsWith(".md")) {
-      out.push(full);
-    }
-  }
-  return out;
-}
 async function assessChangeFolder(projectRoot, changePath) {
   const root = resolve33(projectRoot);
   const changeRoot = resolve33(root, changePath);
@@ -26764,18 +27145,18 @@ async function assessChangeFolder(projectRoot, changePath) {
       successCriteria: []
     };
   }
-  const specDir = join23(changeRoot, "specs");
-  const specFiles = await walkMarkdown(specDir);
-  const extra = ["proposal.md", "design.md"].map((name) => join23(changeRoot, name));
+  const specDir = join25(changeRoot, "specs");
+  const specFiles = await walkMarkdownFiles(specDir);
+  const extra = ["proposal.md", "design.md"].map((name) => join25(changeRoot, name));
   const reports = [];
   for (const file of specFiles) {
-    const content = await readFile35(file, "utf-8");
+    const content = await readFile36(file, "utf-8");
     reports.push(assessSpecMarkdown(content, relative10(root, file).replace(/\\/g, "/")));
   }
   for (const file of extra) {
     let content;
     try {
-      content = await readFile35(file, "utf-8");
+      content = await readFile36(file, "utf-8");
     } catch {
       continue;
     }
@@ -26819,6 +27200,7 @@ async function assessChangeFolder(projectRoot, changePath) {
 }
 var RFC2119, FR_ID, SC_ID, US_AC, GWT, NEEDS_CLARIFICATION, PLACEHOLDER, HOW_LEAK, MAX_CLARIFICATIONS = 3;
 var init_spec_quality = __esm(() => {
+  init_spec_files();
   RFC2119 = /\b(MUST(?: NOT)?|SHALL(?: NOT)?|SHOULD(?: NOT)?|MAY)\b/;
   FR_ID = /\bFR-\d{3}\b/g;
   SC_ID = /\bSC-\d{3}\b/g;
@@ -26830,8 +27212,8 @@ var init_spec_quality = __esm(() => {
 });
 
 // src/core/openspec/spec-analyzer.ts
-import { readFile as readFile36, readdir as readdir12 } from "node:fs/promises";
-import { join as join24, resolve as resolve34 } from "node:path";
+import { readFile as readFile37 } from "node:fs/promises";
+import { join as join26, resolve as resolve34 } from "node:path";
 function unique(ids) {
   return [...new Set(ids)];
 }
@@ -26856,22 +27238,8 @@ function testSection(tasksMarkdown) {
 `);
 }
 async function readDeltaSpecs(specDir) {
-  let entries;
-  try {
-    entries = await readdir12(specDir, { withFileTypes: true });
-  } catch {
-    return "";
-  }
-  const contents = [];
-  for (const entry of entries) {
-    const path = join24(specDir, entry.name);
-    if (entry.isDirectory()) {
-      contents.push(await readDeltaSpecs(path));
-    } else if (entry.isFile() && entry.name.endsWith(".md")) {
-      contents.push(await readFile36(path, "utf-8"));
-    }
-  }
-  return contents.filter(Boolean).join(`
+  const files = await readMarkdownFiles(specDir);
+  return files.map((f) => f.content).filter(Boolean).join(`
 
 `);
 }
@@ -26947,16 +27315,16 @@ function analyzeSpecArtifacts(input) {
 }
 async function analyzeChangeFolder(projectRoot, changePath, options) {
   const changeRoot = resolve34(projectRoot, changePath);
-  const specMarkdown = await readDeltaSpecs(join24(changeRoot, "specs"));
+  const specMarkdown = await readDeltaSpecs(join26(changeRoot, "specs"));
   let tasksMarkdown = "";
   try {
-    tasksMarkdown = await readFile36(join24(changeRoot, "tasks.md"), "utf-8");
+    tasksMarkdown = await readFile37(join26(changeRoot, "tasks.md"), "utf-8");
   } catch {
     tasksMarkdown = "";
   }
   let designMarkdown;
   try {
-    designMarkdown = await readFile36(join24(changeRoot, "design.md"), "utf-8");
+    designMarkdown = await readFile37(join26(changeRoot, "design.md"), "utf-8");
   } catch {
     designMarkdown = undefined;
   }
@@ -26971,53 +27339,28 @@ async function analyzeChangeFolder(projectRoot, changePath, options) {
   });
 }
 var init_spec_analyzer = __esm(() => {
+  init_spec_files();
   init_spec_quality();
 });
 
 // src/core/openspec/spec-sync.ts
-import { mkdir as mkdir23, readFile as readFile37, readdir as readdir13 } from "node:fs/promises";
-import { join as join25, relative as relative11, resolve as resolve35 } from "node:path";
-async function markdownFiles(dir) {
-  let entries;
-  try {
-    entries = await readdir13(dir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-  const files = [];
-  for (const entry of entries) {
-    const path = join25(dir, entry.name);
-    if (entry.isDirectory())
-      files.push(...await markdownFiles(path));
-    else if (entry.isFile() && entry.name.endsWith(".md"))
-      files.push(path);
-  }
-  return files;
-}
-function requirementBlocks2(markdown) {
-  const starts = [...markdown.matchAll(/^### Requirement:.*$/gm)];
-  return starts.flatMap((match, index) => {
-    const start = match.index ?? 0;
-    const end = starts[index + 1]?.index ?? markdown.length;
-    const block = markdown.slice(start, end).trim();
-    const id = block.match(REQUIREMENT_HEADING)?.[1];
-    return id ? [{ id, markdown: block }] : [];
-  });
-}
+import { mkdir as mkdir22, readFile as readFile38 } from "node:fs/promises";
+import { join as join27, relative as relative11, resolve as resolve35 } from "node:path";
 function deltaRequirements(markdown) {
   const sections = [...markdown.matchAll(SECTION_HEADING)];
   return sections.flatMap((section, index) => {
     const start = (section.index ?? 0) + section[0].length;
     const end = sections[index + 1]?.index ?? markdown.length;
     const operation = section[1];
-    return requirementBlocks2(markdown.slice(start, end)).map((requirement) => ({
-      ...requirement,
+    return requirementBlocks(markdown.slice(start, end)).filter((requirement) => requirement.id !== null).map((requirement) => ({
+      id: requirement.id,
+      markdown: requirement.markdown,
       operation
     }));
   });
 }
 function upsertRequirements(existing, deltas, source) {
-  const requirements = requirementBlocks2(existing);
+  const requirements = requirementBlocks(existing).filter((requirement) => requirement.id !== null);
   const byId = new Map(requirements.map((requirement) => [requirement.id, requirement]));
   if (byId.size !== requirements.length) {
     return { ok: false, error: `${source}: durable spec has duplicate requirement IDs` };
@@ -27049,7 +27392,7 @@ ${delta.markdown}`;
     if (!current)
       continue;
     if (delta.operation === "MODIFIED") {
-      next = next.replace(current.markdown, delta.markdown);
+      next = next.replace(current.markdown, () => delta.markdown);
       byId.set(delta.id, { id: delta.id, markdown: delta.markdown });
     } else {
       next = next.replace(current.markdown, "").replace(/\n{3,}/g, `
@@ -27064,17 +27407,17 @@ ${delta.markdown}`;
 async function syncChangeSpecs(projectRoot, changePath) {
   const root = resolve35(projectRoot);
   const changeRoot = resolve35(root, changePath);
-  const changeSpecs = join25(changeRoot, "specs");
+  const changeSpecs = join27(changeRoot, "specs");
   if (changeRoot !== root && !changeRoot.startsWith(`${root}/`)) {
     return { success: false, syncedPaths: [], errors: ["Change path escapes project root"] };
   }
-  const files = await markdownFiles(changeSpecs);
+  const files = await walkMarkdownFiles(changeSpecs);
   if (files.length === 0) {
     return { success: false, syncedPaths: [], errors: ["Change folder has no delta specs"] };
   }
   const writes = [];
   for (const file of files) {
-    const delta = await readFile37(file, "utf-8");
+    const delta = await readFile38(file, "utf-8");
     const requirements = deltaRequirements(delta);
     if (requirements.length === 0) {
       return {
@@ -27084,11 +27427,11 @@ async function syncChangeSpecs(projectRoot, changePath) {
       };
     }
     const relativeSpec = relative11(changeSpecs, file);
-    const target = join25(root, "openspec", "specs", relativeSpec);
+    const target = join27(root, "openspec", "specs", relativeSpec);
     let existing = `# ${relativeSpec.replace(/\\/g, "/")}
 `;
     try {
-      existing = await readFile37(target, "utf-8");
+      existing = await readFile38(target, "utf-8");
     } catch {}
     const merged = upsertRequirements(existing, requirements, relative11(root, file));
     if (!merged.ok)
@@ -27096,7 +27439,7 @@ async function syncChangeSpecs(projectRoot, changePath) {
     writes.push({ path: target, content: merged.content });
   }
   for (const write of writes) {
-    await mkdir23(resolve35(write.path, ".."), { recursive: true });
+    await mkdir22(resolve35(write.path, ".."), { recursive: true });
     await writeFileAtomic(write.path, write.content);
   }
   return {
@@ -27105,20 +27448,104 @@ async function syncChangeSpecs(projectRoot, changePath) {
     errors: []
   };
 }
-var REQUIREMENT_HEADING, SECTION_HEADING;
+var SECTION_HEADING;
 var init_spec_sync = __esm(() => {
   init_openspec_state();
-  REQUIREMENT_HEADING = /^### Requirement:.*?\b(FR-\d{3})\b.*$/m;
+  init_spec_files();
   SECTION_HEADING = /^## (ADDED|MODIFIED|REMOVED) Requirements\s*$/gm;
 });
 
+// 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";
+function countCheckboxes(markdown) {
+  let total = 0;
+  let complete = 0;
+  for (const line of markdown.split(`
+`)) {
+    const marker = line.match(CHECKBOX)?.[1];
+    if (marker === undefined)
+      continue;
+    total += 1;
+    if (marker === "x" || marker === "X")
+      complete += 1;
+  }
+  return { total, complete, remaining: total - complete };
+}
+async function exists(path) {
+  try {
+    await access8(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function hasMarkdown(dir) {
+  let entries;
+  try {
+    entries = await readdir12(dir, { withFileTypes: true });
+  } catch {
+    return false;
+  }
+  for (const entry of entries) {
+    const full = join28(dir, entry.name);
+    if (entry.isFile() && entry.name.endsWith(".md"))
+      return true;
+    if (entry.isDirectory() && await hasMarkdown(full))
+      return true;
+  }
+  return false;
+}
+async function readArtifactProgress(projectRoot, changePath) {
+  const root = resolve36(projectRoot);
+  const changeRoot = resolve36(root, changePath);
+  if (changeRoot !== root && !changeRoot.startsWith(`${root}/`)) {
+    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"))
+  ]);
+  let checkboxes = { total: 0, complete: 0, remaining: 0 };
+  if (tasks) {
+    try {
+      checkboxes = countCheckboxes(await readFile39(join28(changeRoot, "tasks.md"), "utf-8"));
+    } catch {
+      checkboxes = { total: 0, complete: 0, remaining: 0 };
+    }
+  }
+  return { artifacts: { proposal, design, tasks, specs }, checkboxes };
+}
+function missingArtifacts(presence) {
+  const missing = [];
+  if (!presence.proposal)
+    missing.push("proposal.md");
+  if (!presence.design)
+    missing.push("design.md");
+  if (!presence.tasks)
+    missing.push("tasks.md");
+  if (!presence.specs)
+    missing.push("specs/*.md");
+  return missing;
+}
+var CHECKBOX, ABSENT;
+var init_artifact_progress = __esm(() => {
+  CHECKBOX = /^\s*-\s*\[([^\]])\]/;
+  ABSENT = {
+    artifacts: { proposal: false, design: false, tasks: false, specs: false },
+    checkboxes: { total: 0, complete: 0, remaining: 0 }
+  };
+});
+
 // src/commands/openspec.command.ts
 var exports_openspec_command = {};
 __export(exports_openspec_command, {
   openspecCommand: () => openspecCommand
 });
-import { readFile as readFile38 } from "node:fs/promises";
-import { resolve as resolve36 } from "node:path";
+import { readFile as readFile40 } from "node:fs/promises";
+import { resolve as resolve37 } from "node:path";
 async function openspecCommand(options) {
   const { subcommand, itemId, projectRoot, output, reason } = options;
   switch (subcommand) {
@@ -27144,6 +27571,10 @@ async function openspecCommand(options) {
       return handleUnblock(projectRoot, itemId);
     case "archive":
       return handleArchive(projectRoot, itemId);
+    case "sync":
+      return handleSync(projectRoot, itemId);
+    case "verify":
+      return handleVerify(projectRoot, itemId);
     default:
       return {
         code: 1,
@@ -27164,7 +27595,7 @@ function fail(command, errors3, extra = {}) {
   };
 }
 async function persistBacklog(projectRoot, content) {
-  await writeFileAtomic(resolve36(projectRoot, BACKLOG_FILENAME), content);
+  await writeFileAtomic(resolve37(projectRoot, BACKLOG_FILENAME), content);
 }
 async function persistState(projectRoot, state) {
   const written = await writeOpenspecState(projectRoot, state);
@@ -27173,17 +27604,13 @@ async function persistState(projectRoot, state) {
   }
   return { ok: true };
 }
-async function readBacklogMarkdown(projectRoot) {
-  return readFile38(resolve36(projectRoot, BACKLOG_FILENAME), "utf-8");
-}
-async function transitionItem(projectRoot, item, to, progress) {
-  const content = await readBacklogMarkdown(projectRoot);
+async function transitionItem(projectRoot, item, to, progress, content) {
   const next = applyBacklogTransition(content, item.id, item.status, to, progress);
   if (!next.success) {
     return { ok: false, error: next.error.message };
   }
   await persistBacklog(projectRoot, next.data);
-  return { ok: true };
+  return { ok: true, content: next.data };
 }
 function findCard(state, cardId) {
   return state.taskCards.find((c) => c.id === cardId);
@@ -27191,28 +27618,92 @@ function findCard(state, cardId) {
 function itemCards(state, backlogId) {
   return state.taskCards.filter((c) => c.backlogId === backlogId);
 }
-async function handleValidate(projectRoot) {
-  const loadResult = await loadBacklog(projectRoot);
-  if (!loadResult.success) {
+function resolveActiveChange(state, command, itemId) {
+  const targetId = itemId ?? state.activeItemId;
+  if (!targetId) {
     return {
-      code: 1,
-      data: {
-        success: false,
-        command: "openspec validate",
-        errors: [loadResult.error.message],
-        recommendations: [
-          "Create BACKLOG.md at project root using the CodeConductor template."
-        ]
-      }
+      ok: false,
+      response: fail(command, ["No active change. Run openspec plan or pass an item id."])
     };
   }
-  const report = validateBacklog(loadResult.data);
-  const errors3 = report.errors.map((e) => e.message);
-  const recommendations = [...report.recommendations];
+  const changePath = state.changePaths[targetId];
+  if (!changePath || changePath.includes("/archive/")) {
+    return { ok: false, response: fail(command, [`No active change folder for ${targetId}`]) };
+  }
+  return { ok: true, targetId, changePath };
+}
+async function collectAnalyzeReport(projectRoot, session, targetId, changePath) {
+  const tddRequired = session.doc.global.tddRequired;
+  const policyParts = [];
+  try {
+    policyParts.push(await readFile40(resolve37(projectRoot, "AGENTS.md"), "utf-8"));
+  } catch {}
+  policyParts.push(session.raw);
+  const cards = itemCards(session.state, targetId);
+  const tddCards = cards.filter((c) => c.phase === "test" || c.phase === "implement");
+  let hasTddEvidence;
+  if (tddCards.length > 0) {
+    hasTddEvidence = true;
+    for (const card of tddCards) {
+      const expectedPhase = card.phase === "test" ? "red" : "green";
+      if (!await hasTddRunnerEvidence(projectRoot, card.id, expectedPhase)) {
+        hasTddEvidence = false;
+        break;
+      }
+    }
+  }
+  const report = await analyzeChangeFolder(projectRoot, changePath, {
+    tddRequired,
+    policyText: policyParts.join(`
+`),
+    hasTddEvidence
+  });
+  return { tddRequired, report };
+}
+function buildNextSteps(input) {
+  const { state, nextItemId, progress } = input;
+  if (!state || !state.activeItemId) {
+    return [
+      nextItemId ? `Run openspec plan ${nextItemId} to start the next READY item.` : "No active change and no READY item. Author one with /cc-backlog, then run openspec plan <BC-id>."
+    ];
+  }
+  const itemId = state.activeItemId;
+  const steps = [];
+  if (progress) {
+    const missing = missingArtifacts(progress.artifacts);
+    if (missing.length > 0) {
+      steps.push(`Change folder is missing ${missing.join(", ")} — re-run openspec plan ${itemId} or restore them.`);
+    }
+  }
+  const cards = itemCards(state, itemId);
+  const blocked = cards.find((c) => c.status === "blocked");
+  if (blocked) {
+    steps.push(`Run openspec unblock ${blocked.id} to resume the blocked card.`);
+    return steps;
+  }
+  const next = getNextTaskCard(state);
+  if (next && next.backlogId === itemId) {
+    steps.push(`Run openspec start ${next.id} then delegate to ${next.agent}.`);
+    return steps;
+  }
+  const doing = cards.find((c) => c.status === "doing");
+  if (doing) {
+    steps.push(`Run openspec done ${doing.id} when the ${doing.phase} phase completes.`);
+    return steps;
+  }
+  if (cards.length > 0 && cards.every((c) => c.status === "done")) {
+    steps.push(`Run openspec verify ${itemId}, record a scorecard verdict, then run openspec archive ${itemId}.`);
+    return steps;
+  }
+  steps.push(`Run openspec next to get the next TaskCard for ${itemId}.`);
+  return steps;
+}
+async function assessActiveChangeSpecs(projectRoot, state) {
+  const errors3 = [];
+  const recommendations = [];
   let specValid = true;
-  const stateResult = await loadOpenspecState(projectRoot);
-  const activeId = stateResult.success ? stateResult.data.activeItemId : undefined;
-  const changePath = activeId && stateResult.success ? stateResult.data.changePaths[activeId] : undefined;
+  const activeId = state.activeItemId;
+  const changePath = activeId ? state.changePaths[activeId] : undefined;
   if (changePath && !changePath.includes("/archive/")) {
     const specReport = await assessChangeFolder(projectRoot, changePath);
     specValid = specReport.valid;
@@ -27223,7 +27714,32 @@ async function handleValidate(projectRoot) {
       recommendations.push("Spec has [NEEDS CLARIFICATION] markers — run ccep evaluate and wait for human input.");
     }
   }
-  const valid = report.valid && specValid;
+  return { specValid, errors: errors3, recommendations };
+}
+function sessionParts(session) {
+  return { doc: session.doc, state: session.state, report: session.report };
+}
+async function buildValidationResponse(projectRoot, sessionResult) {
+  if (!sessionResult.success && !(sessionResult.error instanceof BacklogSessionError)) {
+    return {
+      code: 1,
+      data: {
+        success: false,
+        command: "openspec validate",
+        errors: [sessionResult.error.message],
+        recommendations: [
+          "Create BACKLOG.md at project root using the CodeConductor template."
+        ]
+      }
+    };
+  }
+  const { doc, state, report } = sessionParts(sessionResult.success ? sessionResult.data : sessionResult.error);
+  const errors3 = report.errors.map((e) => e.message);
+  const recommendations = [...report.recommendations];
+  const spec = await assessActiveChangeSpecs(projectRoot, state);
+  errors3.push(...spec.errors);
+  recommendations.push(...spec.recommendations);
+  const valid = report.valid && spec.specValid;
   return {
     code: valid ? 0 : 1,
     data: {
@@ -27232,57 +27748,56 @@ async function handleValidate(projectRoot) {
       valid,
       errors: errors3,
       recommendations,
-      itemCount: loadResult.data.items.length,
-      archiveCount: loadResult.data.archive.length
+      itemCount: doc.items.length,
+      archiveCount: doc.archive.length
     }
   };
 }
+async function handleValidate(projectRoot) {
+  return buildValidationResponse(projectRoot, await loadBacklogSession(projectRoot));
+}
 async function handleScan(projectRoot) {
-  const stateResult = await loadOpenspecState(projectRoot);
-  const prevSnap = stateResult.success ? stateResult.data.itemSnapshots ?? {} : {};
-  const scanResult = await scanBacklog(projectRoot, prevSnap);
-  if (!scanResult.success) {
+  const sessionResult = await loadBacklogSession(projectRoot);
+  if (!sessionResult.success) {
     return {
       code: 1,
       data: {
         success: false,
         command: "openspec scan",
-        errors: [scanResult.error.message]
+        errors: [sessionResult.error.message]
       }
     };
   }
-  const loadResult = await loadBacklog(projectRoot);
-  if (loadResult.success && stateResult.success) {
-    const snapshots = buildItemSnapshot(loadResult.data.items, loadResult.data.archive);
-    const state = {
-      ...stateResult.data,
-      lastScanHash: scanResult.data.contentHash,
-      lastScanAt: new Date().toISOString(),
-      itemSnapshots: snapshots
-    };
-    const written = await persistState(projectRoot, state);
-    if (!written.ok) {
-      return fail("openspec scan", [written.error]);
-    }
+  const { doc, state: loadedState, scan } = sessionResult.data;
+  const snapshots = buildItemSnapshot(doc.items, doc.archive);
+  const state = {
+    ...loadedState,
+    lastScanHash: scan.contentHash,
+    lastScanAt: new Date().toISOString(),
+    itemSnapshots: snapshots
+  };
+  const written = await persistState(projectRoot, state);
+  if (!written.ok) {
+    return fail("openspec scan", [written.error]);
   }
   return {
     code: 0,
     data: {
       success: true,
       command: "openspec scan",
-      ...scanResult.data
+      ...scan
     }
   };
 }
 async function handlePlan(projectRoot, itemId) {
-  const validateFirst = await handleValidate(projectRoot);
+  const sessionResult = await loadBacklogSession(projectRoot);
+  const validateFirst = await buildValidationResponse(projectRoot, sessionResult);
   if (validateFirst.code !== 0)
     return validateFirst;
-  const loadResult = await loadBacklog(projectRoot);
-  if (!loadResult.success) {
-    return { code: 1, data: { success: false, errors: [loadResult.error.message] } };
-  }
-  const doc = loadResult.data;
+  if (!sessionResult.success)
+    return validateFirst;
+  const session = sessionResult.data;
+  const doc = session.doc;
   const item = selectNextItem(doc, itemId);
   if (!item) {
     return {
@@ -27296,13 +27811,7 @@ async function handlePlan(projectRoot, itemId) {
       }
     };
   }
-  const stateResult = await loadOpenspecState(projectRoot);
-  const existingState = stateResult.success ? stateResult.data : {
-    version: 1,
-    taskCards: [],
-    changePaths: {},
-    itemSnapshots: {}
-  };
+  const existingState = session.state;
   if (item.status !== "PLANNED" && !canTransition(item.status, "PLANNED")) {
     return fail("openspec plan", [
       `Illegal backlog transition for ${item.id}: ${item.status} → PLANNED.`
@@ -27333,8 +27842,7 @@ async function handlePlan(projectRoot, itemId) {
   if (!written.ok) {
     return fail("openspec plan", [written.error]);
   }
-  const content = await readBacklogMarkdown(projectRoot);
-  const transition = applyBacklogTransition(content, item.id, item.status, "PLANNED", item.progress);
+  const transition = applyBacklogTransition(session.raw, item.id, item.status, "PLANNED", item.progress);
   if (!transition.success) {
     return fail("openspec plan", [transition.error.message]);
   }
@@ -27355,45 +27863,14 @@ async function handlePlan(projectRoot, itemId) {
 }
 async function handleAnalyze(projectRoot, itemId) {
   const command = "openspec analyze";
-  const stateResult = await loadOpenspecState(projectRoot);
-  if (!stateResult.success) {
-    return fail(command, [stateResult.error.message]);
-  }
-  const targetId = itemId ?? stateResult.data.activeItemId;
-  if (!targetId) {
-    return fail(command, ["No active change. Run openspec plan or pass an item id."]);
-  }
-  const changePath = stateResult.data.changePaths[targetId];
-  if (!changePath || changePath.includes("/archive/")) {
-    return fail(command, [`No active change folder for ${targetId}`]);
-  }
-  const backlog = await loadBacklog(projectRoot);
-  const tddRequired = backlog.success ? backlog.data.global.tddRequired : false;
-  const policyParts = [];
-  for (const name of ["AGENTS.md", "BACKLOG.md"]) {
-    try {
-      policyParts.push(await readFile38(resolve36(projectRoot, name), "utf-8"));
-    } catch {}
-  }
-  const cards = itemCards(stateResult.data, targetId);
-  const tddCards = cards.filter((c) => c.phase === "test" || c.phase === "implement");
-  let hasTddEvidence;
-  if (tddCards.length > 0) {
-    hasTddEvidence = true;
-    for (const card of tddCards) {
-      const expectedPhase = card.phase === "test" ? "red" : "green";
-      if (!await hasTddRunnerEvidence(projectRoot, card.id, expectedPhase)) {
-        hasTddEvidence = false;
-        break;
-      }
-    }
-  }
-  const report = await analyzeChangeFolder(projectRoot, changePath, {
-    tddRequired,
-    policyText: policyParts.join(`
-`),
-    hasTddEvidence
-  });
+  const sessionResult = await loadBacklogSession(projectRoot);
+  if (!sessionResult.success)
+    return fail(command, [sessionResult.error.message]);
+  const session = sessionResult.data;
+  const resolved = resolveActiveChange(session.state, command, itemId);
+  if (!resolved.ok)
+    return resolved.response;
+  const { report } = await collectAnalyzeReport(projectRoot, session, resolved.targetId, resolved.changePath);
   const data = SpecAnalyzeReportSchema.parse({
     changePath: report.changePath,
     frIds: report.frIds,
@@ -27417,13 +27894,146 @@ async function handleAnalyze(projectRoot, itemId) {
     }
   };
 }
+async function handleSync(projectRoot, itemId) {
+  const command = "openspec sync";
+  const loaded = await loadStateOrFail(projectRoot, command);
+  if (!loaded.ok)
+    return loaded.response;
+  const resolved = resolveActiveChange(loaded.state, command, itemId);
+  if (!resolved.ok)
+    return resolved.response;
+  const synced = await syncChangeSpecs(projectRoot, resolved.changePath);
+  if (!synced.success) {
+    return fail(command, [
+      `Spec sync failed for ${resolved.targetId}: ${synced.errors.join("; ")}`
+    ]);
+  }
+  return {
+    code: 0,
+    data: {
+      success: true,
+      command,
+      itemId: resolved.targetId,
+      changePath: resolved.changePath,
+      syncedPaths: synced.syncedPaths
+    }
+  };
+}
+function analyzeSeverityToVerify(severity) {
+  if (severity === "CRITICAL")
+    return "CRITICAL";
+  if (severity === "HIGH")
+    return "WARNING";
+  return "SUGGESTION";
+}
+async function handleVerify(projectRoot, itemId) {
+  const command = "openspec verify";
+  const sessionResult = await loadBacklogSession(projectRoot);
+  if (!sessionResult.success)
+    return fail(command, [sessionResult.error.message]);
+  const session = sessionResult.data;
+  const resolved = resolveActiveChange(session.state, command, itemId);
+  if (!resolved.ok)
+    return resolved.response;
+  const { targetId, changePath } = resolved;
+  const itemLoaded = findItemOrFail(session, targetId, command);
+  if (!itemLoaded.ok)
+    return itemLoaded.response;
+  const { report } = await collectAnalyzeReport(projectRoot, session, targetId, changePath);
+  const progress = await readArtifactProgress(projectRoot, changePath);
+  const cards = itemCards(session.state, targetId);
+  const doneCount = cards.filter((c) => c.status === "done").length;
+  const issues = [];
+  for (const finding of report.findings) {
+    const dimension = finding.code === "POLICY_CONFLICT" || finding.code === "NEEDS_CLARIFICATION" ? "Coherence" : "Correctness";
+    issues.push({
+      severity: analyzeSeverityToVerify(finding.severity),
+      code: finding.code,
+      message: finding.message,
+      dimension
+    });
+  }
+  if (cards.length === 0) {
+    issues.push({
+      severity: "WARNING",
+      code: "NO_CARDS",
+      message: `No task cards for ${targetId}. Run openspec plan ${targetId}.`,
+      dimension: "Completeness"
+    });
+  } else if (doneCount < cards.length) {
+    const pending = cards.filter((c) => c.status !== "done").map((c) => c.id);
+    issues.push({
+      severity: "WARNING",
+      code: "CARDS_PENDING",
+      message: `${cards.length - doneCount} card(s) not done (${pending.join(", ")}).`,
+      dimension: "Completeness"
+    });
+  }
+  for (const name of missingArtifacts(progress.artifacts)) {
+    issues.push({
+      severity: "WARNING",
+      code: "ARTIFACT_MISSING",
+      message: `Change folder is missing ${name}.`,
+      dimension: "Completeness"
+    });
+  }
+  if (progress.checkboxes.remaining > 0) {
+    issues.push({
+      severity: "WARNING",
+      code: "CHECKBOXES_REMAINING",
+      message: `${progress.checkboxes.remaining} of ${progress.checkboxes.total} tasks.md boxes are unchecked. ` + "Tick them as FRs complete (only [x]/[X] counts).",
+      dimension: "Completeness"
+    });
+  }
+  const scorecardOk = !itemLoaded.reviewRequired || await hasPassingScorecard(projectRoot, targetId);
+  if (!scorecardOk) {
+    issues.push({
+      severity: "WARNING",
+      code: "SCORECARD_PENDING",
+      message: `Global review is required but no PASS scorecard exists for ${targetId}.`,
+      dimension: "Coherence"
+    });
+  }
+  const archiveReady = !issues.some((i) => i.severity === "CRITICAL") && cards.length > 0 && doneCount === cards.length && missingArtifacts(progress.artifacts).length === 0 && scorecardOk;
+  return {
+    code: 0,
+    data: {
+      success: true,
+      command,
+      advisory: true,
+      itemId: targetId,
+      changePath,
+      archiveReady,
+      artifacts: progress.artifacts,
+      checkboxProgress: progress.checkboxes,
+      cardsTotal: cards.length,
+      cardsDone: doneCount,
+      frCoveragePct: report.frCoveragePct,
+      scCoveragePct: report.scCoveragePct,
+      testCoveragePct: report.testCoveragePct,
+      issues
+    }
+  };
+}
 async function handleStatus2(projectRoot) {
-  const loadResult = await loadBacklog(projectRoot);
-  const stateResult = await loadOpenspecState(projectRoot);
-  const nextItem = loadResult.success ? selectNextItem(loadResult.data) : null;
-  const state = stateResult.success ? stateResult.data : null;
+  const sessionResult = await loadBacklogSession(projectRoot);
+  let doc = null;
+  let state = null;
+  if (sessionResult.success) {
+    doc = sessionResult.data.doc;
+    state = sessionResult.data.state;
+  } else if (sessionResult.error instanceof BacklogSessionError) {
+    doc = sessionResult.error.doc;
+    state = sessionResult.error.state;
+  } else {
+    const fallback = await loadOpenspecState(projectRoot);
+    state = fallback.success ? fallback.data : null;
+  }
+  const nextItem = doc ? selectNextItem(doc) : null;
   const pendingCards = state?.taskCards.filter((c) => c.status === "pending").length ?? 0;
   const doneCards = state?.taskCards.filter((c) => c.status === "done").length ?? 0;
+  const changePath = state?.activeItemId ? state.changePaths[state.activeItemId] : undefined;
+  const progress = changePath && !changePath.includes("/archive/") ? await readArtifactProgress(projectRoot, changePath) : undefined;
   return {
     code: 0,
     data: {
@@ -27434,7 +28044,10 @@ async function handleStatus2(projectRoot) {
       nextItemTitle: nextItem?.title,
       taskCardsPending: pendingCards,
       taskCardsDone: doneCards,
-      changePaths: state?.changePaths ?? {}
+      changePaths: state?.changePaths ?? {},
+      artifacts: progress?.artifacts,
+      checkboxProgress: progress?.checkboxes,
+      nextSteps: buildNextSteps({ state, nextItemId: nextItem?.id, progress })
     }
   };
 }
@@ -27486,19 +28099,15 @@ async function loadStateOrFail(projectRoot, command) {
   }
   return { ok: true, state: stateResult.data };
 }
-async function loadItemOrFail(projectRoot, itemId, command) {
-  const loadResult = await loadBacklog(projectRoot);
-  if (!loadResult.success) {
-    return { ok: false, response: fail(command, [loadResult.error.message]) };
-  }
-  const item = loadResult.data.items.find((i) => i.id === itemId) ?? loadResult.data.archive.find((i) => i.id === itemId);
+function findItemOrFail(session, itemId, command) {
+  const item = session.doc.items.find((i) => i.id === itemId) ?? session.doc.archive.find((i) => i.id === itemId);
   if (!item) {
     return { ok: false, response: fail(command, [`Backlog item ${itemId} not found`]) };
   }
   return {
     ok: true,
     item,
-    reviewRequired: loadResult.data.global.reviewRequired
+    reviewRequired: session.doc.global.reviewRequired
   };
 }
 async function handleStart(projectRoot, cardId) {
@@ -27506,27 +28115,28 @@ async function handleStart(projectRoot, cardId) {
   if (!cardId) {
     return fail(command, ["Missing card id. Usage: openspec start <cardId>"]);
   }
-  const loaded = await loadStateOrFail(projectRoot, command);
-  if (!loaded.ok)
-    return loaded.response;
-  const card = findCard(loaded.state, cardId);
+  const sessionResult = await loadBacklogSession(projectRoot);
+  if (!sessionResult.success)
+    return fail(command, [sessionResult.error.message]);
+  const session = sessionResult.data;
+  const card = findCard(session.state, cardId);
   if (!card) {
     return fail(command, [`Task card ${cardId} not found`]);
   }
   if (card.status !== "pending" && card.status !== "doing") {
     return fail(command, [`Card ${cardId} cannot start from status ${card.status}`]);
   }
-  const itemLoaded = await loadItemOrFail(projectRoot, card.backlogId, command);
+  const itemLoaded = findItemOrFail(session, card.backlogId, command);
   if (!itemLoaded.ok)
     return itemLoaded.response;
-  let state = loaded.state;
+  let state = session.state;
   if (card.status === "pending") {
     state = setTaskCardStatus(state, cardId, "doing");
     const written = await persistState(projectRoot, state);
     if (!written.ok)
       return fail(command, [written.error]);
   }
-  const transition = await transitionItem(projectRoot, itemLoaded.item, "IN_PROGRESS", itemLoaded.item.progress);
+  const transition = await transitionItem(projectRoot, itemLoaded.item, "IN_PROGRESS", itemLoaded.item.progress, session.raw);
   if (!transition.ok)
     return fail(command, [transition.error]);
   return {
@@ -27546,10 +28156,11 @@ async function handleDone(projectRoot, cardId) {
   if (!cardId) {
     return fail(command, ["Missing card id. Usage: openspec done <cardId>"]);
   }
-  const loaded = await loadStateOrFail(projectRoot, command);
-  if (!loaded.ok)
-    return loaded.response;
-  const card = findCard(loaded.state, cardId);
+  const sessionResult = await loadBacklogSession(projectRoot);
+  if (!sessionResult.success)
+    return fail(command, [sessionResult.error.message]);
+  const session = sessionResult.data;
+  const card = findCard(session.state, cardId);
   if (!card) {
     return fail(command, [`Task card ${cardId} not found`]);
   }
@@ -27562,11 +28173,10 @@ async function handleDone(projectRoot, cardId) {
   if (card.status !== "doing") {
     return fail(command, [`Card ${cardId} must be doing before done (got ${card.status})`]);
   }
-  const itemLoaded = await loadItemOrFail(projectRoot, card.backlogId, command);
+  const itemLoaded = findItemOrFail(session, card.backlogId, command);
   if (!itemLoaded.ok)
     return itemLoaded.response;
-  const backlog = await loadBacklog(projectRoot);
-  const tddRequired = backlog.success ? backlog.data.global.tddRequired : false;
+  const tddRequired = session.doc.global.tddRequired;
   if (tddRequired && (card.phase === "test" || card.phase === "implement")) {
     const expectedPhase = card.phase === "test" ? "red" : "green";
     const evidenced = await hasTddRunnerEvidence(projectRoot, cardId, expectedPhase);
@@ -27576,7 +28186,7 @@ async function handleDone(projectRoot, cardId) {
       ]);
     }
   }
-  const state = setTaskCardStatus(loaded.state, cardId, "done");
+  const state = setTaskCardStatus(session.state, cardId, "done");
   const cards = itemCards(state, card.backlogId);
   const doneCount = cards.filter((c) => c.status === "done").length;
   const progress = cards.length === 0 ? 0 : Math.round(doneCount / cards.length * 100);
@@ -27592,7 +28202,7 @@ async function handleDone(projectRoot, cardId) {
     });
   }
   const nextStatus = allDone ? "REVIEW" : "IN_PROGRESS";
-  const transition = await transitionItem(projectRoot, itemLoaded.item, nextStatus, progress);
+  const transition = await transitionItem(projectRoot, itemLoaded.item, nextStatus, progress, session.raw);
   if (!transition.ok)
     return fail(command, [transition.error]);
   return {
@@ -27617,21 +28227,22 @@ async function handleBlock(projectRoot, cardId, reason) {
   if (!reason || !reason.trim()) {
     return fail(command, ["--reason is required"]);
   }
-  const loaded = await loadStateOrFail(projectRoot, command);
-  if (!loaded.ok)
-    return loaded.response;
-  const card = findCard(loaded.state, cardId);
+  const sessionResult = await loadBacklogSession(projectRoot);
+  if (!sessionResult.success)
+    return fail(command, [sessionResult.error.message]);
+  const session = sessionResult.data;
+  const card = findCard(session.state, cardId);
   if (!card) {
     return fail(command, [`Task card ${cardId} not found`]);
   }
-  const itemLoaded = await loadItemOrFail(projectRoot, card.backlogId, command);
+  const itemLoaded = findItemOrFail(session, card.backlogId, command);
   if (!itemLoaded.ok)
     return itemLoaded.response;
-  const state = setTaskCardStatus(loaded.state, cardId, "blocked");
+  const state = setTaskCardStatus(session.state, cardId, "blocked");
   const written = await persistState(projectRoot, state);
   if (!written.ok)
     return fail(command, [written.error]);
-  const transition = await transitionItem(projectRoot, itemLoaded.item, "BLOCKED");
+  const transition = await transitionItem(projectRoot, itemLoaded.item, "BLOCKED", undefined, session.raw);
   if (!transition.ok)
     return fail(command, [transition.error]);
   return {
@@ -27652,17 +28263,18 @@ async function handleUnblock(projectRoot, cardId) {
   if (!cardId) {
     return fail(command, ["Missing card id. Usage: openspec unblock <cardId>"]);
   }
-  const loaded = await loadStateOrFail(projectRoot, command);
-  if (!loaded.ok)
-    return loaded.response;
-  const card = findCard(loaded.state, cardId);
+  const sessionResult = await loadBacklogSession(projectRoot);
+  if (!sessionResult.success)
+    return fail(command, [sessionResult.error.message]);
+  const session = sessionResult.data;
+  const card = findCard(session.state, cardId);
   if (!card) {
     return fail(command, [`Task card ${cardId} not found`]);
   }
   if (card.status !== "blocked") {
     return fail(command, [`Card ${cardId} must be blocked before unblock (got ${card.status})`]);
   }
-  const itemLoaded = await loadItemOrFail(projectRoot, card.backlogId, command);
+  const itemLoaded = findItemOrFail(session, card.backlogId, command);
   if (!itemLoaded.ok)
     return itemLoaded.response;
   if (itemLoaded.item.status !== "BLOCKED") {
@@ -27670,19 +28282,18 @@ async function handleUnblock(projectRoot, cardId) {
       `Backlog item ${itemLoaded.item.id} must be BLOCKED before unblock (got ${itemLoaded.item.status})`
     ]);
   }
-  const state = setTaskCardStatus(loaded.state, cardId, "pending");
+  const state = setTaskCardStatus(session.state, cardId, "pending");
   const written = await persistState(projectRoot, state);
   if (!written.ok)
     return fail(command, [written.error]);
   const changePath = state.changePaths[card.backlogId];
   if (changePath) {
-    const backlog = await loadBacklog(projectRoot);
     await writeTasksMarkdown(projectRoot, changePath, itemCards(state, card.backlogId), {
-      tddRequired: backlog.success ? backlog.data.global.tddRequired : false,
+      tddRequired: session.doc.global.tddRequired,
       acceptanceCriteria: itemLoaded.item.acceptanceCriteria
     });
   }
-  const transition = await transitionItem(projectRoot, itemLoaded.item, "READY");
+  const transition = await transitionItem(projectRoot, itemLoaded.item, "READY", undefined, session.raw);
   if (!transition.ok)
     return fail(command, [transition.error]);
   return {
@@ -27703,13 +28314,14 @@ async function handleArchive(projectRoot, itemId) {
   if (!itemId) {
     return fail(command, ["Missing item id. Usage: openspec archive <itemId>"]);
   }
-  const loaded = await loadStateOrFail(projectRoot, command);
-  if (!loaded.ok)
-    return loaded.response;
-  const itemLoaded = await loadItemOrFail(projectRoot, itemId, command);
+  const sessionResult = await loadBacklogSession(projectRoot);
+  if (!sessionResult.success)
+    return fail(command, [sessionResult.error.message]);
+  const session = sessionResult.data;
+  const itemLoaded = findItemOrFail(session, itemId, command);
   if (!itemLoaded.ok)
     return itemLoaded.response;
-  const cards = itemCards(loaded.state, itemId);
+  const cards = itemCards(session.state, itemId);
   if (cards.length === 0) {
     return fail(command, [`No task cards found for ${itemId}. Run openspec plan first.`]);
   }
@@ -27734,8 +28346,26 @@ async function handleArchive(projectRoot, itemId) {
     }
   }
   let archivedPath;
-  const changePath = loaded.state.changePaths[itemId];
+  const changePath = session.state.changePaths[itemId];
+  const warnings = [];
   if (changePath && !changePath.includes("/archive/")) {
+    const progress = await readArtifactProgress(projectRoot, changePath);
+    const missing = missingArtifacts(progress.artifacts);
+    if (missing.length > 0) {
+      return fail(command, [
+        `Cannot archive ${itemId}: change folder is missing ${missing.join(", ")}. Re-run openspec plan ${itemId} or restore them.`
+      ]);
+    }
+    const { report } = await collectAnalyzeReport(projectRoot, session, itemId, changePath);
+    const critical = report.findings.filter((f) => f.severity === "CRITICAL");
+    if (critical.length > 0) {
+      return fail(command, [
+        `Cannot archive ${itemId}: analyze reports ${critical.length} CRITICAL finding(s): ${critical.map((f) => f.code).join(", ")}. Resolve them first.`
+      ]);
+    }
+    if (progress.checkboxes.remaining > 0) {
+      warnings.push(`${progress.checkboxes.remaining} of ${progress.checkboxes.total} tasks.md checkboxes are unchecked; tick them as FRs complete (only [x]/[X] counts as done).`);
+    }
     const synced = await syncChangeSpecs(projectRoot, changePath);
     if (!synced.success) {
       return fail(command, [`Cannot archive ${itemId}: spec sync failed: ${synced.errors.join("; ")}`]);
@@ -27748,18 +28378,19 @@ async function handleArchive(projectRoot, itemId) {
       ]);
     }
   }
+  let content = session.raw;
   if (itemLoaded.item.status !== "DONE") {
-    const toDone = await transitionItem(projectRoot, itemLoaded.item, "DONE", 100);
+    const toDone = await transitionItem(projectRoot, itemLoaded.item, "DONE", 100, content);
     if (!toDone.ok)
       return fail(command, [toDone.error]);
+    content = toDone.content;
   }
-  const content = await readBacklogMarkdown(projectRoot);
   const archived = archiveItemInMarkdown(content, itemId);
   await persistBacklog(projectRoot, archived);
   const nextState = {
-    ...loaded.state,
-    activeItemId: loaded.state.activeItemId === itemId ? undefined : loaded.state.activeItemId,
-    changePaths: archivedPath ? { ...loaded.state.changePaths, [itemId]: archivedPath } : loaded.state.changePaths
+    ...session.state,
+    activeItemId: session.state.activeItemId === itemId ? undefined : session.state.activeItemId,
+    changePaths: archivedPath ? { ...session.state.changePaths, [itemId]: archivedPath } : session.state.changePaths
   };
   const written = await persistState(projectRoot, nextState);
   if (!written.ok)
@@ -27770,20 +28401,21 @@ async function handleArchive(projectRoot, itemId) {
       success: true,
       command,
       itemId,
-      archivedPath: archivedPath ?? changePath
+      archivedPath: archivedPath ?? changePath,
+      warnings
     }
   };
 }
-var KNOWN_SUBCOMMANDS = "validate, scan, plan, analyze, status, next, start, done, block, unblock, archive";
+var KNOWN_SUBCOMMANDS = "validate, scan, plan, analyze, status, next, start, done, block, unblock, archive, sync, verify";
 var init_openspec_command = __esm(() => {
-  init_backlog_parser();
-  init_backlog_validator();
+  init_backlog_session();
   init_backlog_scanner();
   init_backlog_planner();
   init_openspec_generator();
   init_spec_quality();
   init_spec_analyzer();
   init_spec_sync();
+  init_artifact_progress();
   init_schemas();
   init_verification_runner();
   init_outcome_store();
@@ -27841,24 +28473,24 @@ var init_handoff_envelope = __esm(() => {
 
 // src/core/delivery/delivery-ledger.ts
 import { createHash as createHash7 } from "node:crypto";
-import { mkdir as mkdir24, readFile as readFile39, writeFile as writeFile23 } from "node:fs/promises";
-import { resolve as resolve37, sep as sep8 } from "node:path";
+import { mkdir as mkdir23, readFile as readFile41, writeFile as writeFile22 } 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))
     throw new Error("Invalid delivery ledger id");
-  return resolve37(projectRoot, DELIVERY_DIR, `${id}.md`);
+  return resolve38(projectRoot, DELIVERY_DIR, `${id}.md`);
 }
 async function fingerprintWorkspace(projectRoot, paths) {
-  const root = resolve37(projectRoot);
+  const root = resolve38(projectRoot);
   const fingerprints = {};
   for (const path of paths) {
-    const candidate = resolve37(root, path);
-    if (candidate !== root && !candidate.startsWith(`${root}${sep8}`)) {
+    const candidate = resolve38(root, path);
+    if (candidate !== root && !candidate.startsWith(`${root}${sep9}`)) {
       fingerprints[path] = "outside-root";
       continue;
     }
     try {
-      fingerprints[path] = createHash7("sha256").update(await readFile39(candidate)).digest("hex");
+      fingerprints[path] = createHash7("sha256").update(await readFile41(candidate)).digest("hex");
     } catch {
       fingerprints[path] = "missing";
     }
@@ -27881,7 +28513,7 @@ function parseLedger(content) {
   return DeliveryLedgerSchema.parse($parse(match[1]));
 }
 async function loadDeliveryLedger(projectRoot, id) {
-  return parseLedger(await readFile39(ledgerPath(projectRoot, id), "utf-8"));
+  return parseLedger(await readFile41(ledgerPath(projectRoot, id), "utf-8"));
 }
 async function createDeliveryLedger(projectRoot, input) {
   const request = DeliveryLedgerRequestSchema.parse(input);
@@ -27906,9 +28538,9 @@ async function createDeliveryLedger(projectRoot, input) {
     createdAt: now,
     updatedAt: now
   });
-  await mkdir24(resolve37(projectRoot, DELIVERY_DIR), { recursive: true });
+  await mkdir23(resolve38(projectRoot, DELIVERY_DIR), { recursive: true });
   try {
-    await writeFile23(path, render(ledger), { encoding: "utf-8", flag: "wx" });
+    await writeFile22(path, render(ledger), { encoding: "utf-8", flag: "wx" });
     return { created: true, ledger };
   } catch (error) {
     if (error instanceof Error && error.message.includes("EEXIST")) {
@@ -28151,6 +28783,9 @@ function formatHookOutput(verdict, format) {
 function claudeExitCode(verdict) {
   return verdict.action === "deny" ? 2 : 0;
 }
+function parseMusePayload(stdinText) {
+  return parseClaudePayload(stdinText);
+}
 function parseAgyPayload(raw) {
   if (!raw.trim())
     return {};
@@ -28232,12 +28867,16 @@ var init_hook_runner = __esm(() => {
 var exports_hook_command = {};
 __export(exports_hook_command, {
   hookCommand: () => hookCommand,
+  parseHookFormat: () => parseHookFormat,
   readStdinText: () => readStdinText
 });
 import { spawnSync } from "node:child_process";
 import { existsSync as existsSync8, readFileSync as readFileSync5 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname13, resolve as resolve38 } from "node:path";
+import { dirname as dirname12, resolve as resolve39 } from "node:path";
+function parseHookFormat(raw) {
+  return raw === "agy" || raw === "claude" || raw === "muse" ? raw : undefined;
+}
 function detectFormat(explicit, stdinText) {
   if (explicit)
     return explicit;
@@ -28258,7 +28897,7 @@ async function readStdinText() {
   return Buffer.concat(chunks).toString("utf8");
 }
 function resolvePreToolInput(options, stdinText, format) {
-  const fromStdin = format === "agy" ? parseAgyPayload(stdinText) : parseClaudePayload(stdinText);
+  const fromStdin = format === "agy" ? parseAgyPayload(stdinText) : format === "muse" ? parseMusePayload(stdinText) : parseClaudePayload(stdinText);
   return {
     command: options.command ?? (process.env.CLAUDE_TOOL_INPUT_COMMAND || undefined) ?? fromStdin.command,
     filePath: options.filePath ?? (process.env.CLAUDE_TOOL_INPUT_FILE_PATH || undefined) ?? fromStdin.filePath,
@@ -28266,8 +28905,8 @@ function resolvePreToolInput(options, stdinText, format) {
   };
 }
 async function sessionLines(projectRoot) {
-  const backlogPath = resolve38(projectRoot, "BACKLOG.md");
-  const profilePath = resolve38(projectRoot, ".codeconductor", "evaluation", "execution-profile.yml");
+  const backlogPath = resolve39(projectRoot, "BACKLOG.md");
+  const profilePath = resolve39(projectRoot, ".codeconductor", "evaluation", "execution-profile.yml");
   return [
     "[CodeConductor] Session start",
     "Skills: openspec, backlog, evaluation, testing-tdd — invoke via /cc-* then CLI.",
@@ -28322,21 +28961,21 @@ async function hookCommand(options) {
 function formatWrittenFile(filePath, projectRoot) {
   if (!filePath)
     return;
-  filePath = resolve38(projectRoot, filePath);
+  filePath = resolve39(projectRoot, filePath);
   if (!existsSync8(filePath))
     return;
   const prettier = /\.(ts|tsx|js|jsx|mjs|cjs|json|jsonc|md|mdx|css|scss|html|astro|ya?ml)$/i;
   const eslint = /\.(ts|tsx|js|jsx|mjs|cjs)$/i;
   const python = /\.py$/i;
   const opts = { cwd: projectRoot, stdio: "ignore", windowsHide: true, timeout: 5000 };
-  const require2 = createRequire2(resolve38(projectRoot, "package.json"));
+  const require2 = createRequire2(resolve39(projectRoot, "package.json"));
   function runNodeTool(name, args) {
     try {
       const manifestPath = require2.resolve(`${name}/package.json`);
       const manifest = JSON.parse(readFileSync5(manifestPath, "utf8"));
       const bin = typeof manifest.bin === "string" ? manifest.bin : manifest.bin?.[name];
       if (typeof bin === "string")
-        spawnSync(process.execPath, [resolve38(dirname13(manifestPath), bin), ...args], opts);
+        spawnSync(process.execPath, [resolve39(dirname12(manifestPath), bin), ...args], opts);
     } catch {}
   }
   if (prettier.test(filePath)) {
@@ -28875,24 +29514,24 @@ var init_scorecard_signals = __esm(() => {
 
 // src/core/evaluation/harness-experiment.ts
 import { existsSync as existsSync9 } from "node:fs";
-import { cp, mkdir as mkdir25, readFile as readFile40, readdir as readdir14, writeFile as writeFile24 } from "node:fs/promises";
-import { dirname as dirname14, join as join26, resolve as resolve39 } from "node:path";
+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";
 function experimentDir(projectRoot, experimentId) {
-  return resolve39(projectRoot, EVAL_DIR2, EXPERIMENTS_DIR, experimentId);
+  return resolve40(projectRoot, EVAL_DIR2, EXPERIMENTS_DIR, experimentId);
 }
 function experimentYamlPath(projectRoot, experimentId) {
-  return join26(experimentDir(projectRoot, experimentId), "experiment.yml");
+  return join29(experimentDir(projectRoot, experimentId), "experiment.yml");
 }
 async function loadHarnessSuite(projectRoot, suiteId, suitePath) {
   const candidates = suitePath ? [suitePath] : [
-    resolve39(projectRoot, "eval", "suites", suiteId, "suite.yml"),
-    resolve39(projectRoot, EVAL_DIR2, "suites", suiteId, "suite.yml")
+    resolve40(projectRoot, "eval", "suites", suiteId, "suite.yml"),
+    resolve40(projectRoot, EVAL_DIR2, "suites", suiteId, "suite.yml")
   ];
   for (const path of candidates) {
     if (!existsSync9(path))
       continue;
     try {
-      const suite = HarnessSuiteSchema.parse($parse(await readFile40(path, "utf-8")));
+      const suite = HarnessSuiteSchema.parse($parse(await readFile42(path, "utf-8")));
       return ok({ ...suite, path });
     } catch (e) {
       return err(e instanceof Error ? e : new Error(String(e)));
@@ -28902,7 +29541,7 @@ async function loadHarnessSuite(projectRoot, suiteId, suitePath) {
 }
 async function loadExperiment(projectRoot, experimentId) {
   try {
-    const raw = await readFile40(experimentYamlPath(projectRoot, experimentId), "utf-8");
+    const raw = await readFile42(experimentYamlPath(projectRoot, experimentId), "utf-8");
     return ok(HarnessExperimentSchema.parse($parse(raw)));
   } catch (e) {
     if (e.code === "ENOENT") {
@@ -28912,10 +29551,10 @@ async function loadExperiment(projectRoot, experimentId) {
   }
 }
 async function listExperiments(projectRoot) {
-  const root = resolve39(projectRoot, EVAL_DIR2, EXPERIMENTS_DIR);
+  const root = resolve40(projectRoot, EVAL_DIR2, EXPERIMENTS_DIR);
   if (!existsSync9(root))
     return [];
-  const ids = await readdir14(root);
+  const ids = await readdir13(root);
   const experiments = [];
   for (const id of ids) {
     const loaded = await loadExperiment(projectRoot, id);
@@ -28991,8 +29630,8 @@ function generateExperimentId(suiteId, now = new Date) {
   return `abl-${date}-${suiteId}-${rand}`;
 }
 async function copyFixture(suitePath, fixtureDir, dest) {
-  const source = fixtureDir ? resolve39(dirname14(suitePath), fixtureDir) : join26(dirname14(suitePath), "fixture");
-  await mkdir25(dest, { recursive: true });
+  const source = fixtureDir ? resolve40(dirname13(suitePath), fixtureDir) : join29(dirname13(suitePath), "fixture");
+  await mkdir24(dest, { recursive: true });
   if (existsSync9(source)) {
     await cp(source, dest, { recursive: true });
   }
@@ -29014,12 +29653,12 @@ async function startHarnessExperiment(projectRoot, options) {
     suitePath: suite.data.path
   };
   const root = experimentDir(projectRoot, experimentId);
-  await mkdir25(root, { recursive: true });
-  await writeFile24(experimentYamlPath(projectRoot, experimentId), $stringify(experiment), "utf-8");
-  await writeFile24(join26(root, "EXPERIMENT.md"), formatExperimentMarkdown(experiment), "utf-8");
+  await mkdir24(root, { recursive: true });
+  await writeFile23(experimentYamlPath(projectRoot, experimentId), $stringify(experiment), "utf-8");
+  await writeFile23(join29(root, "EXPERIMENT.md"), formatExperimentMarkdown(experiment), "utf-8");
   for (const task of suite.data.tasks) {
     for (const variantId of variants) {
-      const runRoot = join26(root, "runs", task.id, variantDirName(variantId));
+      const runRoot = join29(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);
@@ -29031,7 +29670,7 @@ async function startHarnessExperiment(projectRoot, options) {
       });
       if (!overlay.success)
         return overlay;
-      await writeFile24(join26(runRoot, "TASK.md"), formatTaskCard(task, experimentId, variantId), "utf-8");
+      await writeFile23(join29(runRoot, "TASK.md"), formatTaskCard(task, experimentId, variantId), "utf-8");
     }
   }
   return ok(experiment);
@@ -29066,7 +29705,7 @@ var init_harness_experiment = __esm(() => {
 // src/core/evaluation/suite-run.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { existsSync as existsSync10 } from "node:fs";
-import { resolve as resolve40 } from "node:path";
+import { resolve as resolve41 } from "node:path";
 async function runHarnessSuiteTasks(projectRoot, suiteId, suitePath) {
   const suite = await loadHarnessSuite(projectRoot, suiteId, suitePath);
   if (!suite.success) {
@@ -29126,7 +29765,7 @@ function runTaskCommand(projectRoot, task) {
   if (parts.length === 0) {
     return { ok: false, detail: "Empty testCommand" };
   }
-  const bin = parts[0] === "bun" && existsSync10(resolve40(projectRoot, "src/cli/main.ts")) ? "bun" : parts[0];
+  const bin = parts[0] === "bun" && existsSync10(resolve41(projectRoot, "src/cli/main.ts")) ? "bun" : parts[0];
   const args = parts[0] === "bun" ? parts.slice(1) : parts.slice(1);
   const result = spawnSync2(bin, args, {
     cwd: projectRoot,
@@ -29177,11 +29816,11 @@ var init_suite_run = __esm(() => {
 });
 
 // src/core/evaluation/execution-profile.ts
-import { readFile as readFile41 } from "node:fs/promises";
-import { resolve as resolve41 } from "node:path";
+import { readFile as readFile43 } from "node:fs/promises";
+import { resolve as resolve42 } from "node:path";
 async function loadExecutionProfile(projectRoot, defaultTarget = "opencode") {
   try {
-    const content = await readFile41(resolve41(projectRoot, PROFILE_FILE), "utf-8");
+    const content = await readFile43(resolve42(projectRoot, PROFILE_FILE), "utf-8");
     const data = $parse(content);
     return ExecutionProfileSchema.parse(data);
   } catch {
@@ -29261,14 +29900,14 @@ var init_execution_profile = __esm(() => {
 });
 
 // src/core/evaluation/prompt-diff.ts
-import { readFile as readFile42, readdir as readdir15 } from "node:fs/promises";
-import { join as join27, resolve as resolve42 } from "node:path";
+import { readFile as readFile44, readdir as readdir14 } from "node:fs/promises";
+import { join as join30, resolve as resolve43 } from "node:path";
 function normalizeVersion(v) {
   return v.startsWith("v") ? v : `v${v}`;
 }
 async function listPromptFiles(dir) {
   try {
-    const entries = await readdir15(dir, { withFileTypes: true });
+    const entries = await readdir14(dir, { withFileTypes: true });
     return entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => e.name);
   } catch {
     return [];
@@ -29311,30 +29950,30 @@ async function diffPromptVersions(fromVersion, toVersion, options = {}) {
   const fromV = normalizeVersion(fromVersion);
   const toV = normalizeVersion(toVersion);
   const searchRoots = [
-    resolve42(options.projectRoot ?? PACKAGE_ROOT, ".agents", "prompts"),
-    join27(ROOT_PRESETS_DIR, target, "prompts"),
-    join27(ROOT_PRESETS_DIR, "opencode", "prompts")
+    resolve43(options.projectRoot ?? PACKAGE_ROOT, ".agents", "prompts"),
+    join30(ROOT_PRESETS_DIR, target, "prompts"),
+    join30(ROOT_PRESETS_DIR, "opencode", "prompts")
   ];
   let fromDir = "";
   let toDir = "";
   for (const root of searchRoots) {
-    const f = join27(root, fromV);
-    const t = join27(root, toV);
+    const f = join30(root, fromV);
+    const t = join30(root, toV);
     try {
-      await readFile42(join27(f, "orchestrator.md"), "utf-8");
+      await readFile44(join30(f, "orchestrator.md"), "utf-8");
       fromDir = f;
       toDir = t;
       break;
     } catch {}
   }
   if (!fromDir) {
-    fromDir = join27(ROOT_PRESETS_DIR, "opencode", "prompts", fromV);
-    toDir = join27(ROOT_PRESETS_DIR, "opencode", "prompts", toV);
+    fromDir = join30(ROOT_PRESETS_DIR, "opencode", "prompts", fromV);
+    toDir = join30(ROOT_PRESETS_DIR, "opencode", "prompts", toV);
   } else {
     try {
-      await readFile42(join27(toDir, "orchestrator.md"), "utf-8");
+      await readFile44(join30(toDir, "orchestrator.md"), "utf-8");
     } catch {
-      toDir = join27(ROOT_PRESETS_DIR, "opencode", "prompts", toV);
+      toDir = join30(ROOT_PRESETS_DIR, "opencode", "prompts", toV);
     }
   }
   const fromFiles = await listPromptFiles(fromDir);
@@ -29352,12 +29991,12 @@ async function diffPromptVersions(fromVersion, toVersion, options = {}) {
     let oldText = "";
     let newText = "";
     try {
-      oldText = await readFile42(join27(fromDir, name), "utf-8");
+      oldText = await readFile44(join30(fromDir, name), "utf-8");
     } catch {
       oldText = "";
     }
     try {
-      newText = await readFile42(join27(toDir, name), "utf-8");
+      newText = await readFile44(join30(toDir, name), "utf-8");
     } catch {
       newText = "";
     }
@@ -29397,12 +30036,12 @@ var init_prompt_diff = __esm(() => {
 
 // src/core/evaluation/regression-checklist.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { mkdir as mkdir26, readFile as readFile43, writeFile as writeFile25 } from "node:fs/promises";
-import { dirname as dirname15, resolve as resolve43 } from "node:path";
+import { mkdir as mkdir25, readFile as readFile45, writeFile as writeFile24 } from "node:fs/promises";
+import { dirname as dirname14, resolve as resolve44 } from "node:path";
 async function loadRegressionChecklist() {
   try {
-    const path = resolve43(ROOT_PRESETS_DIR, "templates", "regression-checklist.yml");
-    const content = await readFile43(path, "utf-8");
+    const path = resolve44(ROOT_PRESETS_DIR, "templates", "regression-checklist.yml");
+    const content = await readFile45(path, "utf-8");
     const data = $parse(content);
     return data.checks ?? [];
   } catch {
@@ -29457,9 +30096,9 @@ async function runRegressionChecklist(projectRoot, options = {}) {
       checks,
       timestamp: new Date().toISOString()
     };
-    const outPath = resolve43(projectRoot, ".codeconductor/evaluation/regression-last.json");
-    await mkdir26(dirname15(outPath), { recursive: true });
-    await writeFile25(outPath, JSON.stringify(report, null, 2), "utf-8");
+    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");
     return ok(report);
   } catch (e) {
     return err(e instanceof Error ? e : new Error(String(e)));
@@ -29501,8 +30140,8 @@ var init_model_comparison = __esm(() => {
 });
 
 // src/core/evaluation/cost-quality-matrix.ts
-import { writeFile as writeFile26 } from "node:fs/promises";
-import { resolve as resolve44 } from "node:path";
+import { writeFile as writeFile25 } from "node:fs/promises";
+import { resolve as resolve45 } from "node:path";
 async function buildCostQualityMatrix(projectRoot, outcomes) {
   const agg = aggregateOutcomes(outcomes);
   const rows = Object.entries(agg.byModel).map(([model, entry]) => {
@@ -29522,7 +30161,7 @@ async function buildCostQualityMatrix(projectRoot, outcomes) {
     rows
   };
   const dir = await ensureEvaluationDir(projectRoot);
-  await writeFile26(resolve44(dir, "matrix.yml"), $stringify(matrix), "utf-8");
+  await writeFile25(resolve45(dir, "matrix.yml"), $stringify(matrix), "utf-8");
   return matrix;
 }
 function formatMatrixMarkdown(matrix) {
@@ -29546,8 +30185,8 @@ var init_cost_quality_matrix = __esm(() => {
 });
 
 // src/core/evaluation/ablation-report.ts
-import { mkdir as mkdir27, writeFile as writeFile27 } from "node:fs/promises";
-import { resolve as resolve45 } from "node:path";
+import { mkdir as mkdir26, writeFile as writeFile26 } from "node:fs/promises";
+import { resolve as resolve46 } from "node:path";
 function isPass(o) {
   return o.verdict === "PASS" || o.status === "pass";
 }
@@ -29715,10 +30354,10 @@ function formatAblationMarkdown(report) {
 `);
 }
 async function persistAblationReport(projectRoot, markdown) {
-  const dir = resolve45(projectRoot, EVAL_DIR2);
-  await mkdir27(dir, { recursive: true });
-  const path = resolve45(dir, "ablation-last.md");
-  await writeFile27(path, markdown, "utf-8");
+  const dir = resolve46(projectRoot, EVAL_DIR2);
+  await mkdir26(dir, { recursive: true });
+  const path = resolve46(dir, "ablation-last.md");
+  await writeFile26(path, markdown, "utf-8");
   return path;
 }
 var SCORE_THRESHOLD = 0.1, PASS_RATE_THRESHOLD = 0.05;
@@ -29732,8 +30371,8 @@ var exports_scorecard_command = {};
 __export(exports_scorecard_command, {
   scorecardCommand: () => scorecardCommand
 });
-import { readFile as readFile44 } from "node:fs/promises";
-import { resolve as resolve46 } from "node:path";
+import { readFile as readFile46 } from "node:fs/promises";
+import { resolve as resolve47 } from "node:path";
 function contractVersion() {
   return package_default.version;
 }
@@ -30021,13 +30660,13 @@ async function handleCompareModels(projectRoot, options) {
     outcomes = outcomes.filter((o) => options.modelsFilter.includes(o.model));
   }
   const markdown = generateModelComparisonMarkdown(outcomes, options.modelsFilter);
-  const templatePath = resolve46(projectRoot, ".codeconductor/evaluation/model-comparison-last.md");
+  const templatePath = resolve47(projectRoot, ".codeconductor/evaluation/model-comparison-last.md");
   try {
-    await readFile44(templatePath);
+    await readFile46(templatePath);
   } catch {}
-  const { writeFile: writeFile28, mkdir: mkdir28 } = await import("node:fs/promises");
-  await mkdir28(resolve46(projectRoot, ".codeconductor/evaluation"), { recursive: true });
-  await writeFile28(templatePath, markdown, "utf-8");
+  const { writeFile: writeFile27, mkdir: mkdir27 } = await import("node:fs/promises");
+  await mkdir27(resolve47(projectRoot, ".codeconductor/evaluation"), { recursive: true });
+  await writeFile27(templatePath, markdown, "utf-8");
   return {
     code: 0,
     data: {
@@ -31496,7 +32135,7 @@ var exports_seo_audit_command = {};
 __export(exports_seo_audit_command, {
   seoAuditCommand: () => seoAuditCommand
 });
-import { join as join28 } from "node:path";
+import { join as join31 } from "node:path";
 async function seoAuditCommand(options) {
   const { url, sitemap, format, failOn, delay: delay2, output, followRedirects, force } = options;
   if (!url && !sitemap) {
@@ -31509,7 +32148,7 @@ async function seoAuditCommand(options) {
       }
     };
   }
-  const defaultMarkdownPath = output === undefined && format === "markdown" ? join28("seo-reports", `audit-report-${new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19)}.md`) : undefined;
+  const defaultMarkdownPath = output === undefined && format === "markdown" ? join31("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 });
@@ -31871,7 +32510,7 @@ var COMMANDS = [
   { name: "detect", group: "getting-started", summary: "Inspect the project stack and recommended presets.", usage: ["cc-codeconductor detect"] },
   { name: "init", group: "getting-started", summary: "Initialize low-level CodeConductor configuration.", usage: ["cc-codeconductor init [--locale en|es]"] },
   { name: "usage", group: "getting-started", summary: "Show installation examples for presets, council, and LSP.", usage: ["cc-codeconductor usage"] },
-  { name: "install", group: "getting-started", summary: "Install harness components.", usage: ["cc-codeconductor install preset --target <target>"], options: ["--target opencode|claude|codex|gemini|cursor|agy|pi|all"], subcommands: [
+  { name: "install", group: "getting-started", summary: "Install harness components.", usage: ["cc-codeconductor install preset --target <target>"], options: ["--target opencode|claude|codex|gemini|cursor|agy|pi|muse|all"], subcommands: [
     { name: "preset", group: "getting-started", summary: "Install agents, prompts, skills, and commands.", usage: ["cc-codeconductor install preset --target <target> [--locale en|es]"] },
     { name: "council", group: "getting-started", summary: "Install generated council files.", usage: ["cc-codeconductor install council --target <target>"] },
     { name: "lsp", group: "getting-started", summary: "Install supported language servers.", usage: ["cc-codeconductor install lsp --target <target> [--lang typescript,python]"] }
@@ -31965,7 +32604,7 @@ function renderDocs(command, bin = "cc-codeconductor") {
 }
 function renderCompletion(shell) {
   const names = COMMANDS.flatMap((item) => [item.name, ...item.aliases ?? []]).join(" ");
-  const targets = "opencode claude codex gemini cursor agy pi all";
+  const targets = "opencode claude codex gemini cursor agy pi muse all";
   if (shell === "bash")
     return `_cc(){ local cur="${"${COMP_WORDS[COMP_CWORD]}"}"; local prev="${"${COMP_WORDS[COMP_CWORD-1]}"}"; if [[ "$prev" == "--target" ]]; then COMPREPLY=( $(compgen -W "${targets}" -- "$cur") ); else COMPREPLY=( $(compgen -W "${names}" -- "$cur") ); fi; }
 complete -F _cc cc-codeconductor codeconductor cc`;
@@ -32517,7 +33156,11 @@ async function routeCommand(args, projectRoot) {
         taskId: options["task-id"],
         contextStrategy: options["context-strategy"],
         config: options.config,
-        rest: validateRest
+        rest: validateRest,
+        panel: options.panel === true || options.panel === "true",
+        panelType: options.type,
+        panelScope: options.scope,
+        panelRisk: options.risk
       });
     }
     case "openspec":
@@ -32533,7 +33176,9 @@ async function routeCommand(args, projectRoot) {
         "done",
         "block",
         "unblock",
-        "archive"
+        "archive",
+        "sync",
+        "verify"
       ];
       let openspecSub = "validate";
       let itemId = options.item || undefined;
@@ -32574,9 +33219,8 @@ async function routeCommand(args, projectRoot) {
         return unknownSubcommand(command, subcommand, [...validHookEvents]);
       }
       const event = validHookEvents.includes(subcommand) ? subcommand : "pre-tool";
-      const formatRaw = options.format;
-      const format = formatRaw === "agy" || formatRaw === "claude" ? formatRaw : undefined;
-      const { hookCommand: hookCommand2, readStdinText: readStdinText2 } = await Promise.resolve().then(() => (init_hook_command(), exports_hook_command));
+      const { hookCommand: hookCommand2, parseHookFormat: parseHookFormat2, readStdinText: readStdinText2 } = await Promise.resolve().then(() => (init_hook_command(), exports_hook_command));
+      const format = parseHookFormat2(options.format);
       const stdinText = await readStdinText2();
       return hookCommand2({
         event,