cc-codeconductor 1.4.1 → 1.4.2

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.4.2",
     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",
@@ -15419,6 +15469,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,
@@ -21487,7 +21556,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 +21591,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 +21601,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 +22255,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 relative7, resolve as resolve26, sep as sep5 } 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}${sep5}`)) {
+    throw new Error(`RDD receipt path "${input}" is outside the project root`);
+  }
+  const normalized = relative7(root, absolute);
+  if (!normalized || normalized === ".") {
+    throw new Error("RDD receipts require file paths, not the project root");
+  }
+  return { absolute, relative: normalized.split(sep5).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(relative7(root, join18(current, entry.name)).split(sep5).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 +22405,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 +22441,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 +22449,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 +22470,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 +22551,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 +22564,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 +22579,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 +22602,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 +22629,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 +22697,7 @@ var init_verification_runner = __esm(() => {
   init_compile_checker();
   init_paths();
   init_episodic_store();
+  init_rdd_receipt();
 });
 
 // src/core/orchestrator/runtime-orchestrator.ts
@@ -23536,6 +23820,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 execFile3 } 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 promisify3 } 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 execFileAsync3("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 execFileAsync3;
+var init_rdd_command = __esm(() => {
+  init_schemas();
+  init_paths();
+  init_rdd_receipt();
+  execFileAsync3 = promisify3(execFile3);
+});
+
 // src/core/ccep/confirmation-gate.ts
 function matchesRiskThreshold(severity, threshold) {
   const order = { low: 0, medium: 1, high: 2 };
@@ -23841,11 +24282,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 { 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) {
@@ -23874,8 +24315,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 +24360,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 +24388,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 +24441,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 +24466,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 +24511,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 +24568,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 +24602,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 +24713,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 +24736,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 +24759,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 +24784,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 +24866,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 +24894,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 +25146,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 +25713,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
         }
       };
@@ -25508,8 +25970,8 @@ 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 { 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,8 +25981,8 @@ 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 {
@@ -25757,8 +26219,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 basename6, resolve as resolve32 } from "node:path";
 function pad3(n) {
   return String(n).padStart(3, "0");
 }
@@ -25823,7 +26285,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 +26299,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 +26345,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 +26366,25 @@ capabilities:
   return `openspec/changes/${slug}`;
 }
 async function archiveChangeFolder(projectRoot, changePath) {
-  const src = resolve30(projectRoot, changePath);
+  const src = resolve32(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 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 +26392,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 relative8, resolve as resolve33 } from "node:path";
 function uniqueIds(matches) {
   return [...new Set(matches ?? [])];
 }
@@ -26048,12 +26510,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 +26525,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 +26544,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, relative8(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 = relative8(root, file).replace(/\\/g, "/");
     if (PLACEHOLDER.test(content)) {
       reports.push({
         valid: false,
@@ -26141,15 +26603,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 +26638,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 +26726,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 +26755,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 relative9, 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 +26842,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 +26854,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: [`${relative9(root, file)}: no delta requirements found`]
       };
     }
-    const relativeSpec = relative8(changeSpecs, file);
-    const target = join24(root, "openspec", "specs", relativeSpec);
+    const relativeSpec = relative9(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, relative9(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) => relative9(root, write.path).replace(/\\/g, "/")),
     errors: []
   };
 }
@@ -26435,8 +26897,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 +26920,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 +26944,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 +26954,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 +27152,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 +27348,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 +27427,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 +27554,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,6 +27572,184 @@ 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 sep6 } 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}${sep6}`)) {
+      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();
@@ -27206,8 +27901,8 @@ __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 } from "node:fs";
+import { resolve as resolve38 } from "node:path";
 function detectFormat(explicit, stdinText) {
   if (explicit)
     return explicit;
@@ -27234,13 +27929,13 @@ function resolvePreToolInput(options, stdinText) {
   };
 }
 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"
   ];
@@ -27284,7 +27979,7 @@ async function hookCommand(options) {
   };
 }
 function formatWrittenFile(filePath) {
-  if (!filePath || !existsSync7(filePath))
+  if (!filePath || !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;
@@ -27702,6 +28397,12 @@ function ccGainToScorecardImpact(result) {
 
 // src/core/evaluation/scorecard-signals.ts
 import { execFileSync as execFileSync3 } 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 = {};
@@ -27748,7 +28449,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 +28520,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 dirname13, 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 +28548,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 +28558,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 +28637,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(dirname13(suitePath), fixtureDir) : join26(dirname13(suitePath), "fixture");
+  await mkdir25(dest, { recursive: true });
+  if (existsSync9(source)) {
     await cp(source, dest, { recursive: true });
   }
 }
@@ -27959,12 +28660,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 +28677,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 +28711,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 +28772,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 +28823,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 +28907,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 +28957,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 +28998,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 = "";
     }
@@ -28342,12 +29043,12 @@ 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 { mkdir as mkdir26, readFile as readFile42, writeFile as writeFile25 } from "node:fs/promises";
+import { dirname as dirname14, 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 {
@@ -28402,9 +29103,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(dirname14(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 +29147,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 +29168,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 +29192,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 +29361,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 +29378,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 +29440,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 +29524,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 +29539,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 +29667,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 +31142,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 +31155,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 });
@@ -30832,6 +31540,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"] }
 ];
@@ -31310,6 +32019,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 +32075,7 @@ async function routeCommand(args, projectRoot) {
         "start",
         "done",
         "block",
+        "unblock",
         "archive"
       ];
       let openspecSub = "validate";
@@ -31370,6 +32098,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 +32174,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,