cc-codeconductor 1.4.1 → 1.5.0

package/dist/index.js

@@ -72,7 +72,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "cc-codeconductor",
-    version: "1.4.1",
+    version: "1.5.0",
     description: "A multi-agent orchestration framework for AI-assisted software engineering workflows.",
     keywords: [
       "ai",
@@ -11206,6 +11206,11 @@ __export(exports_schemas, {
   CouncilVerdictInputSchema: () => CouncilVerdictInputSchema,
   CouncilVerdictSchema: () => CouncilVerdictSchema,
   DecisionSchema: () => DecisionSchema,
+  DeliveryLedgerRequestSchema: () => DeliveryLedgerRequestSchema,
+  DeliveryLedgerSchema: () => DeliveryLedgerSchema,
+  DeliveryLedgerTaskSchema: () => DeliveryLedgerTaskSchema,
+  DeliveryRouteSchema: () => DeliveryRouteSchema,
+  DeliveryTelemetrySchema: () => DeliveryTelemetrySchema,
   EvaluationIndexSchema: () => EvaluationIndexSchema,
   EvidenceSchema: () => EvidenceSchema,
   ExecutionContextSchema: () => ExecutionContextSchema,
@@ -11270,6 +11275,7 @@ __export(exports_schemas, {
   TaskOutcomeSourceSchema: () => TaskOutcomeSourceSchema,
   TaskOutcomeStatusSchema: () => TaskOutcomeStatusSchema,
   TechnicalPlanOutputSchema: () => TechnicalPlanOutputSchema,
+  TokenUsageSchema: () => TokenUsageSchema,
   ToolProviderNamesSchema: () => ToolProviderNamesSchema,
   VerificationReportSchema: () => VerificationReportSchema,
   WorkflowCommandSchema: () => WorkflowCommandSchema,
@@ -11433,7 +11439,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, ScorecardVerdictSchema, ScorecardCriterionIdSchema, ScorecardCriterionSchema, ScorecardRecordSchema, TaskOutcomeSourceSchema, TaskOutcomeStatusSchema, TaskOutcomeSchema, HarnessComponentIdSchema, HarnessComponentLayerSchema, HarnessToggleKindSchema, HarnessCatalogEntrySchema, HarnessCatalogSchema, HarnessOverlaySchema, HarnessExperimentSchema, HarnessSuiteTaskSchema, HarnessSuiteSchema, EvaluationIndexSchema, ExecutionProfileNameSchema, ExecutionProfileSchema, SkillsRegistrySchema;
+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, ScorecardVerdictSchema, ScorecardCriterionIdSchema, ScorecardCriterionSchema, ScorecardRecordSchema, TaskOutcomeSourceSchema, TaskOutcomeStatusSchema, DeliveryRouteSchema, TokenUsageSchema, DeliveryTelemetrySchema, DeliveryLedgerTaskSchema, DeliveryLedgerSchema, DeliveryLedgerRequestSchema, TaskOutcomeSchema, HarnessComponentIdSchema, HarnessComponentLayerSchema, HarnessToggleKindSchema, HarnessCatalogEntrySchema, HarnessCatalogSchema, HarnessOverlaySchema, HarnessExperimentSchema, HarnessSuiteTaskSchema, HarnessSuiteSchema, EvaluationIndexSchema, ExecutionProfileNameSchema, ExecutionProfileSchema, SkillsRegistrySchema;
 var init_schemas = __esm(() => {
   init_zod();
   init_runner_target();
@@ -11598,7 +11604,8 @@ var init_schemas = __esm(() => {
     complianceVeto: exports_external.boolean().optional(),
     confidence: exports_external.number().min(0).max(1),
     findings: exports_external.array(CouncilFindingSchema),
-    summary: exports_external.string()
+    summary: exports_external.string(),
+    candidateHash: exports_external.string().min(1).optional()
   });
   ConsensusConfigSchema = exports_external.object({
     algorithm: exports_external.enum(["majority", "unanimous"]),
@@ -11606,7 +11613,8 @@ var init_schemas = __esm(() => {
     allowComplianceVeto: exports_external.boolean().optional(),
     expectedAgentIds: exports_external.array(exports_external.string().min(1).refine((id) => id.trim().length > 0)).min(1).refine((ids) => new Set(ids.map((id) => id.trim().toLowerCase())).size === ids.length).optional(),
     quorum: exports_external.number().int().positive().optional(),
-    criticalFindingsPolicy: exports_external.enum(["escalate", "reject", "ignore"]).optional()
+    criticalFindingsPolicy: exports_external.enum(["escalate", "reject", "ignore"]).optional(),
+    candidateHash: exports_external.string().min(1).optional()
   }).refine((config) => config.algorithm !== "unanimous" || config.expectedAgentIds !== undefined, {
     message: "unanimous consensus requires a non-empty expectedAgentIds roster",
     path: ["expectedAgentIds"]
@@ -11983,7 +11991,8 @@ var init_schemas = __esm(() => {
     "prototype",
     "handoff",
     "clarify",
-    "security"
+    "security",
+    "odd"
   ]);
   CcepOutputFormatSchema = exports_external.enum(["taskcard", "plan", "verdict"]);
   CommandEnvelopeSchema = exports_external.object({
@@ -12199,6 +12208,46 @@ var init_schemas = __esm(() => {
     "revise",
     "reject"
   ]);
+  DeliveryRouteSchema = exports_external.enum(["read-only", "small", "tracked", "openspec"]);
+  TokenUsageSchema = exports_external.union([
+    exports_external.object({
+      status: exports_external.literal("known"),
+      total: exports_external.number().nonnegative()
+    }),
+    exports_external.object({ status: exports_external.literal("unknown") })
+  ]);
+  DeliveryTelemetrySchema = exports_external.object({
+    route: DeliveryRouteSchema,
+    contextBytes: exports_external.number().int().nonnegative().optional(),
+    handoffs: exports_external.number().int().nonnegative().optional(),
+    checks: exports_external.array(exports_external.string().min(1)).optional(),
+    tokenUsage: TokenUsageSchema
+  });
+  DeliveryLedgerTaskSchema = exports_external.object({
+    id: exports_external.string().min(1),
+    title: exports_external.string().min(1),
+    status: exports_external.enum(["pending", "done", "blocked"])
+  });
+  DeliveryLedgerSchema = exports_external.object({
+    version: exports_external.literal(1),
+    id: exports_external.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/),
+    taskCard: CanonicalTaskCardSchema,
+    tasks: exports_external.array(DeliveryLedgerTaskSchema).min(1),
+    evidence: exports_external.array(exports_external.string().min(1)),
+    nextStep: exports_external.string().min(1),
+    memoryTopicKey: exports_external.string().min(1),
+    workspace: exports_external.record(exports_external.string(), exports_external.string()),
+    createdAt: exports_external.string().datetime(),
+    updatedAt: exports_external.string().datetime()
+  });
+  DeliveryLedgerRequestSchema = exports_external.object({
+    id: exports_external.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/),
+    authorized: exports_external.boolean(),
+    route: DeliveryRouteSchema,
+    taskCard: CanonicalTaskCardSchema,
+    tasks: exports_external.array(DeliveryLedgerTaskSchema).min(1),
+    nextStep: exports_external.string().min(1)
+  });
   TaskOutcomeSchema = exports_external.object({
     id: exports_external.string(),
     taskId: exports_external.string(),
@@ -12222,7 +12271,8 @@ var init_schemas = __esm(() => {
     variantId: exports_external.string().optional(),
     suiteTaskId: exports_external.string().optional(),
     harnessFingerprint: exports_external.string().optional(),
-    disabledComponents: exports_external.array(exports_external.string()).optional()
+    disabledComponents: exports_external.array(exports_external.string()).optional(),
+    delivery: DeliveryTelemetrySchema.optional()
   });
   HarnessComponentIdSchema = exports_external.enum([
     "wayfinding",
@@ -12939,18 +12989,19 @@ var init_path_containment = __esm(() => {
 });
 
 // src/core/presets/complementary-detector.ts
-import { execFileSync } from "node:child_process";
+import { execFile } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { join as join3 } from "node:path";
 import { homedir } from "node:os";
-function detectComplementaryTools() {
+import { promisify } from "node:util";
+async function detectComplementaryTools() {
   if (cachedStatus) {
     return cachedStatus;
   }
-  const isCmdAvailable = (cmd) => {
+  const isCmdAvailable = async (cmd) => {
     try {
       const binary = process.platform === "win32" ? "where" : "which";
-      execFileSync(binary, [cmd], { stdio: "ignore", timeout: 1000 });
+      await execFileAsync(binary, [cmd], { timeout: 1000 });
       return true;
     } catch {
       return false;
@@ -12979,18 +13030,28 @@ function detectComplementaryTools() {
     } catch {}
     return false;
   };
+  const [rtk, codeReviewGraph, tokenSavior, tokenSaviorRecall, engram, gentleAi] = await Promise.all([
+    isCmdAvailable("rtk"),
+    isCmdAvailable("code-review-graph"),
+    isCmdAvailable("token-savior"),
+    isCmdAvailable("token-savior-recall"),
+    isCmdAvailable("engram"),
+    isCmdAvailable("gentle-ai")
+  ]);
   cachedStatus = {
-    rtk: isCmdAvailable("rtk"),
-    codeReviewGraph: isCmdAvailable("code-review-graph"),
-    tokenSavior: isCmdAvailable("token-savior") || isCmdAvailable("token-savior-recall"),
+    rtk,
+    codeReviewGraph,
+    tokenSavior: tokenSavior || tokenSaviorRecall,
     caveman: hasCaveman(),
-    engram: isCmdAvailable("engram"),
-    gentleAi: isCmdAvailable("gentle-ai")
+    engram,
+    gentleAi
   };
   return cachedStatus;
 }
-var cachedStatus = null;
-var init_complementary_detector = () => {};
+var execFileAsync, cachedStatus = null;
+var init_complementary_detector = __esm(() => {
+  execFileAsync = promisify(execFile);
+});
 
 // src/core/presets/file-copier.ts
 import { lstat as lstat2, readdir, readFile as readFile4, stat } from "node:fs/promises";
@@ -13083,9 +13144,9 @@ function extractAgentRole(filePath) {
   ];
   return knownRoles.includes(name) ? name : null;
 }
-function renderTemplate(content, modelConfig, filePath, locale = "en") {
+async function renderTemplate(content, modelConfig, filePath, locale = "en") {
   const cleanLocale = locale === "es" || locale === "en" ? locale : "en";
-  const tools = detectComplementaryTools();
+  const tools = await detectComplementaryTools();
   let complementaryRules = "";
   if (cleanLocale === "es") {
     if (tools.rtk) {
@@ -13208,7 +13269,7 @@ function substituteToolNames(content, modelConfig) {
   const eol = fmMatch[1];
   const frontmatter = fmMatch[2];
   if (target === "opencode" && modelConfig.permissions) {
-    const updatedFrontmatter2 = frontmatter.replace(/^tools:\s*(.+)\r?\n?/m, "");
+    const updatedFrontmatter2 = frontmatter.replace(/^tools:\s*(.+)\r?\n?/m, "").replace(/^(?:temperature|effort):[^\r\n]*\r?\n?/gm, "");
     return content.replace(fmMatch[0], `---${eol}${updatedFrontmatter2}${eol}---`);
   }
   if (!modelConfig.tools)
@@ -13226,7 +13287,7 @@ function substituteToolNames(content, modelConfig) {
   });
   return content.replace(fmMatch[0], `---${eol}${updatedFrontmatter}${eol}---`);
 }
-function injectMcpServers(jsonString, filePath) {
+async function injectMcpServers(jsonString, filePath) {
   const isAgyMcpConfig = filePath.endsWith("mcp_config.json");
   const isClaudeSettings = filePath.endsWith("settings.json");
   const isOpencodeJsonc = filePath.endsWith("opencode.jsonc") || filePath.endsWith("opencode.json");
@@ -13239,7 +13300,7 @@ function injectMcpServers(jsonString, filePath) {
       cleanJson = jsonString.replace(/\/\*[\s\S]*?\*\/|([^\\:]|^)\/\/.*$/gm, "$1");
     }
     const obj = JSON.parse(cleanJson);
-    const tools = detectComplementaryTools();
+    const tools = await detectComplementaryTools();
     const mcpServers = {};
     if (tools.tokenSavior) {
       mcpServers["token-savior-recall"] = {
@@ -13311,8 +13372,8 @@ async function applySingleFile(srcPath, destPath, strategy, force, dryRun, isTem
   } catch (e) {
     return { src: srcPath, dest: destPath, action: "error", error: `Cannot read source: ${e}` };
   }
-  let incomingContent = isTemplate && modelConfig ? renderTemplate(content, modelConfig, srcPath, locale) : content;
-  incomingContent = injectMcpServers(incomingContent, destPath);
+  let incomingContent = isTemplate && modelConfig ? await renderTemplate(content, modelConfig, srcPath, locale) : content;
+  incomingContent = await injectMcpServers(incomingContent, destPath);
   let finalContent = incomingContent;
   let action = "written";
   if (strategy === "append") {
@@ -14579,7 +14640,7 @@ async function checkUpdates(basePath, isGlobal, includeConflicts = false) {
         let expectedContent;
         try {
           const srcContent = await readFile7(src, "utf-8");
-          expectedContent = isTemplate && modelConfig ? renderTemplate(srcContent, modelConfig, src, locale) : srcContent;
+          expectedContent = isTemplate && modelConfig ? await renderTemplate(srcContent, modelConfig, src, locale) : srcContent;
         } catch {
           continue;
         }
@@ -15041,7 +15102,7 @@ async function doctorCommand(options) {
         message: "No product graph yet. Run `codeconductor ingest` to build product memory."
       });
     }
-    const compTools = detectComplementaryTools();
+    const compTools = await detectComplementaryTools();
     const toolDetails = [
       { name: "rtk", key: "rtk", label: "RTK", desc: "Run `brew install rtk` to compress command outputs" },
       { name: "code-review-graph", key: "codeReviewGraph", label: "code-review-graph", desc: "Run `pipx install code-review-graph` to navigate symbol graph" },
@@ -15419,6 +15480,25 @@ var init_profiles = __esm(() => {
       routing: { default: ["validate-backlog", "discover", "design", "analyze", "test", "implement", "review"] },
       confirmationGate: baseGate
     },
+    odd: {
+      id: "odd",
+      version: 1,
+      command: "odd",
+      taskCard: {
+        type: "feature",
+        requiredFields: ["title", "type", "risk", "scope", "context", "acceptanceCriteria"]
+      },
+      phases: [
+        { id: "wayfinding", agent: "repo-explorer", outputSchema: "agent-output" },
+        { id: "intake", agent: "task-coach", outputSchema: "planner-output", stopGate: "confirmation" },
+        { id: "ledger", agent: "orchestrator", type: "cli-gate" },
+        { id: "test", agent: "tester", dependsOn: ["intake"] },
+        { id: "implement", agent: "implementer", dependsOn: ["test"] },
+        { id: "review", agent: "reviewer" }
+      ],
+      routing: { default: ["wayfinding", "intake", "ledger", "test", "implement", "review"] },
+      confirmationGate: baseGate
+    },
     backlog: {
       id: "backlog",
       version: 1,
@@ -18304,13 +18384,13 @@ var init_binary_downloader = __esm(() => {
 });
 
 // src/core/lsp/lsp-installer.ts
-import { execFile } from "node:child_process";
+import { execFile as execFile2 } from "node:child_process";
 import { access as access6, mkdir as mkdir6, mkdtemp, rename as rename2, rm, writeFile as writeFile5 } from "node:fs/promises";
 import { homedir as homedir8, tmpdir } from "node:os";
 import { join as join9 } from "node:path";
-import { promisify } from "node:util";
+import { promisify as promisify2 } from "node:util";
 async function assertTarArchiveSafe(archivePath, destRoot) {
-  const { stdout } = await execFileAsync("tar", ["-tzf", archivePath], {
+  const { stdout } = await execFileAsync2("tar", ["-tzf", archivePath], {
     timeout: 60000,
     maxBuffer: 10 * 1024 * 1024
   });
@@ -18322,7 +18402,7 @@ async function assertTarArchiveSafe(archivePath, destRoot) {
 }
 async function extractHardenedTar(archivePath, destRoot) {
   await assertTarArchiveSafe(archivePath, destRoot);
-  await execFileAsync("tar", ["-xzf", archivePath, "-C", destRoot, ...TAR_EXTRACT_HARDENING_FLAGS], { timeout: 120000 });
+  await execFileAsync2("tar", ["-xzf", archivePath, "-C", destRoot, ...TAR_EXTRACT_HARDENING_FLAGS], { timeout: 120000 });
 }
 
 class LspInstaller {
@@ -18332,7 +18412,7 @@ class LspInstaller {
   }
   async checkInstalled(def) {
     try {
-      const { stdout } = await execFileAsync("which", [def.binaryName], { timeout: 5000 });
+      const { stdout } = await execFileAsync2("which", [def.binaryName], { timeout: 5000 });
       const path = stdout.trim();
       if (path) {
         const version = await this.getVersion(def);
@@ -18341,7 +18421,7 @@ class LspInstaller {
     } catch {}
     if (def.packageManager === "npm" && def.npmDetect) {
       try {
-        const { stdout } = await execFileAsync("npm", ["list", "-g", def.npmDetect, "--depth=0"], { timeout: 1e4 });
+        const { stdout } = await execFileAsync2("npm", ["list", "-g", def.npmDetect, "--depth=0"], { timeout: 1e4 });
         if (stdout.includes(def.npmDetect)) {
           const version = this.parseVersionFromNpmList(stdout, def.npmDetect);
           return { installed: true, version };
@@ -18350,7 +18430,7 @@ class LspInstaller {
     }
     if (def.packageManager === "pip" && def.pipDetect) {
       try {
-        const { stdout } = await execFileAsync("pip", ["show", def.pipDetect], { timeout: 1e4 });
+        const { stdout } = await execFileAsync2("pip", ["show", def.pipDetect], { timeout: 1e4 });
         if (stdout.includes("Version:")) {
           const version = this.parseVersionFromPipShow(stdout);
           return { installed: true, version };
@@ -18414,7 +18494,7 @@ class LspInstaller {
   }
   async getVersion(def) {
     try {
-      const { stdout } = await execFileAsync(def.binaryName, [def.versionFlag], { timeout: 5000 });
+      const { stdout } = await execFileAsync2(def.binaryName, [def.versionFlag], { timeout: 5000 });
       return stdout.trim().split(`
 `)[0];
     } catch {
@@ -18432,7 +18512,7 @@ class LspInstaller {
   async installNpm(def) {
     assertPinnedPackage(def);
     try {
-      await execFileAsync("npm", ["install", "-g", def.package], { timeout: 120000 });
+      await execFileAsync2("npm", ["install", "-g", def.package], { timeout: 120000 });
     } catch (error) {
       throw new Error(`Failed to install ${def.serverName}: ${error instanceof Error ? error.message : String(error)}`);
     }
@@ -18440,7 +18520,7 @@ class LspInstaller {
   async installPip(def) {
     assertPinnedPackage(def);
     try {
-      await execFileAsync("pip", ["install", "--user", def.package], { timeout: 120000 });
+      await execFileAsync2("pip", ["install", "--user", def.package], { timeout: 120000 });
     } catch (error) {
       throw new Error(`Failed to install ${def.serverName}: ${error instanceof Error ? error.message : String(error)}`);
     }
@@ -18482,7 +18562,7 @@ class LspInstaller {
         await access6(candidate);
         await rename2(candidate, destPath);
       } catch {
-        const { stdout: found } = await execFileAsync("find", [workDir, "-type", "f", "-name", def.binaryName], { timeout: 30000 });
+        const { stdout: found } = await execFileAsync2("find", [workDir, "-type", "f", "-name", def.binaryName], { timeout: 30000 });
         const first = found.split(`
 `).map((l) => l.trim()).find((l) => l.length > 0);
         if (!first) {
@@ -18492,7 +18572,7 @@ class LspInstaller {
         await rename2(first, destPath);
       }
       if (process.platform !== "win32") {
-        await execFileAsync("chmod", ["+x", destPath], { timeout: 5000 });
+        await execFileAsync2("chmod", ["+x", destPath], { timeout: 5000 });
       }
     } finally {
       await rm(workDir, { recursive: true, force: true });
@@ -18502,11 +18582,11 @@ class LspInstaller {
 function createLspInstaller() {
   return new LspInstaller;
 }
-var execFileAsync, TAR_EXTRACT_HARDENING_FLAGS;
+var execFileAsync2, TAR_EXTRACT_HARDENING_FLAGS;
 var init_lsp_installer = __esm(() => {
   init_binary_integrity();
   init_binary_downloader();
-  execFileAsync = promisify(execFile);
+  execFileAsync2 = promisify2(execFile2);
   TAR_EXTRACT_HARDENING_FLAGS = [
     "--no-same-owner",
     "--no-same-permissions"
@@ -20771,13 +20851,13 @@ function slugify(text) {
 
 // src/core/knowledge/source-parsers.ts
 import { readFile as readFile19 } from "node:fs/promises";
-import { join as join15 } from "node:path";
+import { basename as basename6, join as join15, relative as relative7, sep as sep5 } from "node:path";
 async function parseAdrFile(filePath) {
   try {
     const content = await readFile19(filePath, "utf-8");
-    const basename6 = filePath.split("/").pop() ?? "";
-    const idMatch = basename6.match(/adr-(\d+)/i);
-    const id = idMatch ? `adr-${idMatch[1]}` : slugify(basename6);
+    const base = basename6(filePath);
+    const idMatch = base.match(/adr-(\d+)/i);
+    const id = idMatch ? `adr-${idMatch[1]}` : slugify(base);
     const titleMatch = content.match(/^#\s+ADR-\d+:\s*(.+)$/m);
     const statusMatch = content.match(/\*\*Status:\*\*\s*(\w+)/i);
     const contextSection = extractSection(content, "Context");
@@ -20787,7 +20867,7 @@ async function parseAdrFile(filePath) {
 `).filter((l) => l.trim().startsWith("-") || l.trim().startsWith("*")).map((l) => l.replace(/^[\s*-]+/, "").trim()).filter(Boolean);
     return {
       id,
-      title: titleMatch?.[1]?.trim() ?? basename6,
+      title: titleMatch?.[1]?.trim() ?? base,
       status: statusMatch?.[1]?.toLowerCase() ?? "unknown",
       context: contextSection.trim(),
       decision: decisionSection.trim(),
@@ -20887,7 +20967,7 @@ async function scanSrcComponents(projectRoot) {
             source: "src/",
             confidence: "medium",
             relations: [],
-            data: { path: full.replace(projectRoot + "/", "") }
+            data: { path: relative7(projectRoot, full).split(sep5).join("/") }
           });
           await walk(full, prefix ? `${prefix}-${domainSlug}` : domainSlug);
         }
@@ -20948,7 +21028,7 @@ var init_episodic_store = __esm(() => {
 // src/core/knowledge/ingest-pipeline.ts
 import { createHash as createHash3 } from "node:crypto";
 import { readFile as readFile21 } from "node:fs/promises";
-import { join as join16 } from "node:path";
+import { join as join16, relative as relative8, sep as sep6 } from "node:path";
 import { mkdir as mkdir13, writeFile as writeFile12 } from "node:fs/promises";
 async function mapLimit(items, limit, fn) {
   if (items.length === 0)
@@ -20997,7 +21077,7 @@ async function collectDeferRisks(projectRoot) {
   const perFile = await mapLimit(files, WALK_READ_CONCURRENCY, async (full) => {
     const entities = [];
     const content = await readFile21(full, "utf-8");
-    const rel = full.replace(projectRoot + "/", "");
+    const rel = relative8(projectRoot, full).split(sep6).join("/");
     const deferRe = new RegExp(DEFER_REGEX_SOURCE, "gm");
     let match;
     while ((match = deferRe.exec(content)) !== null) {
@@ -21487,7 +21567,10 @@ async function listScorecards(projectRoot, filter = {}) {
 }
 async function hasPassingScorecard(projectRoot, backlogId) {
   const listed = await listScorecards(projectRoot, { backlogId, verdict: "PASS" });
-  return listed.success && listed.data.length > 0;
+  if (listed.success && listed.data.length > 0)
+    return true;
+  const outcomes = await listOutcomes(projectRoot, { backlogId, source: "review" });
+  return outcomes.success && outcomes.data.some((outcome) => outcome.verdict === "PASS");
 }
 async function loadScorecard(projectRoot, id) {
   try {
@@ -21519,7 +21602,7 @@ function aggregateOutcomes(outcomes) {
       agentScoreCounts[o.agent] = (agentScoreCounts[o.agent] ?? 0) + 1;
     }
     if (!byModel[o.model])
-      byModel[o.model] = { count: 0, avgScore: 0 };
+      byModel[o.model] = { count: 0, avgScore: 0, knownTokenMeasurements: 0 };
     byModel[o.model].count++;
     if (o.weightedScore !== undefined) {
       byModel[o.model].avgScore += o.weightedScore;
@@ -21529,10 +21612,11 @@ function aggregateOutcomes(outcomes) {
       byModel[o.model].avgCost = (byModel[o.model].avgCost ?? 0) + o.costUsd;
       modelCostCounts[o.model] = (modelCostCounts[o.model] ?? 0) + 1;
     }
-    if (o.tokensIn !== undefined || o.tokensOut !== undefined) {
-      const tokens = (o.tokensIn ?? 0) + (o.tokensOut ?? 0);
-      byModel[o.model].avgTokens = (byModel[o.model].avgTokens ?? 0) + tokens;
+    const reportedTokens = o.delivery?.tokenUsage.status === "known" ? o.delivery.tokenUsage.total : o.tokensIn !== undefined || o.tokensOut !== undefined ? (o.tokensIn ?? 0) + (o.tokensOut ?? 0) : undefined;
+    if (reportedTokens !== undefined) {
+      byModel[o.model].avgTokens = (byModel[o.model].avgTokens ?? 0) + reportedTokens;
       modelTokenCounts[o.model] = (modelTokenCounts[o.model] ?? 0) + 1;
+      byModel[o.model].knownTokenMeasurements++;
     }
     if (o.variantId) {
       if (!byVariant[o.variantId])
@@ -22182,11 +22266,140 @@ var init_compile_checker = __esm(() => {
   ];
 });
 
+// src/core/verification/rdd-receipt.ts
+var exports_rdd_receipt = {};
+__export(exports_rdd_receipt, {
+  captureReceipt: () => captureReceipt,
+  collectReceiptPaths: () => collectReceiptPaths,
+  isRddReceipt: () => isRddReceipt,
+  verifyReceipt: () => verifyReceipt
+});
+import { createHash as createHash4 } from "node:crypto";
+import { readdir as readdir7, readFile as readFile27 } from "node:fs/promises";
+import { join as join18, relative as relative9, resolve as resolve26, sep as sep7 } 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}`)) {
+    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("/") };
+}
+async function fingerprint(projectRoot, paths) {
+  const deduplicated = new Map;
+  for (const path of paths) {
+    const canonical = canonicalPath(projectRoot, path);
+    deduplicated.set(canonical.relative, canonical.absolute);
+  }
+  const result = [];
+  for (const [path, absolute] of [...deduplicated.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+    result.push({ path, hash: sha2562(await readFile27(absolute)) });
+  }
+  return result;
+}
+function manifestHash(paths) {
+  return sha2562(paths.map((entry) => `${entry.path}\x00${entry.hash}`).join(`
+`));
+}
+function isRddReceipt(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const receipt = value;
+  return receipt.version === 1 && typeof receipt.taskId === "string" && typeof receipt.phase === "string" && Array.isArray(receipt.paths) && receipt.paths.every((entry) => Boolean(entry) && typeof entry.path === "string" && typeof entry.hash === "string") && (receipt.coverage === "paths" || receipt.coverage === "project") && typeof receipt.manifestHash === "string" && (receipt.outcome === "passed" || receipt.outcome === "failed") && typeof receipt.capturedAt === "string";
+}
+async function captureReceipt(projectRoot, input) {
+  if (!input.taskId.trim())
+    throw new Error("RDD receipts require a task id");
+  if (input.paths.length === 0 && input.coverage !== "project") {
+    throw new Error("RDD receipts require at least one protected path");
+  }
+  const paths = await fingerprint(projectRoot, input.paths);
+  return {
+    version: 1,
+    taskId: input.taskId,
+    phase: input.phase,
+    paths,
+    coverage: input.coverage ?? "paths",
+    manifestHash: manifestHash(paths),
+    command: input.command,
+    outcome: input.outcome,
+    capturedAt: new Date().toISOString()
+  };
+}
+async function collectReceiptPaths(projectRoot) {
+  const root = resolve26(projectRoot);
+  const paths = [];
+  async function visit2(current) {
+    const entries = await readdir7(current, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (!EXCLUDED_DIRECTORIES.has(entry.name))
+          await visit2(join18(current, entry.name));
+        continue;
+      }
+      if (entry.isFile())
+        paths.push(relative9(root, join18(current, entry.name)).split(sep7).join("/"));
+    }
+  }
+  await visit2(root);
+  return paths.sort();
+}
+async function verifyReceipt(projectRoot, receipt) {
+  const expected = new Map(receipt.paths.map((entry) => [entry.path, entry.hash]));
+  const changedPaths = [];
+  const current = [];
+  const pathsToCheck = receipt.coverage === "project" ? await collectReceiptPaths(projectRoot) : receipt.paths.map((entry) => entry.path);
+  const currentByPath = new Map;
+  for (const path of pathsToCheck) {
+    try {
+      const canonical = canonicalPath(projectRoot, path);
+      const hash = sha2562(await readFile27(canonical.absolute));
+      const currentEntry = { path: canonical.relative, hash };
+      current.push(currentEntry);
+      currentByPath.set(currentEntry.path, currentEntry);
+      if (hash !== expected.get(currentEntry.path))
+        changedPaths.push(currentEntry.path);
+    } catch {
+      changedPaths.push(path);
+    }
+  }
+  for (const path of expected.keys()) {
+    if (!currentByPath.has(path) && !changedPaths.includes(path))
+      changedPaths.push(path);
+  }
+  changedPaths.sort();
+  const actualHash = manifestHash(current.sort((left, right) => left.path.localeCompare(right.path)));
+  return {
+    valid: changedPaths.length === 0 && actualHash === receipt.manifestHash,
+    expectedHash: receipt.manifestHash,
+    actualHash,
+    changedPaths
+  };
+}
+var EXCLUDED_DIRECTORIES;
+var init_rdd_receipt = __esm(() => {
+  EXCLUDED_DIRECTORIES = new Set([
+    ".git",
+    ".codeconductor",
+    "node_modules",
+    "dist",
+    "coverage",
+    "graphify-out"
+  ]);
+});
+
 // src/core/verification/verification-runner.ts
 import { existsSync as existsSync3 } from "node:fs";
-import { readFile as readFile27 } from "node:fs/promises";
-import { dirname as dirname10, join as join18, resolve as resolve26 } from "node:path";
-import { mkdir as mkdir18, readdir as readdir7, writeFile as writeFile18 } from "node:fs/promises";
+import { readFile as readFile28 } 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";
 function isPassingEvidence(ev) {
   switch (ev.type) {
     case "verification":
@@ -22203,9 +22416,17 @@ function isPassingEvidence(ev) {
       return false;
   }
 }
+async function isCurrentPassingEvidence(projectRoot, ev) {
+  if (!isPassingEvidence(ev))
+    return false;
+  const receipt = ev.data?.rddReceipt;
+  if (!isRddReceipt(receipt))
+    return false;
+  return (await verifyReceipt(projectRoot, receipt)).valid;
+}
 function evidenceFilePath(evDir, id) {
-  const path = resolve26(evDir, `${id.replace(/[^A-Za-z0-9_-]/g, "_")}.json`);
-  if (dirname10(path) !== resolve26(evDir)) {
+  const path = resolve27(evDir, `${id.replace(/[^A-Za-z0-9_-]/g, "_")}.json`);
+  if (dirname10(path) !== resolve27(evDir)) {
     return err(new Error(`Refusing to write evidence for "${id}" outside ${evDir}`));
   }
   return ok(path);
@@ -22231,7 +22452,7 @@ async function collectTaskEvidence(projectRoot, taskId) {
     return ok({ records, invalid });
   let files;
   try {
-    files = await readdir7(evDir);
+    files = await readdir8(evDir);
   } catch (e) {
     return err(e instanceof Error ? e : new Error(String(e)));
   }
@@ -22239,7 +22460,7 @@ async function collectTaskEvidence(projectRoot, taskId) {
     if (!file.endsWith(".json"))
       continue;
     try {
-      const raw = await readFile27(join18(evDir, file), "utf-8");
+      const raw = await readFile28(join19(evDir, file), "utf-8");
       const ev = EvidenceSchema.parse(JSON.parse(raw));
       if (ev.relatedTask === taskId)
         records.push(ev);
@@ -22260,7 +22481,7 @@ async function validateEvidenceIds(projectRoot, taskId, evidenceIds) {
     if (!record) {
       return err(new Error(`Evidence "${id}" is not a record of task ${taskId}`));
     }
-    if (!isPassingEvidence(record)) {
+    if (!await isCurrentPassingEvidence(projectRoot, record)) {
       return err(new Error(`Evidence "${id}" does not record a passing result`));
     }
     if (record.type === "verification")
@@ -22341,7 +22562,12 @@ async function runVerification(projectRoot, taskId, goal, options) {
     passed: collected.data.invalid === 0,
     message: collected.data.invalid === 0 ? "All evidence records are readable" : `${collected.data.invalid} unreadable evidence record(s)`
   });
-  const supporting = collected.data.records.filter((ev) => ev.type !== "verification" && isPassingEvidence(ev));
+  const supporting = [];
+  for (const candidate of collected.data.records) {
+    if (candidate.type !== "verification" && await isCurrentPassingEvidence(projectRoot, candidate)) {
+      supporting.push(candidate);
+    }
+  }
   evidenceIds.push(...supporting.map((ev) => ev.id));
   checks.push({
     name: "evidence_present",
@@ -22349,6 +22575,13 @@ async function runVerification(projectRoot, taskId, goal, options) {
     message: supporting.length > 0 ? `${supporting.length} passing evidence record(s) for task` : task.risk === "low" ? "Low risk task — evidence optional" : "No passing evidence records found for task"
   });
   const passed = checks.every((c) => c.passed);
+  const receipt = await captureReceipt(projectRoot, {
+    taskId,
+    phase: "verification",
+    paths: await collectReceiptPaths(projectRoot),
+    outcome: passed ? "passed" : "failed",
+    coverage: "project"
+  });
   const evidence = {
     id: `ev-verify-${taskId}-${Date.now()}`,
     source: "cc verify",
@@ -22357,7 +22590,7 @@ async function runVerification(projectRoot, taskId, goal, options) {
     relatedTask: taskId,
     confidence: passed ? 0.9 : 0.3,
     summary: passed ? "Verification passed" : "Verification failed",
-    data: { passed, checks }
+    data: { passed, checks, rddReceipt: receipt }
   };
   const persisted = await persistEvidence(projectRoot, evidence);
   if (!persisted.success)
@@ -22380,19 +22613,25 @@ async function gateTaskCompletion(projectRoot, taskId, evidenceRequired, evidenc
   if (collected.data.invalid > 0)
     return ok(false);
   const cited = evidenceIds ? new Set(evidenceIds) : undefined;
-  const hasPassing = (type) => collected.data.records.some((ev) => (!cited || cited.has(ev.id)) && ev.type === type && isPassingEvidence(ev));
+  const hasPassing = async (type) => {
+    for (const evidence of collected.data.records) {
+      if ((!cited || cited.has(evidence.id)) && evidence.type === type && await isCurrentPassingEvidence(projectRoot, evidence))
+        return true;
+    }
+    return false;
+  };
   for (const req of evidenceRequired) {
     switch (req) {
       case "acceptance_criteria_met":
-        if (!hasPassing("verification"))
+        if (!await hasPassing("verification"))
           return ok(false);
         break;
       case "tests_passed":
-        if (!hasPassing("test"))
+        if (!await hasPassing("test"))
           return ok(false);
         break;
       case "review_approved":
-        if (!hasPassing("review"))
+        if (!await hasPassing("review"))
           return ok(false);
         break;
       default:
@@ -22401,11 +22640,66 @@ async function gateTaskCompletion(projectRoot, taskId, evidenceRequired, evidenc
   }
   return ok(true);
 }
-async function hasTddRunnerEvidence(projectRoot, taskId) {
+async function loadTddSuiteEvidence(projectRoot, taskId, evidenceId) {
+  const evDir = evidenceDir(projectRoot);
+  const path = evidenceFilePath(evDir, evidenceId);
+  if (!path.success)
+    return path;
+  let raw;
+  try {
+    raw = await readFile28(path.data, "utf-8");
+  } catch (e) {
+    return err(e instanceof Error ? e : new Error(String(e)));
+  }
+  let ev;
+  try {
+    ev = EvidenceSchema.parse(JSON.parse(raw));
+  } catch {
+    return err(new Error(`Evidence "${evidenceId}" is not valid TDD evidence`));
+  }
+  if (ev.relatedTask !== taskId) {
+    return err(new Error(`Evidence "${evidenceId}" is not a record of task ${taskId}`));
+  }
+  if (ev.type !== "tdd" || ev.source !== TDD_EVIDENCE_SOURCE) {
+    return err(new Error(`Evidence "${evidenceId}" was not captured by the verification runner`));
+  }
+  const capturedBy = ev.data?.capturedBy;
+  const suiteFailed = ev.data?.suiteFailed;
+  const suitePassed = ev.data?.suitePassed;
+  if (capturedBy !== TDD_CAPTURED_BY || typeof suiteFailed !== "boolean" || typeof suitePassed !== "boolean") {
+    return err(new Error(`Evidence "${evidenceId}" was not captured by the verification runner`));
+  }
+  const receipt = ev.data?.rddReceipt;
+  if (!isRddReceipt(receipt)) {
+    return err(new Error(`Evidence "${evidenceId}" has no valid RDD receipt`));
+  }
+  if (receipt.taskId !== taskId) {
+    return err(new Error(`Evidence "${evidenceId}" receipt belongs to another task`));
+  }
+  const verified = await verifyReceipt(projectRoot, receipt);
+  if (!verified.valid) {
+    return err(new Error(`Evidence "${evidenceId}" RDD receipt is stale: ${verified.changedPaths.join(", ")}`));
+  }
+  return ok({ capturedBy, suiteFailed, suitePassed, receipt });
+}
+async function hasTddRunnerEvidence(projectRoot, taskId, expectedPhase) {
   const collected = await collectTaskEvidence(projectRoot, taskId);
   if (!collected.success)
     return false;
-  return collected.data.records.some((ev) => ev.type === "tdd" && ev.source === TDD_EVIDENCE_SOURCE && ev.data?.capturedBy === TDD_CAPTURED_BY);
+  for (const ev of collected.data.records) {
+    if (ev.type !== "tdd" || ev.source !== TDD_EVIDENCE_SOURCE || ev.data?.capturedBy !== TDD_CAPTURED_BY) {
+      continue;
+    }
+    const loaded = await loadTddSuiteEvidence(projectRoot, taskId, ev.id);
+    if (!loaded.success)
+      continue;
+    if (expectedPhase === "red" && (!loaded.data.suiteFailed || loaded.data.suitePassed))
+      continue;
+    if (expectedPhase === "green" && (!loaded.data.suitePassed || loaded.data.suiteFailed))
+      continue;
+    return true;
+  }
+  return false;
 }
 var TDD_EVIDENCE_SOURCE = "cc verify", TDD_CAPTURED_BY = "verification-runner";
 var init_verification_runner = __esm(() => {
@@ -22414,6 +22708,7 @@ var init_verification_runner = __esm(() => {
   init_compile_checker();
   init_paths();
   init_episodic_store();
+  init_rdd_receipt();
 });
 
 // src/core/orchestrator/runtime-orchestrator.ts
@@ -22753,8 +23048,8 @@ var init_loop_state = __esm(() => {
 });
 
 // src/core/loop/git-stats.ts
-import { execFile as execFile2 } from "node:child_process";
-import { promisify as promisify2 } from "node:util";
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
 function countPorcelain(output) {
   return output.split(`
 `).filter((line) => line.trim().length > 0).length;
@@ -22778,12 +23073,12 @@ function countNumstat(output) {
 async function fetchGitChangeStats(cwd) {
   try {
     const [status, diff] = await Promise.all([
-      execFileAsync2("git", ["status", "--porcelain"], {
+      execFileAsync3("git", ["status", "--porcelain"], {
         cwd,
         encoding: "utf-8",
         timeout: 15000
       }),
-      execFileAsync2("git", ["diff", "--numstat"], {
+      execFileAsync3("git", ["diff", "--numstat"], {
         cwd,
         encoding: "utf-8",
         timeout: 15000
@@ -22807,9 +23102,9 @@ async function readGitChangeStats(cwd, options) {
   cache = { cwd, at: now, stats };
   return stats;
 }
-var execFileAsync2, GIT_STATS_CACHE_TTL_MS = 3000, cache;
+var execFileAsync3, GIT_STATS_CACHE_TTL_MS = 3000, cache;
 var init_git_stats = __esm(() => {
-  execFileAsync2 = promisify2(execFile2);
+  execFileAsync3 = promisify3(execFile3);
 });
 
 // src/core/loop/loop-engine.ts
@@ -23536,6 +23831,163 @@ var init_verify_command = __esm(() => {
   init_verification_runner();
 });
 
+// src/commands/rdd.command.ts
+var exports_rdd_command = {};
+__export(exports_rdd_command, {
+  rddCommand: () => rddCommand,
+  rddStatus: () => rddStatus
+});
+import { execFile as execFile4 } from "node:child_process";
+import { existsSync as existsSync4 } from "node:fs";
+import { mkdir as mkdir19, readFile as readFile29, readdir as readdir9, rename as rename3, writeFile as writeFile19, chmod } from "node:fs/promises";
+import { dirname as dirname11, resolve as resolve28 } from "node:path";
+import { promisify as promisify4 } from "node:util";
+function receiptPath(projectRoot, id) {
+  const directory = resolve28(evidenceDir(projectRoot));
+  const path = resolve28(directory, `${id.replace(/[^A-Za-z0-9_-]/g, "_")}.json`);
+  if (dirname11(path) !== directory)
+    throw new Error(`Invalid RDD receipt id: ${id}`);
+  return path;
+}
+async function loadReceipt(projectRoot, id) {
+  const raw = await readFile29(receiptPath(projectRoot, id), "utf-8");
+  const evidence = EvidenceSchema.parse(JSON.parse(raw));
+  if (evidence.type !== "rdd")
+    throw new Error(`Evidence "${id}" is not an RDD receipt`);
+  return { evidence, receipt: assertReceipt(evidence.data?.rddReceipt) };
+}
+function assertReceipt(value) {
+  if (!isRddReceipt(value))
+    throw new Error("RDD receipt payload is invalid");
+  return value;
+}
+async function rddStatus(projectRoot, taskId) {
+  const directory = evidenceDir(projectRoot);
+  if (!existsSync4(directory))
+    return [];
+  const receipts = [];
+  for (const file of await readdir9(directory)) {
+    if (!file.endsWith(".json"))
+      continue;
+    try {
+      const id = file.slice(0, -".json".length);
+      const { evidence, receipt } = await loadReceipt(projectRoot, id);
+      if (taskId && evidence.relatedTask !== taskId)
+        continue;
+      const verification = await verifyReceipt(projectRoot, receipt);
+      receipts.push({
+        id: evidence.id,
+        taskId: evidence.relatedTask,
+        phase: receipt.phase,
+        timestamp: evidence.timestamp,
+        valid: verification.valid,
+        changedPaths: verification.changedPaths
+      });
+    } catch {}
+  }
+  return receipts.sort((left, right) => right.timestamp.localeCompare(left.timestamp));
+}
+async function installHooks(projectRoot) {
+  const { stdout } = await execFileAsync4("git", ["rev-parse", "--git-path", "hooks"], {
+    cwd: projectRoot,
+    encoding: "utf8"
+  });
+  const hooksDir = resolve28(projectRoot, stdout.trim());
+  await mkdir19(hooksDir, { recursive: true });
+  const installed = [];
+  const skipped = [];
+  for (const hook of ["pre-commit", "pre-push"]) {
+    const path = resolve28(hooksDir, hook);
+    const backup = resolve28(hooksDir, `${hook}.rdd-original`);
+    const marker = "# codeconductor-rdd-hook";
+    if (existsSync4(path)) {
+      const existing = await readFile29(path, "utf8");
+      if (existing.includes(marker)) {
+        skipped.push(hook);
+        continue;
+      }
+      if (existsSync4(backup)) {
+        throw new Error(`Cannot preserve ${hook}: ${backup} already exists`);
+      }
+      await rename3(path, backup);
+    }
+    const script = `#!/bin/sh
+${marker}
+set -e
+HOOK_DIR="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)"
+if [ -x "$HOOK_DIR/${hook}.rdd-original" ]; then
+  "$HOOK_DIR/${hook}.rdd-original" "$@"
+fi
+cc-codeconductor rdd git-check
+`;
+    await writeFile19(path, script, "utf8");
+    await chmod(path, 493);
+    installed.push(hook);
+  }
+  return { installed, skipped };
+}
+async function rddCommand(options) {
+  try {
+    if (options.subcommand === "capture") {
+      if (!options.taskId)
+        throw new Error("Missing task id. Use --task <id>.");
+      const protectedPaths = options.paths?.length ? options.paths : await collectReceiptPaths(options.projectRoot);
+      const receipt = await captureReceipt(options.projectRoot, {
+        taskId: options.taskId,
+        phase: options.phase ?? "verification",
+        paths: protectedPaths,
+        outcome: options.outcome ?? "passed",
+        command: options.command,
+        coverage: options.paths?.length ? "paths" : "project"
+      });
+      const id = `ev-rdd-${options.taskId}-${Date.now()}`;
+      const evidence = {
+        id,
+        source: "cc rdd",
+        type: "rdd",
+        timestamp: new Date().toISOString(),
+        relatedTask: options.taskId,
+        confidence: 0.9,
+        summary: `RDD ${receipt.phase} receipt captured`,
+        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");
+      return { code: 0, data: { success: true, receiptId: id, receipt } };
+    }
+    if (options.subcommand === "verify") {
+      if (!options.receiptId)
+        throw new Error("Missing receipt id. Use --receipt <id>.");
+      const { receipt } = await loadReceipt(options.projectRoot, options.receiptId);
+      const verification = await verifyReceipt(options.projectRoot, receipt);
+      return {
+        code: verification.valid ? 0 : 1,
+        data: { success: verification.valid, receiptId: options.receiptId, ...verification }
+      };
+    }
+    if (options.subcommand === "status") {
+      return { code: 0, data: { success: true, receipts: await rddStatus(options.projectRoot, options.taskId) } };
+    }
+    if (options.subcommand === "git-check") {
+      const current = (await rddStatus(options.projectRoot))[0];
+      if (!current)
+        return { code: 1, data: { success: false, errors: ["No RDD receipt exists for the Git candidate."] } };
+      return current.valid ? { code: 0, data: { success: true, receiptId: current.id } } : { code: 1, data: { success: false, receiptId: current.id, changedPaths: current.changedPaths } };
+    }
+    return { code: 0, data: { success: true, ...await installHooks(options.projectRoot) } };
+  } catch (error) {
+    return { code: 1, data: { success: false, errors: [error instanceof Error ? error.message : String(error)] } };
+  }
+}
+var execFileAsync4;
+var init_rdd_command = __esm(() => {
+  init_schemas();
+  init_paths();
+  init_rdd_receipt();
+  execFileAsync4 = promisify4(execFile4);
+});
+
 // src/core/ccep/confirmation-gate.ts
 function matchesRiskThreshold(severity, threshold) {
   const order = { low: 0, medium: 1, high: 2 };
@@ -23841,11 +24293,11 @@ var init_output_validator = __esm(() => {
 });
 
 // src/core/ccep/command-parser.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "node:fs";
-import { join as join19 } from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "node:fs";
+import { basename as basename7, join as join20 } from "node:path";
 function readProjectId(projectRoot) {
-  const packageJsonPath = join19(projectRoot, "package.json");
-  if (existsSync4(packageJsonPath)) {
+  const packageJsonPath = join20(projectRoot, "package.json");
+  if (existsSync5(packageJsonPath)) {
     try {
       const pkg = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
       if (pkg.name) {
@@ -23853,7 +24305,7 @@ function readProjectId(projectRoot) {
       }
     } catch {}
   }
-  return projectRoot.split("/").pop() ?? "unknown";
+  return basename7(projectRoot) || "unknown";
 }
 function parseCommand(command, userRequest, projectRoot) {
   const validatedCommand = WorkflowCommandSchema.parse(command);
@@ -23874,8 +24326,8 @@ function parseCommand(command, userRequest, projectRoot) {
       maxVariance: "low"
     }
   };
-  const packageJsonPath = join19(projectRoot, "package.json");
-  if (existsSync4(packageJsonPath)) {
+  const packageJsonPath = join20(projectRoot, "package.json");
+  if (existsSync5(packageJsonPath)) {
     try {
       const pkg = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
       const deps = { ...pkg.dependencies, ...pkg.devDependencies };
@@ -23919,7 +24371,8 @@ var init_command_parser = __esm(() => {
     prototype: { outputFormat: "taskcard", needConfirmation: true, riskThreshold: "medium" },
     handoff: { outputFormat: "plan", needConfirmation: false, riskThreshold: "low" },
     clarify: { outputFormat: "plan", needConfirmation: false, riskThreshold: "low" },
-    security: { outputFormat: "taskcard", needConfirmation: true, riskThreshold: "high" }
+    security: { outputFormat: "taskcard", needConfirmation: true, riskThreshold: "high" },
+    odd: { outputFormat: "taskcard", needConfirmation: true, riskThreshold: "medium" }
   };
 });
 
@@ -23946,10 +24399,10 @@ var init_workflow_profile_loader = __esm(() => {
 });
 
 // src/core/evaluation/harness-catalog.ts
-import { createHash as createHash4 } from "node:crypto";
-import { existsSync as existsSync5, readFileSync as readFileSync4 } from "node:fs";
-import { copyFile as copyFile2, mkdir as mkdir19, readFile as readFile28, readdir as readdir8, rm as rm4, writeFile as writeFile19 } from "node:fs/promises";
-import { dirname as dirname11, join as join20, resolve as resolve27 } from "node:path";
+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 readFile30, 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";
 function catalogIds(catalog = DEFAULT_HARNESS_CATALOG) {
   return catalog.components.map((c) => c.id);
 }
@@ -23999,23 +24452,23 @@ function harnessFingerprint(disabled, contractVersion, ccepProfile = "feature",
     contractVersion,
     ccepProfile
   };
-  return createHash4("sha256").update(JSON.stringify(payload)).digest("hex").slice(0, 16);
+  return createHash5("sha256").update(JSON.stringify(payload)).digest("hex").slice(0, 16);
 }
 async function loadHarnessCatalog(projectRoot) {
-  const overridePath = resolve27(projectRoot, EVAL_DIR2, CATALOG_FILE);
+  const overridePath = resolve29(projectRoot, EVAL_DIR2, CATALOG_FILE);
   try {
-    const raw = await readFile28(overridePath, "utf-8");
+    const raw = await readFile30(overridePath, "utf-8");
     return HarnessCatalogSchema.parse($parse(raw));
   } catch {
     return DEFAULT_HARNESS_CATALOG;
   }
 }
 function activeOverlayPath(projectRoot) {
-  return resolve27(projectRoot, EVAL_DIR2, ACTIVE_OVERLAY_FILE);
+  return resolve29(projectRoot, EVAL_DIR2, ACTIVE_OVERLAY_FILE);
 }
 async function readActiveOverlay(projectRoot) {
   try {
-    const raw = await readFile28(activeOverlayPath(projectRoot), "utf-8");
+    const raw = await readFile30(activeOverlayPath(projectRoot), "utf-8");
     return HarnessOverlaySchema.parse($parse(raw));
   } catch {
     return null;
@@ -24024,7 +24477,7 @@ async function readActiveOverlay(projectRoot) {
 function isProductGraphDisabled(projectRoot) {
   try {
     const path = activeOverlayPath(projectRoot);
-    if (!existsSync5(path))
+    if (!existsSync6(path))
       return false;
     const overlay = HarnessOverlaySchema.parse($parse(readFileSync4(path, "utf-8")));
     return overlay.disableProductGraph === true || overlay.disabledComponents.includes("product_graph");
@@ -24069,55 +24522,55 @@ function applyCatalogToProfile(profile, disabled) {
   return next;
 }
 async function restoreOverlayBackup(projectRoot) {
-  const backupRoot = resolve27(projectRoot, EVAL_DIR2, OVERLAY_BACKUP_DIR);
-  if (!existsSync5(backupRoot))
+  const backupRoot = resolve29(projectRoot, EVAL_DIR2, OVERLAY_BACKUP_DIR);
+  if (!existsSync6(backupRoot))
     return;
-  const configBackup = join20(backupRoot, "config.yml");
-  const configDest = resolve27(projectRoot, ".codeconductor", "config.yml");
-  if (existsSync5(configBackup)) {
-    await mkdir19(dirname11(configDest), { recursive: true });
+  const configBackup = join21(backupRoot, "config.yml");
+  const configDest = resolve29(projectRoot, ".codeconductor", "config.yml");
+  if (existsSync6(configBackup)) {
+    await mkdir20(dirname12(configDest), { recursive: true });
     await copyFile2(configBackup, configDest);
   }
-  const workflowsBackup = join20(backupRoot, "workflows");
-  const workflowsDest = resolve27(projectRoot, ".codeconductor", "workflows");
-  if (existsSync5(workflowsBackup)) {
-    await mkdir19(workflowsDest, { recursive: true });
-    const files = await readdir8(workflowsBackup);
+  const workflowsBackup = join21(backupRoot, "workflows");
+  const workflowsDest = resolve29(projectRoot, ".codeconductor", "workflows");
+  if (existsSync6(workflowsBackup)) {
+    await mkdir20(workflowsDest, { recursive: true });
+    const files = await readdir10(workflowsBackup);
     for (const file of files) {
-      await copyFile2(join20(workflowsBackup, file), join20(workflowsDest, file));
+      await copyFile2(join21(workflowsBackup, file), join21(workflowsDest, file));
     }
   }
-  const overlayBackup = join20(backupRoot, ACTIVE_OVERLAY_FILE);
+  const overlayBackup = join21(backupRoot, ACTIVE_OVERLAY_FILE);
   const overlayDest = activeOverlayPath(projectRoot);
-  if (existsSync5(overlayBackup)) {
+  if (existsSync6(overlayBackup)) {
     await copyFile2(overlayBackup, overlayDest);
-  } else if (existsSync5(overlayDest)) {
+  } else if (existsSync6(overlayDest)) {
     await rm4(overlayDest, { force: true });
   }
 }
 async function snapshotForBackup(projectRoot) {
-  const backupRoot = resolve27(projectRoot, EVAL_DIR2, OVERLAY_BACKUP_DIR);
-  if (existsSync5(backupRoot))
+  const backupRoot = resolve29(projectRoot, EVAL_DIR2, OVERLAY_BACKUP_DIR);
+  if (existsSync6(backupRoot))
     return;
-  await mkdir19(backupRoot, { recursive: true });
-  const configPath = resolve27(projectRoot, ".codeconductor", "config.yml");
-  if (existsSync5(configPath)) {
-    await copyFile2(configPath, join20(backupRoot, "config.yml"));
-  }
-  const workflowsDir = resolve27(projectRoot, ".codeconductor", "workflows");
-  if (existsSync5(workflowsDir)) {
-    const dest = join20(backupRoot, "workflows");
-    await mkdir19(dest, { recursive: true });
-    const files = await readdir8(workflowsDir);
+  await mkdir20(backupRoot, { recursive: true });
+  const configPath = resolve29(projectRoot, ".codeconductor", "config.yml");
+  if (existsSync6(configPath)) {
+    await copyFile2(configPath, join21(backupRoot, "config.yml"));
+  }
+  const workflowsDir = resolve29(projectRoot, ".codeconductor", "workflows");
+  if (existsSync6(workflowsDir)) {
+    const dest = join21(backupRoot, "workflows");
+    await mkdir20(dest, { recursive: true });
+    const files = await readdir10(workflowsDir);
     for (const file of files) {
       if (file.endsWith(".yml")) {
-        await copyFile2(join20(workflowsDir, file), join20(dest, file));
+        await copyFile2(join21(workflowsDir, file), join21(dest, file));
       }
     }
   }
   const overlay = activeOverlayPath(projectRoot);
-  if (existsSync5(overlay)) {
-    await copyFile2(overlay, join20(backupRoot, ACTIVE_OVERLAY_FILE));
+  if (existsSync6(overlay)) {
+    await copyFile2(overlay, join21(backupRoot, ACTIVE_OVERLAY_FILE));
   }
 }
 async function applyHarnessOverlay(projectRoot, disabled, options = {}) {
@@ -24126,13 +24579,13 @@ async function applyHarnessOverlay(projectRoot, disabled, options = {}) {
       await restoreOverlayBackup(projectRoot);
       await snapshotForBackup(projectRoot);
     }
-    const workflowsDir = resolve27(projectRoot, ".codeconductor", "workflows");
-    await mkdir19(workflowsDir, { recursive: true });
-    await mkdir19(resolve27(projectRoot, EVAL_DIR2), { recursive: true });
+    const workflowsDir = resolve29(projectRoot, ".codeconductor", "workflows");
+    await mkdir20(workflowsDir, { recursive: true });
+    await mkdir20(resolve29(projectRoot, EVAL_DIR2), { recursive: true });
     for (const command of WORKFLOW_OVERLAY_COMMANDS) {
       const base = loadWorkflowProfile(command);
       const next = applyCatalogToProfile(base, disabled);
-      await writeFile19(join20(workflowsDir, `${command}.yml`), $stringify(next), "utf-8");
+      await writeFile20(join21(workflowsDir, `${command}.yml`), $stringify(next), "utf-8");
     }
     const needsConfig = disabled.includes("compile_loop") || disabled.includes("council");
     if (needsConfig) {
@@ -24160,7 +24613,7 @@ async function applyHarnessOverlay(projectRoot, disabled, options = {}) {
       contractVersion: options.contractVersion,
       ccepProfile: options.ccepProfile ?? "feature"
     });
-    await writeFile19(activeOverlayPath(projectRoot), $stringify(overlay), "utf-8");
+    await writeFile20(activeOverlayPath(projectRoot), $stringify(overlay), "utf-8");
     return ok(overlay);
   } catch (e) {
     return err(e instanceof Error ? e : new Error(String(e)));
@@ -24271,9 +24724,9 @@ var init_harness_catalog = __esm(() => {
 });
 
 // src/core/openspec/openspec-state.ts
-import { createHash as createHash5 } from "node:crypto";
-import { mkdir as mkdir20, readFile as readFile29, rename as rename3, writeFile as writeFile20 } from "node:fs/promises";
-import { resolve as resolve28 } from "node:path";
+import { createHash as createHash6 } from "node:crypto";
+import { mkdir as mkdir21, readFile as readFile31, rename as rename4, writeFile as writeFile21 } from "node:fs/promises";
+import { resolve as resolve30 } from "node:path";
 function canTransition(from, to) {
   return ALLOWED_TRANSITIONS[from]?.includes(to) ?? false;
 }
@@ -24294,13 +24747,13 @@ function applyBacklogTransition(content, itemId, from, to, progress) {
 }
 async function writeFileAtomic(path, content) {
   const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
-  await writeFile20(tmp, content, "utf-8");
-  await rename3(tmp, path);
+  await writeFile21(tmp, content, "utf-8");
+  await rename4(tmp, path);
 }
 async function loadOpenspecState(projectRoot) {
   try {
-    const filePath = resolve28(projectRoot, STATE_FILE);
-    const content = await readFile29(filePath, "utf-8");
+    const filePath = resolve30(projectRoot, STATE_FILE);
+    const content = await readFile31(filePath, "utf-8");
     const data = JSON.parse(content);
     return ok(OpenspecStateSchema.parse(data));
   } catch (e) {
@@ -24317,10 +24770,10 @@ async function loadOpenspecState(projectRoot) {
 }
 async function writeOpenspecState(projectRoot, state) {
   try {
-    const dir = resolve28(projectRoot, ".codeconductor");
-    await mkdir20(dir, { recursive: true });
+    const dir = resolve30(projectRoot, ".codeconductor");
+    await mkdir21(dir, { recursive: true });
     const validated = OpenspecStateSchema.parse(state);
-    await writeFileAtomic(resolve28(dir, "openspec-state.json"), JSON.stringify(validated, null, 2));
+    await writeFileAtomic(resolve30(dir, "openspec-state.json"), JSON.stringify(validated, null, 2));
     return ok(undefined);
   } catch (e) {
     return err(e instanceof Error ? e : new Error(String(e)));
@@ -24342,7 +24795,7 @@ function getNextTaskCard(state) {
   return null;
 }
 function hashContent(content) {
-  return createHash5("sha256").update(content).digest("hex").slice(0, 16);
+  return createHash6("sha256").update(content).digest("hex").slice(0, 16);
 }
 function serializeItemSnapshot(item) {
   return JSON.stringify({
@@ -24424,19 +24877,19 @@ var init_openspec_state = __esm(() => {
 });
 
 // src/core/ccep/context-resolver.ts
-import { existsSync as existsSync6 } from "node:fs";
-import { readFile as readFile30 } from "node:fs/promises";
-import { join as join21 } from "node:path";
+import { existsSync as existsSync7 } from "node:fs";
+import { readFile as readFile32 } from "node:fs/promises";
+import { join as join22 } from "node:path";
 async function loadProductKnowledge(projectRoot) {
   if (isProductGraphDisabled(projectRoot)) {
     return {};
   }
   const graphPath = productGraphPath(projectRoot);
-  if (!existsSync6(graphPath)) {
+  if (!existsSync7(graphPath)) {
     return {};
   }
   try {
-    const raw = await readFile30(graphPath, "utf-8");
+    const raw = await readFile32(graphPath, "utf-8");
     const graph = ProductGraphSchema.parse(JSON.parse(raw));
     return {
       productName: graph.productName,
@@ -24452,18 +24905,18 @@ async function loadProductKnowledge(projectRoot) {
 }
 async function resolveAstSource(projectRoot) {
   if (isProductGraphDisabled(projectRoot)) {
-    const graphifyPath2 = join21(projectRoot, "graphify-out", "graph.json");
-    if (existsSync6(graphifyPath2)) {
+    const graphifyPath2 = join22(projectRoot, "graphify-out", "graph.json");
+    if (existsSync7(graphifyPath2)) {
       return { source: "graphify", confidence: "medium" };
     }
     return { source: "manual", confidence: "low" };
   }
   const graphPath = productGraphPath(projectRoot);
-  if (existsSync6(graphPath)) {
+  if (existsSync7(graphPath)) {
     return { source: "product-graph", confidence: "high" };
   }
-  const graphifyPath = join21(projectRoot, "graphify-out", "graph.json");
-  if (existsSync6(graphifyPath)) {
+  const graphifyPath = join22(projectRoot, "graphify-out", "graph.json");
+  if (existsSync7(graphifyPath)) {
     return { source: "graphify", confidence: "medium" };
   }
   try {
@@ -24704,6 +25157,12 @@ function councilConsensus(verdicts, config = DEFAULT_CONFIG2) {
       individualVerdicts: verdicts
     };
   }
+  if (config.candidateHash !== undefined) {
+    const mismatched = verdicts.filter((verdict) => verdict.candidateHash !== config.candidateHash);
+    if (mismatched.length > 0) {
+      return escalated(verdicts, `Candidate receipt mismatch for ${mismatched.length} ballot(s) — escalated for human review.`, counts);
+    }
+  }
   const critical = allFindings.filter((f) => f.severity === "critical");
   if (critical.length > 0 && policy === "reject") {
     return {
@@ -25265,12 +25724,26 @@ async function ccepCommand(options) {
         }
         mergedConfig = { ...mergedConfig, ...parsedConfig.data };
       }
+      let currentCandidateHash;
+      if (mergedConfig?.candidateHash !== undefined) {
+        const { captureReceipt: captureReceipt2, collectReceiptPaths: collectReceiptPaths2 } = await Promise.resolve().then(() => (init_rdd_receipt(), exports_rdd_receipt));
+        const receipt = await captureReceipt2(projectRoot, {
+          taskId: "council",
+          phase: "review",
+          paths: await collectReceiptPaths2(projectRoot),
+          outcome: "passed",
+          coverage: "project"
+        });
+        currentCandidateHash = receipt.manifestHash;
+        mergedConfig = { ...mergedConfig, candidateHash: currentCandidateHash };
+      }
       const verdict = councilConsensus(parsedBallots.verdicts, mergedConfig);
       return {
         code: consensusExitCode(verdict.status),
         data: {
           success: verdict.status === "APPROVED",
           command: "ccep consensus",
+          candidateHash: currentCandidateHash,
           verdict
         }
       };
@@ -25507,9 +25980,9 @@ var init_backlog_validator = __esm(() => {
 });
 
 // src/core/openspec/backlog-scanner.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
-import { readFile as readFile31 } from "node:fs/promises";
-import { resolve as resolve29 } from "node:path";
+import { execFileSync } from "node:child_process";
+import { readFile as readFile33 } from "node:fs/promises";
+import { resolve as resolve31 } from "node:path";
 function itemSnapshot(items) {
   const snap = {};
   for (const item of items) {
@@ -25519,12 +25992,12 @@ function itemSnapshot(items) {
 }
 async function scanBacklog(projectRoot, previousSnapshot = {}) {
   try {
-    const filePath = resolve29(projectRoot, BACKLOG_FILENAME);
-    const content = await readFile31(filePath, "utf-8");
+    const filePath = resolve31(projectRoot, BACKLOG_FILENAME);
+    const content = await readFile33(filePath, "utf-8");
     const hash = hashContent(content);
     let fileChanged = true;
     try {
-      const diff = execFileSync2("git", ["diff", "--name-only", "--", BACKLOG_FILENAME], {
+      const diff = execFileSync("git", ["diff", "--name-only", "--", BACKLOG_FILENAME], {
         cwd: projectRoot,
         encoding: "utf-8",
         stdio: ["ignore", "pipe", "ignore"]
@@ -25757,8 +26230,8 @@ var init_backlog_planner = __esm(() => {
 });
 
 // src/core/openspec/openspec-generator.ts
-import { mkdir as mkdir21, rename as rename4, writeFile as writeFile21 } from "node:fs/promises";
-import { basename as basename6, resolve as resolve30 } from "node:path";
+import { mkdir as mkdir22, rename as rename5, writeFile as writeFile22 } from "node:fs/promises";
+import { basename as basename8, resolve as resolve32 } from "node:path";
 function pad3(n) {
   return String(n).padStart(3, "0");
 }
@@ -25823,7 +26296,7 @@ The system MUST ${criterion}.
 
 #### Scenario: SC-${n} ${criterion}
 
-- GIVEN the current behavior in ${item.scope}
+- GIVEN the relevant scoped behavior
 - WHEN this change is applied
 - THEN ${criterion}
 `;
@@ -25837,8 +26310,8 @@ ${blocks.join(`
 `;
 }
 async function writeTasksMarkdown(projectRoot, changePath, cards, options = {}) {
-  await mkdir21(resolve30(projectRoot, changePath), { recursive: true });
-  await writeFile21(resolve30(projectRoot, changePath, "tasks.md"), tasksContent(cards, options), "utf-8");
+  await mkdir22(resolve32(projectRoot, changePath), { recursive: true });
+  await writeFile22(resolve32(projectRoot, changePath, "tasks.md"), tasksContent(cards, options), "utf-8");
 }
 function tasksContent(cards, options = {}) {
   const criteria = options.acceptanceCriteria ?? [];
@@ -25883,19 +26356,19 @@ function tasksContent(cards, options = {}) {
 }
 async function generateOpenspecChange(projectRoot, item, taskCards, options = {}) {
   const slug = buildChangeSlug(item);
-  const changeDir = resolve30(projectRoot, "openspec", "changes", slug);
-  await mkdir21(resolve30(changeDir, "specs"), { recursive: true });
+  const changeDir = resolve32(projectRoot, "openspec", "changes", slug);
+  await mkdir22(resolve32(changeDir, "specs"), { recursive: true });
   const taskOpts = {
     tddRequired: options.tddRequired,
     acceptanceCriteria: options.acceptanceCriteria ?? item.acceptanceCriteria
   };
-  await writeFile21(resolve30(changeDir, "proposal.md"), proposalContent(item), "utf-8");
-  await writeFile21(resolve30(changeDir, "design.md"), designContent(item), "utf-8");
-  await writeFile21(resolve30(changeDir, "tasks.md"), tasksContent(taskCards, taskOpts), "utf-8");
+  await writeFile22(resolve32(changeDir, "proposal.md"), proposalContent(item), "utf-8");
+  await writeFile22(resolve32(changeDir, "design.md"), designContent(item), "utf-8");
+  await writeFile22(resolve32(changeDir, "tasks.md"), tasksContent(taskCards, taskOpts), "utf-8");
   const capability = capabilitySlug(item.title);
-  await mkdir21(resolve30(changeDir, "specs", capability), { recursive: true });
-  await writeFile21(resolve30(changeDir, "specs", capability, "spec.md"), specDelta(item), "utf-8");
-  await writeFile21(resolve30(changeDir, "change.yaml"), `version: 1
+  await mkdir22(resolve32(changeDir, "specs", capability), { recursive: true });
+  await writeFile22(resolve32(changeDir, "specs", capability, "spec.md"), specDelta(item), "utf-8");
+  await writeFile22(resolve32(changeDir, "change.yaml"), `version: 1
 backlogId: ${item.id}
 profile: standard
 capabilities:
@@ -25904,25 +26377,25 @@ capabilities:
   return `openspec/changes/${slug}`;
 }
 async function archiveChangeFolder(projectRoot, changePath) {
-  const src = resolve30(projectRoot, changePath);
-  const slug = basename6(changePath);
-  const destDir = resolve30(projectRoot, "openspec", "changes", "archive");
-  await mkdir21(destDir, { recursive: true });
-  const dest = resolve30(destDir, slug);
-  await rename4(src, dest);
+  const src = resolve32(projectRoot, changePath);
+  const slug = basename8(changePath);
+  const destDir = resolve32(projectRoot, "openspec", "changes", "archive");
+  await mkdir22(destDir, { recursive: true });
+  const dest = resolve32(destDir, slug);
+  await rename5(src, dest);
   return `openspec/changes/archive/${slug}`;
 }
 async function ensureOpenspecConfig(projectRoot) {
-  const configPath = resolve30(projectRoot, "openspec", "config.yaml");
+  const configPath = resolve32(projectRoot, "openspec", "config.yaml");
   try {
     const { access: access7 } = await import("node:fs/promises");
     await access7(configPath);
   } catch {
-    await mkdir21(resolve30(projectRoot, "openspec"), { recursive: true });
+    await mkdir22(resolve32(projectRoot, "openspec"), { recursive: true });
     const stub = `# OpenSpec project config (CodeConductor native compatible)
 schema: spec-driven
 `;
-    await writeFile21(configPath, stub, "utf-8");
+    await writeFile22(configPath, stub, "utf-8");
   }
 }
 var init_openspec_generator = __esm(() => {
@@ -25930,8 +26403,8 @@ var init_openspec_generator = __esm(() => {
 });
 
 // src/core/openspec/spec-quality.ts
-import { readdir as readdir9, readFile as readFile32 } from "node:fs/promises";
-import { join as join22, relative as relative7, resolve as resolve31 } from "node:path";
+import { readdir as readdir11, readFile as readFile34 } from "node:fs/promises";
+import { join as join23, relative as relative10, resolve as resolve33 } from "node:path";
 function uniqueIds(matches) {
   return [...new Set(matches ?? [])];
 }
@@ -26048,12 +26521,12 @@ async function walkMarkdown(dir) {
   const out = [];
   let entries;
   try {
-    entries = await readdir9(dir, { withFileTypes: true });
+    entries = await readdir11(dir, { withFileTypes: true });
   } catch {
     return out;
   }
   for (const entry of entries) {
-    const full = join22(dir, entry.name);
+    const full = join23(dir, entry.name);
     if (entry.isDirectory()) {
       out.push(...await walkMarkdown(full));
     } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -26063,8 +26536,8 @@ async function walkMarkdown(dir) {
   return out;
 }
 async function assessChangeFolder(projectRoot, changePath) {
-  const root = resolve31(projectRoot);
-  const changeRoot = resolve31(root, changePath);
+  const root = resolve33(projectRoot);
+  const changeRoot = resolve33(root, changePath);
   if (!changeRoot.startsWith(root)) {
     return {
       valid: false,
@@ -26082,22 +26555,22 @@ async function assessChangeFolder(projectRoot, changePath) {
       successCriteria: []
     };
   }
-  const specDir = join22(changeRoot, "specs");
+  const specDir = join23(changeRoot, "specs");
   const specFiles = await walkMarkdown(specDir);
-  const extra = ["proposal.md", "design.md"].map((name) => join22(changeRoot, name));
+  const extra = ["proposal.md", "design.md"].map((name) => join23(changeRoot, name));
   const reports = [];
   for (const file of specFiles) {
-    const content = await readFile32(file, "utf-8");
-    reports.push(assessSpecMarkdown(content, relative7(root, file).replace(/\\/g, "/")));
+    const content = await readFile34(file, "utf-8");
+    reports.push(assessSpecMarkdown(content, relative10(root, file).replace(/\\/g, "/")));
   }
   for (const file of extra) {
     let content;
     try {
-      content = await readFile32(file, "utf-8");
+      content = await readFile34(file, "utf-8");
     } catch {
       continue;
     }
-    const rel = relative7(root, file).replace(/\\/g, "/");
+    const rel = relative10(root, file).replace(/\\/g, "/");
     if (PLACEHOLDER.test(content)) {
       reports.push({
         valid: false,
@@ -26141,15 +26614,15 @@ var init_spec_quality = __esm(() => {
   FR_ID = /\bFR-\d{3}\b/g;
   SC_ID = /\bSC-\d{3}\b/g;
   US_AC = /\b(?:US|AC)#?\d+\b/g;
-  GWT = /\bGIVEN\b[\s\S]{0,400}\bWHEN\b[\s\S]{0,400}\bTHEN\b/i;
+  GWT = /\bGIVEN\b[\s\S]*?\bWHEN\b[\s\S]*?\bTHEN\b/i;
   NEEDS_CLARIFICATION = /\[NEEDS CLARIFICATION:[^\]]*\]/gi;
   PLACEHOLDER = /\(To be completed/i;
   HOW_LEAK = /\b(TypeScript|PostgreSQL|Django|React|Spring Boot|package\.json|implements class)\b/i;
 });
 
 // src/core/openspec/spec-analyzer.ts
-import { readFile as readFile33, readdir as readdir10 } from "node:fs/promises";
-import { join as join23, resolve as resolve32 } from "node:path";
+import { readFile as readFile35, readdir as readdir12 } from "node:fs/promises";
+import { join as join24, resolve as resolve34 } from "node:path";
 function unique(ids) {
   return [...new Set(ids)];
 }
@@ -26176,17 +26649,17 @@ function testSection(tasksMarkdown) {
 async function readDeltaSpecs(specDir) {
   let entries;
   try {
-    entries = await readdir10(specDir, { withFileTypes: true });
+    entries = await readdir12(specDir, { withFileTypes: true });
   } catch {
     return "";
   }
   const contents = [];
   for (const entry of entries) {
-    const path = join23(specDir, entry.name);
+    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 readFile33(path, "utf-8"));
+      contents.push(await readFile35(path, "utf-8"));
     }
   }
   return contents.filter(Boolean).join(`
@@ -26264,17 +26737,17 @@ function analyzeSpecArtifacts(input) {
   };
 }
 async function analyzeChangeFolder(projectRoot, changePath, options) {
-  const changeRoot = resolve32(projectRoot, changePath);
-  const specMarkdown = await readDeltaSpecs(join23(changeRoot, "specs"));
+  const changeRoot = resolve34(projectRoot, changePath);
+  const specMarkdown = await readDeltaSpecs(join24(changeRoot, "specs"));
   let tasksMarkdown = "";
   try {
-    tasksMarkdown = await readFile33(join23(changeRoot, "tasks.md"), "utf-8");
+    tasksMarkdown = await readFile35(join24(changeRoot, "tasks.md"), "utf-8");
   } catch {
     tasksMarkdown = "";
   }
   let designMarkdown;
   try {
-    designMarkdown = await readFile33(join23(changeRoot, "design.md"), "utf-8");
+    designMarkdown = await readFile35(join24(changeRoot, "design.md"), "utf-8");
   } catch {
     designMarkdown = undefined;
   }
@@ -26293,18 +26766,18 @@ var init_spec_analyzer = __esm(() => {
 });
 
 // src/core/openspec/spec-sync.ts
-import { mkdir as mkdir22, readFile as readFile34, readdir as readdir11 } from "node:fs/promises";
-import { join as join24, relative as relative8, resolve as resolve33 } from "node:path";
+import { mkdir as mkdir23, readFile as readFile36, 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 readdir11(dir, { withFileTypes: true });
+    entries = await readdir13(dir, { withFileTypes: true });
   } catch {
     return [];
   }
   const files = [];
   for (const entry of entries) {
-    const path = join24(dir, entry.name);
+    const path = join25(dir, entry.name);
     if (entry.isDirectory())
       files.push(...await markdownFiles(path));
     else if (entry.isFile() && entry.name.endsWith(".md"))
@@ -26380,9 +26853,9 @@ ${delta.markdown}`;
 ` };
 }
 async function syncChangeSpecs(projectRoot, changePath) {
-  const root = resolve33(projectRoot);
-  const changeRoot = resolve33(root, changePath);
-  const changeSpecs = join24(changeRoot, "specs");
+  const root = resolve35(projectRoot);
+  const changeRoot = resolve35(root, changePath);
+  const changeSpecs = join25(changeRoot, "specs");
   if (changeRoot !== root && !changeRoot.startsWith(`${root}/`)) {
     return { success: false, syncedPaths: [], errors: ["Change path escapes project root"] };
   }
@@ -26392,34 +26865,34 @@ async function syncChangeSpecs(projectRoot, changePath) {
   }
   const writes = [];
   for (const file of files) {
-    const delta = await readFile34(file, "utf-8");
+    const delta = await readFile36(file, "utf-8");
     const requirements = deltaRequirements(delta);
     if (requirements.length === 0) {
       return {
         success: false,
         syncedPaths: [],
-        errors: [`${relative8(root, file)}: no delta requirements found`]
+        errors: [`${relative11(root, file)}: no delta requirements found`]
       };
     }
-    const relativeSpec = relative8(changeSpecs, file);
-    const target = join24(root, "openspec", "specs", relativeSpec);
+    const relativeSpec = relative11(changeSpecs, file);
+    const target = join25(root, "openspec", "specs", relativeSpec);
     let existing = `# ${relativeSpec.replace(/\\/g, "/")}
 `;
     try {
-      existing = await readFile34(target, "utf-8");
+      existing = await readFile36(target, "utf-8");
     } catch {}
-    const merged = upsertRequirements(existing, requirements, relative8(root, file));
+    const merged = upsertRequirements(existing, requirements, relative11(root, file));
     if (!merged.ok)
       return { success: false, syncedPaths: [], errors: [merged.error] };
     writes.push({ path: target, content: merged.content });
   }
   for (const write of writes) {
-    await mkdir22(resolve33(write.path, ".."), { recursive: true });
+    await mkdir23(resolve35(write.path, ".."), { recursive: true });
     await writeFileAtomic(write.path, write.content);
   }
   return {
     success: true,
-    syncedPaths: writes.map((write) => relative8(root, write.path).replace(/\\/g, "/")),
+    syncedPaths: writes.map((write) => relative11(root, write.path).replace(/\\/g, "/")),
     errors: []
   };
 }
@@ -26435,8 +26908,8 @@ var exports_openspec_command = {};
 __export(exports_openspec_command, {
   openspecCommand: () => openspecCommand
 });
-import { readFile as readFile35 } from "node:fs/promises";
-import { resolve as resolve34 } from "node:path";
+import { readFile as readFile37 } from "node:fs/promises";
+import { resolve as resolve36 } from "node:path";
 async function openspecCommand(options) {
   const { subcommand, itemId, projectRoot, output, reason } = options;
   switch (subcommand) {
@@ -26458,6 +26931,8 @@ async function openspecCommand(options) {
       return handleDone(projectRoot, itemId);
     case "block":
       return handleBlock(projectRoot, itemId, reason);
+    case "unblock":
+      return handleUnblock(projectRoot, itemId);
     case "archive":
       return handleArchive(projectRoot, itemId);
     default:
@@ -26480,7 +26955,7 @@ function fail(command, errors3, extra = {}) {
   };
 }
 async function persistBacklog(projectRoot, content) {
-  await writeFileAtomic(resolve34(projectRoot, BACKLOG_FILENAME), content);
+  await writeFileAtomic(resolve36(projectRoot, BACKLOG_FILENAME), content);
 }
 async function persistState(projectRoot, state) {
   const written = await writeOpenspecState(projectRoot, state);
@@ -26490,7 +26965,7 @@ async function persistState(projectRoot, state) {
   return { ok: true };
 }
 async function readBacklogMarkdown(projectRoot) {
-  return readFile35(resolve34(projectRoot, BACKLOG_FILENAME), "utf-8");
+  return readFile37(resolve36(projectRoot, BACKLOG_FILENAME), "utf-8");
 }
 async function transitionItem(projectRoot, item, to, progress) {
   const content = await readBacklogMarkdown(projectRoot);
@@ -26688,17 +27163,18 @@ async function handleAnalyze(projectRoot, itemId) {
   const policyParts = [];
   for (const name of ["AGENTS.md", "BACKLOG.md"]) {
     try {
-      policyParts.push(await readFile35(resolve34(projectRoot, name), "utf-8"));
+      policyParts.push(await readFile37(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 = false;
+    hasTddEvidence = true;
     for (const card of tddCards) {
-      if (await hasTddRunnerEvidence(projectRoot, card.id)) {
-        hasTddEvidence = true;
+      const expectedPhase = card.phase === "test" ? "red" : "green";
+      if (!await hasTddRunnerEvidence(projectRoot, card.id, expectedPhase)) {
+        hasTddEvidence = false;
         break;
       }
     }
@@ -26883,10 +27359,11 @@ async function handleDone(projectRoot, cardId) {
   const backlog = await loadBacklog(projectRoot);
   const tddRequired = backlog.success ? backlog.data.global.tddRequired : false;
   if (tddRequired && (card.phase === "test" || card.phase === "implement")) {
-    const evidenced = await hasTddRunnerEvidence(projectRoot, cardId);
+    const expectedPhase = card.phase === "test" ? "red" : "green";
+    const evidenced = await hasTddRunnerEvidence(projectRoot, cardId, expectedPhase);
     if (!evidenced) {
       return fail(command, [
-        `Card ${cardId} (${card.phase}) requires verification-runner TDD evidence. Run captureTddSuiteEvidence before openspec done.`
+        `Card ${cardId} (${card.phase}) requires current ${expectedPhase.toUpperCase()} verification-runner TDD evidence. Run captureTddSuiteEvidence before openspec done.`
       ]);
     }
   }
@@ -26961,6 +27438,57 @@ async function handleBlock(projectRoot, cardId, reason) {
     }
   };
 }
+async function handleUnblock(projectRoot, cardId) {
+  const command = "openspec unblock";
+  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);
+  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);
+  if (!itemLoaded.ok)
+    return itemLoaded.response;
+  if (itemLoaded.item.status !== "BLOCKED") {
+    return fail(command, [
+      `Backlog item ${itemLoaded.item.id} must be BLOCKED before unblock (got ${itemLoaded.item.status})`
+    ]);
+  }
+  const state = setTaskCardStatus(loaded.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,
+      acceptanceCriteria: itemLoaded.item.acceptanceCriteria
+    });
+  }
+  const transition = await transitionItem(projectRoot, itemLoaded.item, "READY");
+  if (!transition.ok)
+    return fail(command, [transition.error]);
+  return {
+    code: 0,
+    data: {
+      success: true,
+      command,
+      cardId,
+      cardStatus: "pending",
+      itemId: itemLoaded.item.id,
+      itemStatus: "READY",
+      nextStep: `Run openspec plan ${itemLoaded.item.id}.`
+    }
+  };
+}
 async function handleArchive(projectRoot, itemId) {
   const command = "openspec archive";
   if (!itemId) {
@@ -27037,7 +27565,7 @@ async function handleArchive(projectRoot, itemId) {
     }
   };
 }
-var KNOWN_SUBCOMMANDS = "validate, scan, plan, analyze, status, next, start, done, block, archive";
+var KNOWN_SUBCOMMANDS = "validate, scan, plan, analyze, status, next, start, done, block, unblock, archive";
 var init_openspec_command = __esm(() => {
   init_backlog_parser();
   init_backlog_validator();
@@ -27055,12 +27583,194 @@ var init_openspec_command = __esm(() => {
   init_loop_engine();
 });
 
+// src/core/ccep/context-assembly.ts
+function resumeDecision(changedPaths) {
+  if (changedPaths.length === 0)
+    return { status: "ready" };
+  return {
+    status: "needs_decision",
+    changedPaths,
+    question: `Workspace changed in ${changedPaths.join(", ")}. Continue with the current workspace?`
+  };
+}
+var init_context_assembly = () => {};
+
+// src/core/delivery/delivery-ledger.ts
+import { createHash as createHash7 } from "node:crypto";
+import { mkdir as mkdir24, readFile as readFile38, writeFile as writeFile23 } from "node:fs/promises";
+import { resolve as resolve37, sep as sep8 } 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`);
+}
+async function fingerprintWorkspace(projectRoot, paths) {
+  const root = resolve37(projectRoot);
+  const fingerprints = {};
+  for (const path of paths) {
+    const candidate = resolve37(root, path);
+    if (candidate !== root && !candidate.startsWith(`${root}${sep8}`)) {
+      fingerprints[path] = "outside-root";
+      continue;
+    }
+    try {
+      fingerprints[path] = createHash7("sha256").update(await readFile38(candidate)).digest("hex");
+    } catch {
+      fingerprints[path] = "missing";
+    }
+  }
+  return fingerprints;
+}
+function render(ledger) {
+  return `# Delivery Ledger: ${ledger.id}
+
+${START}
+\`\`\`yaml
+${$stringify(ledger)}\`\`\`
+${END}
+`;
+}
+function parseLedger(content) {
+  const match = content.match(/<!-- delivery-ledger-start -->\n```yaml\n([\s\S]*?)```\n<!-- delivery-ledger-end -->/);
+  if (!match)
+    throw new Error("Invalid delivery ledger format");
+  return DeliveryLedgerSchema.parse($parse(match[1]));
+}
+async function loadDeliveryLedger(projectRoot, id) {
+  return parseLedger(await readFile38(ledgerPath(projectRoot, id), "utf-8"));
+}
+async function createDeliveryLedger(projectRoot, input) {
+  const request = DeliveryLedgerRequestSchema.parse(input);
+  const path = ledgerPath(projectRoot, request.id);
+  try {
+    return { created: false, ledger: await loadDeliveryLedger(projectRoot, request.id) };
+  } catch (error) {
+    if (!(error instanceof Error) || !error.message.includes("ENOENT"))
+      throw error;
+  }
+  const now = new Date().toISOString();
+  const ledger = DeliveryLedgerSchema.parse({
+    version: 1,
+    id: request.id,
+    taskCard: request.taskCard,
+    tasks: request.tasks,
+    evidence: request.taskCard.evidenceRequired,
+    nextStep: request.nextStep,
+    memoryTopicKey: `delivery:${request.id}`,
+    workspace: await fingerprintWorkspace(projectRoot, request.taskCard.targetFiles),
+    createdAt: now,
+    updatedAt: now
+  });
+  await mkdir24(resolve37(projectRoot, DELIVERY_DIR), { recursive: true });
+  try {
+    await writeFile23(path, render(ledger), { encoding: "utf-8", flag: "wx" });
+    return { created: true, ledger };
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("EEXIST")) {
+      return { created: false, ledger: await loadDeliveryLedger(projectRoot, request.id) };
+    }
+    throw error;
+  }
+}
+async function reconcileDeliveryLedger(projectRoot, id) {
+  const ledger = await loadDeliveryLedger(projectRoot, id);
+  const current = await fingerprintWorkspace(projectRoot, Object.keys(ledger.workspace));
+  const changedPaths = Object.keys(ledger.workspace).filter((path) => ledger.workspace[path] !== current[path]);
+  return { ledger, changedPaths };
+}
+var DELIVERY_DIR = ".codeconductor/delivery", START = "<!-- delivery-ledger-start -->", END = "<!-- delivery-ledger-end -->";
+var init_delivery_ledger = __esm(() => {
+  init_dist();
+  init_schemas();
+});
+
+// src/commands/odd.command.ts
+var exports_odd_command = {};
+__export(exports_odd_command, {
+  oddCommand: () => oddCommand
+});
+async function oddCommand(options) {
+  if (options.subcommand === "create") {
+    let input = options.input;
+    if (typeof input === "string") {
+      try {
+        input = JSON.parse(input);
+      } catch {
+        return { code: 1, data: { success: false, errors: ["Invalid JSON input"] } };
+      }
+    }
+    const request = DeliveryLedgerRequestSchema.safeParse(input);
+    if (!request.success)
+      return { code: 1, data: { success: false, errors: request.error.issues } };
+    if (!request.data.authorized || request.data.route !== "tracked") {
+      return { code: 0, data: { success: true, created: false, reason: "route_not_tracked" } };
+    }
+    const issues = validateTaskCardForProfile(loadWorkflowProfile("odd", options.projectRoot), request.data.taskCard);
+    if (issues.length > 0)
+      return { code: 1, data: { success: false, errors: issues } };
+    try {
+      const result = await createDeliveryLedger(options.projectRoot, request.data);
+      return { code: 0, data: { success: true, ...result, ...result.created ? {} : { existing: true } } };
+    } catch (error) {
+      return { code: 1, data: { success: false, errors: [String(error)] } };
+    }
+  }
+  if (!options.id)
+    return { code: 1, data: { success: false, errors: ["Missing ledger id"] } };
+  try {
+    if (options.subcommand === "read") {
+      return { code: 0, data: { success: true, ledger: await loadDeliveryLedger(options.projectRoot, options.id) } };
+    }
+    if (options.subcommand === "reconcile") {
+      const result = await reconcileDeliveryLedger(options.projectRoot, options.id);
+      const memory = await loadMemoryIndex(options.projectRoot);
+      const { rddCommand: rddCommand2 } = await Promise.resolve().then(() => (init_rdd_command(), exports_rdd_command));
+      const rdd = await rddCommand2({
+        subcommand: "status",
+        projectRoot: options.projectRoot,
+        taskId: result.ledger.taskCard.id
+      });
+      const receipts = rdd.data.receipts ?? [];
+      const staleReceipt = receipts.some((receipt) => receipt.valid === false);
+      const changedPaths = staleReceipt ? [...result.changedPaths, "RDD receipt"].sort() : result.changedPaths;
+      return {
+        code: 0,
+        data: {
+          success: true,
+          status: changedPaths.length === 0 ? "ready" : "conflict",
+          resume: resumeDecision(changedPaths),
+          rdd,
+          memory: memory.success ? "available" : "unavailable",
+          memoryPointers: memory.success ? memory.data.pointers.filter((pointer) => pointer.topic_key === result.ledger.memoryTopicKey) : [],
+          ...result,
+          changedPaths
+        }
+      };
+    }
+    return { code: 1, data: { success: false, errors: [`Unknown odd subcommand: ${options.subcommand}`] } };
+  } catch (error) {
+    return { code: 1, data: { success: false, errors: [String(error)] } };
+  }
+}
+var init_odd_command = __esm(() => {
+  init_memory_index();
+  init_context_assembly();
+  init_task_card_validator();
+  init_workflow_profile_loader();
+  init_delivery_ledger();
+  init_schemas();
+});
+
 // src/core/hooks/hook-runner.ts
 function normalizeCommand(raw) {
   return raw.replace(/\s+/g, " ").trim();
 }
 function stripGitBinary(command) {
-  return command.replace(/(?:^|[\\/])git(?:\.exe)?\b/i, "git");
+  const match = command.match(/^(?:&\s*)?("[^"]+"|'[^']+'|[^\s]+)([\s\S]*)$/);
+  if (!match)
+    return command;
+  const binary = match[1].replace(/^["']|["']$/g, "").replace(/\\/g, "/").split("/").pop();
+  return /^git(?:\.exe)?$/i.test(binary ?? "") ? `git${match[2]}` : command;
 }
 function evaluatePath(filePath) {
   if (SENSITIVE_PATH.test(filePath.replace(/\//g, "\\")) || SENSITIVE_PATH.test(filePath)) {
@@ -27069,9 +27779,44 @@ function evaluatePath(filePath) {
   return allow();
 }
 function evaluateCommand(rawCommand) {
-  const command = stripGitBinary(normalizeCommand(rawCommand));
+  if (/(?:curl|wget)\b.+\|\s*(sh|bash|zsh|cmd)\b/i.test(normalizeCommand(rawCommand)))
+    return deny(MSG_POLICY);
+  const tokens = rawCommand.match(/"[^"]*"|'[^']*'|[^"';&|\r\n]+|[;&|\r\n]+/g) ?? [];
+  const commands = [];
+  let current = "";
+  for (const token of tokens) {
+    if (/^[;&|\r\n]+$/.test(token) && !(token === "&" && !current.trim())) {
+      commands.push(current);
+      current = "";
+    } else {
+      current += token;
+    }
+  }
+  commands.push(current);
+  let verdict = allow();
+  for (const part of commands) {
+    const result = evaluateSingleCommand(part);
+    if (result.action === "deny")
+      return result;
+    if (result.action === "ask")
+      verdict = result;
+  }
+  return verdict;
+}
+function evaluateSingleCommand(rawCommand) {
+  let command = stripGitBinary(normalizeCommand(rawCommand));
   if (!command)
     return allow();
+  if (/^git\s/i.test(command)) {
+    const words = command.match(/"[^"]*"|'[^']*'|\S+/g) ?? [];
+    let index = 1;
+    while (words[index]?.startsWith("-")) {
+      const option = words[index++];
+      if (/^(?:-C|-c|--git-dir|--work-tree|--namespace)$/.test(option))
+        index++;
+    }
+    command = ["git", ...words.slice(index)].join(" ");
+  }
   if (SENSITIVE_PATH.test(command) && READ_LIKE.test(command)) {
     return deny(MSG_SECRET);
   }
@@ -27094,9 +27839,12 @@ function evaluateCommand(rawCommand) {
   }
   if (/^rm\s+-rf\s+(\*|[\\/])/i.test(command))
     return deny(MSG_POLICY);
-  if (/^sudo\s+/i.test(command))
+  const windowsTarget = /(?:^|\s)["']?(?:[a-z]:[\\/]|\\|\*)/i.test(command);
+  if (windowsTarget && /^Remove-Item\b/i.test(command) && /\s-(?:Recurse|r)\b/i.test(command) && /\s-(?:Force|f)\b/i.test(command))
     return deny(MSG_POLICY);
-  if (/(?:curl|wget)\b.+\|\s*(sh|bash|zsh|cmd)\b/i.test(command))
+  if (windowsTarget && /^(?:rd|rmdir|del|erase)\b/i.test(command) && /\s\/s\b/i.test(command))
+    return deny(MSG_POLICY);
+  if (/^sudo\s+/i.test(command))
     return deny(MSG_POLICY);
   if (/^chmod\s+777\b/i.test(command))
     return deny(MSG_POLICY);
@@ -27123,13 +27871,16 @@ function evaluatePreTool(input) {
 function formatHookOutput(verdict, format) {
   if (format === "agy") {
     if (verdict.action === "deny") {
-      return JSON.stringify({ decision: "deny", error: verdict.message });
+      return JSON.stringify({ decision: "deny", reason: verdict.message });
     }
     if (verdict.action === "ask") {
       return JSON.stringify({ decision: "ask" });
     }
     return JSON.stringify({ decision: "allow" });
   }
+  if (verdict.action === "ask") {
+    return JSON.stringify({ hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "ask" } });
+  }
   return "";
 }
 function claudeExitCode(verdict) {
@@ -27140,11 +27891,24 @@ function parseAgyPayload(raw) {
     return {};
   try {
     const parsed = JSON.parse(raw);
-    const args = parsed.arguments ?? {};
+    const args = parsed.toolCall?.args ?? parsed.arguments ?? {};
     return {
-      toolName: parsed.toolName,
-      command: args.CommandLine,
-      filePath: args.TargetFile ?? args.AbsolutePath
+      toolName: typeof (parsed.toolCall?.name ?? parsed.toolName) === "string" ? parsed.toolCall?.name ?? parsed.toolName : undefined,
+      command: typeof args.CommandLine === "string" ? args.CommandLine : undefined,
+      filePath: typeof args.TargetFile === "string" ? args.TargetFile : typeof args.AbsolutePath === "string" ? args.AbsolutePath : undefined
+    };
+  } catch {
+    return {};
+  }
+}
+function parseClaudePayload(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    const input = parsed.tool_input ?? {};
+    return {
+      toolName: typeof parsed.tool_name === "string" ? parsed.tool_name : undefined,
+      command: typeof input.command === "string" ? input.command : undefined,
+      filePath: typeof input.file_path === "string" ? input.file_path : undefined
     };
   } catch {
     return {};
@@ -27206,14 +27970,17 @@ __export(exports_hook_command, {
   readStdinText: () => readStdinText
 });
 import { spawnSync } from "node:child_process";
-import { existsSync as existsSync7 } from "node:fs";
-import { resolve as resolve35 } from "node:path";
+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";
 function detectFormat(explicit, stdinText) {
   if (explicit)
     return explicit;
-  const trimmed = stdinText.trim();
-  if (trimmed.startsWith("{"))
-    return "agy";
+  try {
+    const payload = JSON.parse(stdinText);
+    if (payload && (("toolCall" in payload) || ("toolName" in payload) || ("workspacePaths" in payload)))
+      return "agy";
+  } catch {}
   return "claude";
 }
 async function readStdinText() {
@@ -27225,22 +27992,22 @@ async function readStdinText() {
   }
   return Buffer.concat(chunks).toString("utf8");
 }
-function resolvePreToolInput(options, stdinText) {
-  const fromStdin = parseAgyPayload(stdinText);
+function resolvePreToolInput(options, stdinText, format) {
+  const fromStdin = format === "agy" ? parseAgyPayload(stdinText) : parseClaudePayload(stdinText);
   return {
-    command: options.command ?? process.env.CLAUDE_TOOL_INPUT_COMMAND ?? fromStdin.command,
-    filePath: options.filePath ?? process.env.CLAUDE_TOOL_INPUT_FILE_PATH ?? fromStdin.filePath,
+    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,
     toolName: fromStdin.toolName
   };
 }
 async function sessionLines(projectRoot) {
-  const backlogPath = resolve35(projectRoot, "BACKLOG.md");
-  const profilePath = resolve35(projectRoot, ".codeconductor", "evaluation", "execution-profile.yml");
+  const backlogPath = resolve38(projectRoot, "BACKLOG.md");
+  const profilePath = resolve38(projectRoot, ".codeconductor", "evaluation", "execution-profile.yml");
   return [
     "[CodeConductor] Session start",
     "Skills: openspec, backlog, evaluation, testing-tdd — invoke via /cc-* then CLI.",
-    existsSync7(backlogPath) ? "BACKLOG.md present — run: bun run dev openspec status" : "No BACKLOG.md — author with /cc-backlog if you need an item queue.",
-    existsSync7(profilePath) ? "Scorecard profile on disk — run: bun run dev scorecard models" : "Scorecard: bun run dev scorecard create --task <id> --from-diff",
+    existsSync8(backlogPath) ? "BACKLOG.md present — run: bun run dev openspec status" : "No BACKLOG.md — author with /cc-backlog if you need an item queue.",
+    existsSync8(profilePath) ? "Scorecard profile on disk — run: bun run dev scorecard models" : "Scorecard: bun run dev scorecard create --task <id> --from-diff",
     "Hooks: bun run dev hook pre-tool | post-tool | session-start",
     "Eval suites: bun run dev scorecard suite-run --suite workflow-gates"
   ];
@@ -27256,15 +28023,15 @@ async function hookCommand(options) {
     return { code: 0, data: { success: true, command: "hook session-start" } };
   }
   if (event === "post-tool") {
-    const filePath = options.filePath ?? process.env.CLAUDE_TOOL_INPUT_FILE_PATH ?? parseAgyPayload(stdinText).filePath;
-    formatWrittenFile(filePath);
+    const filePath = resolvePreToolInput(options, stdinText, format).filePath;
+    formatWrittenFile(filePath, options.projectRoot);
     if (format === "agy") {
       process.stdout.write(`{}
 `);
     }
     return { code: 0, data: { success: true, command: "hook post-tool" } };
   }
-  const input = resolvePreToolInput(options, stdinText);
+  const input = resolvePreToolInput(options, stdinText, format);
   const verdict = evaluatePreTool(input);
   if (format === "agy") {
     process.stdout.write(`${formatHookOutput(verdict, "agy")}
@@ -27278,23 +28045,40 @@ async function hookCommand(options) {
     process.stderr.write(`${verdict.message}
 `);
   }
+  const output = formatHookOutput(verdict, "claude");
+  if (output)
+    process.stdout.write(`${output}
+`);
   return {
     code: claudeExitCode(verdict),
     data: { success: verdict.action !== "deny", command: "hook pre-tool", verdict }
   };
 }
-function formatWrittenFile(filePath) {
-  if (!filePath || !existsSync7(filePath))
+function formatWrittenFile(filePath, projectRoot) {
+  if (!filePath)
+    return;
+  filePath = resolve38(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 = { stdio: "ignore", windowsHide: true };
+  const opts = { cwd: projectRoot, stdio: "ignore", windowsHide: true, timeout: 5000 };
+  const require2 = createRequire2(resolve38(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);
+    } catch {}
+  }
   if (prettier.test(filePath)) {
-    spawnSync("npx", ["--no-install", "prettier", "--write", filePath], opts);
+    runNodeTool("prettier", ["--write", filePath]);
   }
   if (eslint.test(filePath)) {
-    spawnSync("npx", ["--no-install", "eslint", "--fix", filePath], opts);
+    runNodeTool("eslint", ["--fix", filePath]);
   }
   if (python.test(filePath)) {
     spawnSync("ruff", ["format", filePath], opts);
@@ -27701,7 +28485,13 @@ function ccGainToScorecardImpact(result) {
 }
 
 // src/core/evaluation/scorecard-signals.ts
-import { execFileSync as execFileSync3 } from "node:child_process";
+import { execFileSync as execFileSync2 } from "node:child_process";
+function parseScopeFiles(scope) {
+  return scope.split(/[,;]/).map((entry) => entry.trim().replace(/[.;:]$/, "").replace(/^`|`$/g, "")).filter(Boolean);
+}
+function isGeneratedBuildCache(path) {
+  return /(^|\/)\.gradle\//.test(path);
+}
 function collectScorecardSignals(projectRoot, scopeFiles, extra) {
   const findings = [];
   const overrides = {};
@@ -27725,7 +28515,7 @@ function collectScorecardSignals(projectRoot, scopeFiles, extra) {
   }
   let diff = "";
   try {
-    diff = execFileSync3("git", ["diff", "HEAD"], {
+    diff = execFileSync2("git", ["diff", "HEAD"], {
       cwd: projectRoot,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"]
@@ -27748,7 +28538,7 @@ function collectScorecardSignals(projectRoot, scopeFiles, extra) {
       changedFiles.add(m[1]);
   }
   if (scopeFiles && scopeFiles.length > 0) {
-    const outOfScope = [...changedFiles].filter((f) => !scopeFiles.some((s) => f.includes(s.replace(/\*\*/g, ""))));
+    const outOfScope = [...changedFiles].filter((file) => !isGeneratedBuildCache(file)).filter((f) => !scopeFiles.some((s) => f.includes(s.replace(/\*\*/g, ""))));
     if (outOfScope.length > 0) {
       overrides.minimal_diff = {
         score: 0,
@@ -27819,25 +28609,25 @@ var init_scorecard_signals = __esm(() => {
 });
 
 // src/core/evaluation/harness-experiment.ts
-import { existsSync as existsSync8 } from "node:fs";
-import { cp, mkdir as mkdir23, readFile as readFile36, readdir as readdir12, writeFile as writeFile22 } from "node:fs/promises";
-import { dirname as dirname12, join as join25, resolve as resolve36 } from "node:path";
+import { existsSync as existsSync9 } from "node:fs";
+import { cp, mkdir as mkdir25, readFile as readFile39, readdir as readdir14, writeFile as writeFile24 } from "node:fs/promises";
+import { dirname as dirname14, join as join26, resolve as resolve39 } from "node:path";
 function experimentDir(projectRoot, experimentId) {
-  return resolve36(projectRoot, EVAL_DIR2, EXPERIMENTS_DIR, experimentId);
+  return resolve39(projectRoot, EVAL_DIR2, EXPERIMENTS_DIR, experimentId);
 }
 function experimentYamlPath(projectRoot, experimentId) {
-  return join25(experimentDir(projectRoot, experimentId), "experiment.yml");
+  return join26(experimentDir(projectRoot, experimentId), "experiment.yml");
 }
 async function loadHarnessSuite(projectRoot, suiteId, suitePath) {
   const candidates = suitePath ? [suitePath] : [
-    resolve36(projectRoot, "eval", "suites", suiteId, "suite.yml"),
-    resolve36(projectRoot, EVAL_DIR2, "suites", suiteId, "suite.yml")
+    resolve39(projectRoot, "eval", "suites", suiteId, "suite.yml"),
+    resolve39(projectRoot, EVAL_DIR2, "suites", suiteId, "suite.yml")
   ];
   for (const path of candidates) {
-    if (!existsSync8(path))
+    if (!existsSync9(path))
       continue;
     try {
-      const suite = HarnessSuiteSchema.parse($parse(await readFile36(path, "utf-8")));
+      const suite = HarnessSuiteSchema.parse($parse(await readFile39(path, "utf-8")));
       return ok({ ...suite, path });
     } catch (e) {
       return err(e instanceof Error ? e : new Error(String(e)));
@@ -27847,7 +28637,7 @@ async function loadHarnessSuite(projectRoot, suiteId, suitePath) {
 }
 async function loadExperiment(projectRoot, experimentId) {
   try {
-    const raw = await readFile36(experimentYamlPath(projectRoot, experimentId), "utf-8");
+    const raw = await readFile39(experimentYamlPath(projectRoot, experimentId), "utf-8");
     return ok(HarnessExperimentSchema.parse($parse(raw)));
   } catch (e) {
     if (e.code === "ENOENT") {
@@ -27857,10 +28647,10 @@ async function loadExperiment(projectRoot, experimentId) {
   }
 }
 async function listExperiments(projectRoot) {
-  const root = resolve36(projectRoot, EVAL_DIR2, EXPERIMENTS_DIR);
-  if (!existsSync8(root))
+  const root = resolve39(projectRoot, EVAL_DIR2, EXPERIMENTS_DIR);
+  if (!existsSync9(root))
     return [];
-  const ids = await readdir12(root);
+  const ids = await readdir14(root);
   const experiments = [];
   for (const id of ids) {
     const loaded = await loadExperiment(projectRoot, id);
@@ -27936,9 +28726,9 @@ function generateExperimentId(suiteId, now = new Date) {
   return `abl-${date}-${suiteId}-${rand}`;
 }
 async function copyFixture(suitePath, fixtureDir, dest) {
-  const source = fixtureDir ? resolve36(dirname12(suitePath), fixtureDir) : join25(dirname12(suitePath), "fixture");
-  await mkdir23(dest, { recursive: true });
-  if (existsSync8(source)) {
+  const source = fixtureDir ? resolve39(dirname14(suitePath), fixtureDir) : join26(dirname14(suitePath), "fixture");
+  await mkdir25(dest, { recursive: true });
+  if (existsSync9(source)) {
     await cp(source, dest, { recursive: true });
   }
 }
@@ -27959,12 +28749,12 @@ async function startHarnessExperiment(projectRoot, options) {
     suitePath: suite.data.path
   };
   const root = experimentDir(projectRoot, experimentId);
-  await mkdir23(root, { recursive: true });
-  await writeFile22(experimentYamlPath(projectRoot, experimentId), $stringify(experiment), "utf-8");
-  await writeFile22(join25(root, "EXPERIMENT.md"), formatExperimentMarkdown(experiment), "utf-8");
+  await mkdir25(root, { recursive: true });
+  await writeFile24(experimentYamlPath(projectRoot, experimentId), $stringify(experiment), "utf-8");
+  await writeFile24(join26(root, "EXPERIMENT.md"), formatExperimentMarkdown(experiment), "utf-8");
   for (const task of suite.data.tasks) {
     for (const variantId of variants) {
-      const runRoot = join25(root, "runs", task.id, variantDirName(variantId));
+      const runRoot = join26(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);
@@ -27976,7 +28766,7 @@ async function startHarnessExperiment(projectRoot, options) {
       });
       if (!overlay.success)
         return overlay;
-      await writeFile22(join25(runRoot, "TASK.md"), formatTaskCard(task, experimentId, variantId), "utf-8");
+      await writeFile24(join26(runRoot, "TASK.md"), formatTaskCard(task, experimentId, variantId), "utf-8");
     }
   }
   return ok(experiment);
@@ -28010,8 +28800,8 @@ var init_harness_experiment = __esm(() => {
 
 // src/core/evaluation/suite-run.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { existsSync as existsSync9 } from "node:fs";
-import { resolve as resolve37 } from "node:path";
+import { existsSync as existsSync10 } from "node:fs";
+import { resolve as resolve40 } from "node:path";
 async function runHarnessSuiteTasks(projectRoot, suiteId, suitePath) {
   const suite = await loadHarnessSuite(projectRoot, suiteId, suitePath);
   if (!suite.success) {
@@ -28071,7 +28861,7 @@ function runTaskCommand(projectRoot, task) {
   if (parts.length === 0) {
     return { ok: false, detail: "Empty testCommand" };
   }
-  const bin = parts[0] === "bun" && existsSync9(resolve37(projectRoot, "src/cli/main.ts")) ? "bun" : parts[0];
+  const bin = parts[0] === "bun" && existsSync10(resolve40(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,
@@ -28122,11 +28912,11 @@ var init_suite_run = __esm(() => {
 });
 
 // src/core/evaluation/execution-profile.ts
-import { readFile as readFile37 } from "node:fs/promises";
-import { resolve as resolve38 } from "node:path";
+import { readFile as readFile40 } from "node:fs/promises";
+import { resolve as resolve41 } from "node:path";
 async function loadExecutionProfile(projectRoot, defaultTarget = "opencode") {
   try {
-    const content = await readFile37(resolve38(projectRoot, PROFILE_FILE), "utf-8");
+    const content = await readFile40(resolve41(projectRoot, PROFILE_FILE), "utf-8");
     const data = $parse(content);
     return ExecutionProfileSchema.parse(data);
   } catch {
@@ -28206,14 +28996,14 @@ var init_execution_profile = __esm(() => {
 });
 
 // src/core/evaluation/prompt-diff.ts
-import { readFile as readFile38, readdir as readdir13 } from "node:fs/promises";
-import { join as join26, resolve as resolve39 } from "node:path";
+import { readFile as readFile41, readdir as readdir15 } from "node:fs/promises";
+import { join as join27, resolve as resolve42 } from "node:path";
 function normalizeVersion(v) {
   return v.startsWith("v") ? v : `v${v}`;
 }
 async function listPromptFiles(dir) {
   try {
-    const entries = await readdir13(dir, { withFileTypes: true });
+    const entries = await readdir15(dir, { withFileTypes: true });
     return entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => e.name);
   } catch {
     return [];
@@ -28256,30 +29046,30 @@ async function diffPromptVersions(fromVersion, toVersion, options = {}) {
   const fromV = normalizeVersion(fromVersion);
   const toV = normalizeVersion(toVersion);
   const searchRoots = [
-    resolve39(options.projectRoot ?? PACKAGE_ROOT, ".agents", "prompts"),
-    join26(ROOT_PRESETS_DIR, target, "prompts"),
-    join26(ROOT_PRESETS_DIR, "opencode", "prompts")
+    resolve42(options.projectRoot ?? PACKAGE_ROOT, ".agents", "prompts"),
+    join27(ROOT_PRESETS_DIR, target, "prompts"),
+    join27(ROOT_PRESETS_DIR, "opencode", "prompts")
   ];
   let fromDir = "";
   let toDir = "";
   for (const root of searchRoots) {
-    const f = join26(root, fromV);
-    const t = join26(root, toV);
+    const f = join27(root, fromV);
+    const t = join27(root, toV);
     try {
-      await readFile38(join26(f, "orchestrator.md"), "utf-8");
+      await readFile41(join27(f, "orchestrator.md"), "utf-8");
       fromDir = f;
       toDir = t;
       break;
     } catch {}
   }
   if (!fromDir) {
-    fromDir = join26(ROOT_PRESETS_DIR, "opencode", "prompts", fromV);
-    toDir = join26(ROOT_PRESETS_DIR, "opencode", "prompts", toV);
+    fromDir = join27(ROOT_PRESETS_DIR, "opencode", "prompts", fromV);
+    toDir = join27(ROOT_PRESETS_DIR, "opencode", "prompts", toV);
   } else {
     try {
-      await readFile38(join26(toDir, "orchestrator.md"), "utf-8");
+      await readFile41(join27(toDir, "orchestrator.md"), "utf-8");
     } catch {
-      toDir = join26(ROOT_PRESETS_DIR, "opencode", "prompts", toV);
+      toDir = join27(ROOT_PRESETS_DIR, "opencode", "prompts", toV);
     }
   }
   const fromFiles = await listPromptFiles(fromDir);
@@ -28297,12 +29087,12 @@ async function diffPromptVersions(fromVersion, toVersion, options = {}) {
     let oldText = "";
     let newText = "";
     try {
-      oldText = await readFile38(join26(fromDir, name), "utf-8");
+      oldText = await readFile41(join27(fromDir, name), "utf-8");
     } catch {
       oldText = "";
     }
     try {
-      newText = await readFile38(join26(toDir, name), "utf-8");
+      newText = await readFile41(join27(toDir, name), "utf-8");
     } catch {
       newText = "";
     }
@@ -28341,13 +29131,13 @@ var init_prompt_diff = __esm(() => {
 });
 
 // src/core/evaluation/regression-checklist.ts
-import { execFileSync as execFileSync4 } from "node:child_process";
-import { mkdir as mkdir24, readFile as readFile39, writeFile as writeFile23 } from "node:fs/promises";
-import { dirname as dirname13, resolve as resolve40 } from "node:path";
+import { execFileSync as execFileSync3 } from "node:child_process";
+import { mkdir as mkdir26, readFile as readFile42, writeFile as writeFile25 } from "node:fs/promises";
+import { dirname as dirname15, resolve as resolve43 } from "node:path";
 async function loadRegressionChecklist() {
   try {
-    const path = resolve40(ROOT_PRESETS_DIR, "templates", "regression-checklist.yml");
-    const content = await readFile39(path, "utf-8");
+    const path = resolve43(ROOT_PRESETS_DIR, "templates", "regression-checklist.yml");
+    const content = await readFile42(path, "utf-8");
     const data = $parse(content);
     return data.checks ?? [];
   } catch {
@@ -28361,7 +29151,7 @@ function runCheckCommand(cmd, cwd) {
   if (!file)
     return { passed: false, message: "Empty command" };
   try {
-    execFileSync4(file, args, {
+    execFileSync3(file, args, {
       cwd,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"],
@@ -28402,9 +29192,9 @@ async function runRegressionChecklist(projectRoot, options = {}) {
       checks,
       timestamp: new Date().toISOString()
     };
-    const outPath = resolve40(projectRoot, ".codeconductor/evaluation/regression-last.json");
-    await mkdir24(dirname13(outPath), { recursive: true });
-    await writeFile23(outPath, JSON.stringify(report, null, 2), "utf-8");
+    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");
     return ok(report);
   } catch (e) {
     return err(e instanceof Error ? e : new Error(String(e)));
@@ -28446,8 +29236,8 @@ var init_model_comparison = __esm(() => {
 });
 
 // src/core/evaluation/cost-quality-matrix.ts
-import { writeFile as writeFile24 } from "node:fs/promises";
-import { resolve as resolve41 } from "node:path";
+import { writeFile as writeFile26 } from "node:fs/promises";
+import { resolve as resolve44 } from "node:path";
 async function buildCostQualityMatrix(projectRoot, outcomes) {
   const agg = aggregateOutcomes(outcomes);
   const rows = Object.entries(agg.byModel).map(([model, entry]) => {
@@ -28467,7 +29257,7 @@ async function buildCostQualityMatrix(projectRoot, outcomes) {
     rows
   };
   const dir = await ensureEvaluationDir(projectRoot);
-  await writeFile24(resolve41(dir, "matrix.yml"), $stringify(matrix), "utf-8");
+  await writeFile26(resolve44(dir, "matrix.yml"), $stringify(matrix), "utf-8");
   return matrix;
 }
 function formatMatrixMarkdown(matrix) {
@@ -28491,8 +29281,8 @@ var init_cost_quality_matrix = __esm(() => {
 });
 
 // src/core/evaluation/ablation-report.ts
-import { mkdir as mkdir25, writeFile as writeFile25 } from "node:fs/promises";
-import { resolve as resolve42 } from "node:path";
+import { mkdir as mkdir27, writeFile as writeFile27 } from "node:fs/promises";
+import { resolve as resolve45 } from "node:path";
 function isPass(o) {
   return o.verdict === "PASS" || o.status === "pass";
 }
@@ -28660,10 +29450,10 @@ function formatAblationMarkdown(report) {
 `);
 }
 async function persistAblationReport(projectRoot, markdown) {
-  const dir = resolve42(projectRoot, EVAL_DIR2);
-  await mkdir25(dir, { recursive: true });
-  const path = resolve42(dir, "ablation-last.md");
-  await writeFile25(path, markdown, "utf-8");
+  const dir = resolve45(projectRoot, EVAL_DIR2);
+  await mkdir27(dir, { recursive: true });
+  const path = resolve45(dir, "ablation-last.md");
+  await writeFile27(path, markdown, "utf-8");
   return path;
 }
 var SCORE_THRESHOLD = 0.1, PASS_RATE_THRESHOLD = 0.05;
@@ -28677,8 +29467,8 @@ var exports_scorecard_command = {};
 __export(exports_scorecard_command, {
   scorecardCommand: () => scorecardCommand
 });
-import { readFile as readFile40 } from "node:fs/promises";
-import { resolve as resolve43 } from "node:path";
+import { readFile as readFile43 } from "node:fs/promises";
+import { resolve as resolve46 } from "node:path";
 function contractVersion() {
   return package_default.version;
 }
@@ -28739,7 +29529,7 @@ async function handleCreate(projectRoot, options) {
     if (backlog.success && options.taskId) {
       const item = backlog.data.items.find((i) => i.id === options.taskId);
       if (item) {
-        scopeFiles = item.scope.split(/[,;]/).map((s) => s.trim()).filter(Boolean);
+        scopeFiles = parseScopeFiles(item.scope);
       }
     }
     let hints = collectScorecardSignals(projectRoot, scopeFiles);
@@ -28823,7 +29613,7 @@ async function handleRecord(projectRoot, options) {
   const variantId = options.variantId ?? overlay?.variantId;
   const suiteTaskId = options.suiteTaskId;
   const disabled = overlay?.disabledComponents ?? (variantId ? parseVariantId(variantId) : undefined);
-  const fingerprint = experimentId || variantId ? harnessFingerprint(disabled ?? [], overlay?.contractVersion ?? contractVersion(), overlay?.ccepProfile ?? "feature") : undefined;
+  const fingerprint2 = experimentId || variantId ? harnessFingerprint(disabled ?? [], overlay?.contractVersion ?? contractVersion(), overlay?.ccepProfile ?? "feature") : undefined;
   const outcome = {
     id: generateEvalId("out"),
     taskId,
@@ -28838,10 +29628,17 @@ async function handleRecord(projectRoot, options) {
     costUsd: options.costUsd,
     tokensIn: options.tokens,
     durationMs: options.durationMs,
+    delivery: options.deliveryRoute ? {
+      route: options.deliveryRoute,
+      contextBytes: options.contextBytes,
+      handoffs: options.handoffs,
+      checks: options.checks,
+      tokenUsage: options.tokens !== undefined ? { status: "known", total: options.tokens } : { status: "unknown" }
+    } : undefined,
     experimentId,
     variantId,
     suiteTaskId,
-    harnessFingerprint: fingerprint,
+    harnessFingerprint: fingerprint2,
     disabledComponents: disabled && disabled.length > 0 ? [...disabled] : disabled ? [] : undefined,
     status: options.verdict === "PASS" ? "pass" : options.verdict === "REJECT" ? "reject" : undefined
   };
@@ -28959,13 +29756,13 @@ async function handleCompareModels(projectRoot, options) {
     outcomes = outcomes.filter((o) => options.modelsFilter.includes(o.model));
   }
   const markdown = generateModelComparisonMarkdown(outcomes, options.modelsFilter);
-  const templatePath = resolve43(projectRoot, ".codeconductor/evaluation/model-comparison-last.md");
+  const templatePath = resolve46(projectRoot, ".codeconductor/evaluation/model-comparison-last.md");
   try {
-    await readFile40(templatePath);
+    await readFile43(templatePath);
   } catch {}
-  const { writeFile: writeFile26, mkdir: mkdir26 } = await import("node:fs/promises");
-  await mkdir26(resolve43(projectRoot, ".codeconductor/evaluation"), { recursive: true });
-  await writeFile26(templatePath, markdown, "utf-8");
+  const { writeFile: writeFile28, mkdir: mkdir28 } = await import("node:fs/promises");
+  await mkdir28(resolve46(projectRoot, ".codeconductor/evaluation"), { recursive: true });
+  await writeFile28(templatePath, markdown, "utf-8");
   return {
     code: 0,
     data: {
@@ -30434,7 +31231,7 @@ var exports_seo_audit_command = {};
 __export(exports_seo_audit_command, {
   seoAuditCommand: () => seoAuditCommand
 });
-import { join as join27 } from "node:path";
+import { join as join28 } from "node:path";
 async function seoAuditCommand(options) {
   const { url, sitemap, format, failOn, delay: delay2, output, followRedirects, force } = options;
   if (!url && !sitemap) {
@@ -30447,7 +31244,7 @@ async function seoAuditCommand(options) {
       }
     };
   }
-  const defaultMarkdownPath = output === undefined && format === "markdown" ? join27("seo-reports", `audit-report-${new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19)}.md`) : undefined;
+  const defaultMarkdownPath = output === undefined && format === "markdown" ? join28("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 });
@@ -30808,6 +31605,7 @@ var COMMANDS = [
   { name: "setup", group: "getting-started", summary: "Configure and install CodeConductor.", usage: ["cc-codeconductor setup [--target <target>] [--locale en|es] [--yes] [--dry-run]"] },
   { 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: "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>"] },
@@ -30832,6 +31630,7 @@ var COMMANDS = [
   { name: "orchestrate", group: "workflow", summary: "Run goal execution orchestration.", usage: ["cc-codeconductor orchestrate <subcommand>"] },
   { name: "impact", group: "workflow", summary: "Analyze change impact.", usage: ["cc-codeconductor impact [--files <paths>]"] },
   { name: "verify", group: "workflow", summary: "Verify task completion with evidence.", usage: ["cc-codeconductor verify --task <id>"] },
+  { name: "rdd", group: "workflow", summary: "Capture and validate Receipt-Driven Development evidence.", usage: ["cc-codeconductor rdd capture --task <id> [--phase red|green|review]", "cc-codeconductor rdd verify --receipt <id>", "cc-codeconductor rdd status [--task <id>]", "cc-codeconductor rdd git-check", "cc-codeconductor rdd install-hooks"] },
   { name: "seo", group: "tool", summary: "Audit SEO and generate llms.txt.", usage: ["cc-codeconductor seo audit --url <url>"] },
   { name: "debt-harvest", aliases: ["harvest"], group: "tool", summary: "Scan source files for deferred debt.", usage: ["cc-codeconductor debt-harvest"] }
 ];
@@ -30920,6 +31719,96 @@ _arguments '1:command:(${names})' '--target[target]:target:(${targets})'`;
   return null;
 }
 
+// src/cli/usage-guide.ts
+init_cli_bin();
+var RECOMMENDED_FLOW = [
+  "cc-codeconductor setup --target claude",
+  "cc-codeconductor setup --target claude --locale es --yes",
+  "cc-codeconductor setup --target claude --dry-run"
+];
+var PRIMITIVES = [
+  "cc-codeconductor detect",
+  "cc-codeconductor init --locale es",
+  "cc-codeconductor install preset --target claude",
+  "cc-codeconductor install council --target claude",
+  "cc-codeconductor install lsp --target claude"
+];
+var PRESET_EXAMPLES = [
+  "cc-codeconductor install preset --target claude",
+  "cc-codeconductor install preset --target claude --global",
+  "cc-codeconductor install preset --target claude --force",
+  "cc-codeconductor install preset --target claude --dry-run",
+  "cc-codeconductor install preset --target all",
+  "cc-codeconductor install preset --target claude --locale es",
+  "cc-codeconductor install preset --target claude --global --force"
+];
+var COUNCIL_EXAMPLES = [
+  "cc-codeconductor install council --target claude",
+  "cc-codeconductor install council --target claude --global",
+  "cc-codeconductor install council --target claude --force",
+  "cc-codeconductor install council --target claude --dry-run",
+  "cc-codeconductor install council --target all",
+  "cc-codeconductor install council --target claude --global --force"
+];
+var LSP_EXAMPLES = [
+  "cc-codeconductor install lsp --target claude --lang typescript,python",
+  "cc-codeconductor install lsp --target all --lang typescript,python",
+  "cc-codeconductor install lsp --target claude --global",
+  "cc-codeconductor install lsp --target claude --dry-run"
+];
+var AFTER_INSTALL_EXAMPLES = [
+  ["cc-codeconductor doctor", "validates the installation"],
+  ["cc-codeconductor status", "shows what is installed"],
+  ["cc-codeconductor update --dry-run", "previews reconciliation of managed files after upgrading"],
+  ["cc-codeconductor update --force", "applies reconciliation of managed files after upgrading"],
+  ["cc-codeconductor migrate --dry-run", "previews repair of orphaned artifacts a reinstall cannot fix"]
+];
+function renderExamples(lines, bin) {
+  return lines.map((line) => `  ${formatUsage(line, bin)}`);
+}
+function renderAnnotatedExamples(entries, bin) {
+  return entries.map(([line, description]) => `  ${formatUsage(line, bin)} — ${description}`);
+}
+function renderUsageGuide(bin = resolveCliBin()) {
+  return [
+    "CodeConductor — installation usage guide",
+    "",
+    "Recommended flow (one command, installs and configures everything):",
+    ...renderExamples(RECOMMENDED_FLOW, bin),
+    "",
+    "Fine-grained primitives (for scripting or partial installs):",
+    ...renderExamples(PRIMITIVES, bin),
+    "",
+    "Shared flags:",
+    "  --target    opencode|claude|codex|gemini|cursor|agy|pi|all (default: opencode)",
+    "  --global    Install to the home directory (~/.claude, ~/.opencode, etc.) instead of the project",
+    "  --force     Allow overwriting existing files",
+    "  --dry-run   Show what would happen without writing files",
+    "  --locale    Instruction language for agent files: en (default) | es — install preset only",
+    "  --lang      Comma-separated languages to install LSP servers for — install lsp only",
+    "  --output    Output mode: human (default) | json",
+    "",
+    "install preset — agents, prompts, skills, and commands:",
+    ...renderExamples(PRESET_EXAMPLES, bin),
+    "",
+    "install council — generated council spec files:",
+    ...renderExamples(COUNCIL_EXAMPLES, bin),
+    "",
+    "install lsp — language servers:",
+    ...renderExamples(LSP_EXAMPLES, bin),
+    "  Dedicated integration config is generated for: opencode, claude, codex, gemini, cursor, agy.",
+    "  pi installs the language servers but does not get a dedicated integration config file.",
+    "",
+    "After installing, verify and keep in sync:",
+    ...renderAnnotatedExamples(AFTER_INSTALL_EXAMPLES, bin),
+    "",
+    "More detail (GitHub only, not bundled in the npm package):",
+    "  docs/usage-cli.md         Detailed CLI reference, incl. per-target generated files",
+    "  docs/getting-started/     Installation, first project, and update walkthroughs"
+  ].join(`
+`);
+}
+
 // src/cli/router.ts
 var OutputModeSchema = exports_external.enum(["json", "human"]);
 var SeoFormatSchema = exports_external.enum(["cli", "json", "markdown"]);
@@ -31200,6 +32089,8 @@ async function routeCommand(args, projectRoot) {
     case "docs":
     case "man":
       return { code: 0, data: { success: true, command, output: renderDocs(subcommand) } };
+    case "usage":
+      return { code: 0, data: { success: true, command: "usage", output: renderUsageGuide() } };
     case "completion": {
       const output = renderCompletion(subcommand ?? "");
       return output ? { code: 0, data: { success: true, command: "completion", output } } : cliContractError("completion", ["Expected shell: bash, zsh, fish, or powershell."]);
@@ -31310,6 +32201,24 @@ async function routeCommand(args, projectRoot) {
         allowCompileCheck: options["allow-compile-check"] === true || options["allow-compile-check"] === "true"
       });
     }
+    case "rdd": {
+      const validSubs = ["capture", "verify", "status", "git-check", "install-hooks"];
+      if (!subcommand || !validSubs.includes(subcommand)) {
+        return unknownSubcommand("rdd", subcommand ?? "", [...validSubs]);
+      }
+      const { rddCommand: rddCommand2 } = await Promise.resolve().then(() => (init_rdd_command(), exports_rdd_command));
+      const paths = typeof options.paths === "string" ? options.paths.split(",").map((path) => path.trim()).filter(Boolean) : undefined;
+      return rddCommand2({
+        subcommand,
+        projectRoot,
+        taskId: options.task ?? args.rest?.[0],
+        receiptId: options.receipt,
+        phase: options.phase,
+        paths,
+        outcome: options.outcome,
+        command: options.command
+      });
+    }
     case "ccep": {
       const validSubs = ["parse", "profile", "resolve", "compile", "validate", "evaluate", "consensus", "taskcard"];
       if (subcommand && !validSubs.includes(subcommand)) {
@@ -31348,6 +32257,7 @@ async function routeCommand(args, projectRoot) {
         "start",
         "done",
         "block",
+        "unblock",
         "archive"
       ];
       let openspecSub = "validate";
@@ -31370,6 +32280,19 @@ async function routeCommand(args, projectRoot) {
         output: flags.output
       });
     }
+    case "odd": {
+      const validSubs = ["create", "read", "reconcile"];
+      if (!subcommand || !validSubs.includes(subcommand)) {
+        return unknownSubcommand(command, subcommand ?? "", validSubs);
+      }
+      const { oddCommand: oddCommand2 } = await Promise.resolve().then(() => (init_odd_command(), exports_odd_command));
+      return oddCommand2({
+        subcommand,
+        projectRoot,
+        input: options.input,
+        id: options.id ?? args.rest?.[0]
+      });
+    }
     case "hook": {
       const validHookEvents = ["pre-tool", "post-tool", "session-start"];
       if (subcommand && !validHookEvents.includes(subcommand)) {
@@ -31433,6 +32356,10 @@ async function routeCommand(args, projectRoot) {
         costUsd: options.cost ? parseFloat(String(options.cost)) : undefined,
         tokens: options.tokens ? parseInt(String(options.tokens), 10) : undefined,
         durationMs: options.duration ? parseInt(String(options.duration), 10) : undefined,
+        deliveryRoute: options.route,
+        contextBytes: options["context-bytes"] ? parseInt(String(options["context-bytes"]), 10) : undefined,
+        handoffs: options.handoffs ? parseInt(String(options.handoffs), 10) : undefined,
+        checks: typeof options.checks === "string" ? options.checks.split(",").map((check) => check.trim()).filter(Boolean) : undefined,
         verdict: options.verdict,
         weightedScore: options.score ? parseFloat(String(options.score)) : undefined,
         source: options.source,