cc-codeconductor 1.4.0 → 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.0",
+    version: "1.4.2",
     description: "A multi-agent orchestration framework for AI-assisted software engineering workflows.",
     keywords: [
       "ai",
@@ -4145,6 +4145,38 @@ var init_runner_target = __esm(() => {
   INDIVIDUAL_TARGETS = ["opencode", "claude", "codex", "gemini", "cursor", "agy", "pi"];
 });
 
+// src/utils/cli-bin.ts
+import { basename } from "node:path";
+function resolveCliBin(env = process.env, argv = process.argv) {
+  if (env.CC_CLI_BIN) {
+    return env.CC_CLI_BIN;
+  }
+  if (env.npm_lifecycle_event === "npx" || env.npm_command === "exec" || env._?.endsWith("/npx") || env._ === "npx") {
+    return "npx cc-codeconductor";
+  }
+  if (env._?.endsWith("/bunx") || env._ === "bunx") {
+    return "bunx cc-codeconductor";
+  }
+  if (env.npm_lifecycle_event === "dev") {
+    return env.npm_lifecycle_script?.startsWith("bun") ? "bun run dev" : "npm run dev";
+  }
+  if (argv && argv.length > 1 && argv[1]) {
+    const script = argv[1];
+    const binName = basename(script);
+    if (binName === "main.ts") {
+      return "bun run dev";
+    }
+    if (binName === "cc-codeconductor" || binName === "codeconductor") {
+      return binName;
+    }
+  }
+  return "cc-codeconductor";
+}
+function formatUsage(usage, bin = resolveCliBin()) {
+  return usage.replace(/^(?:cc-codeconductor|codeconductor|cc)\b/, bin);
+}
+var init_cli_bin = () => {};
+
 // node_modules/yaml/dist/nodes/identity.js
 var require_identity = __commonJS(function(exports) {
   var ALIAS = Symbol.for("yaml.alias");
@@ -11174,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,
@@ -11238,6 +11275,7 @@ __export(exports_schemas, {
   TaskOutcomeSourceSchema: () => TaskOutcomeSourceSchema,
   TaskOutcomeStatusSchema: () => TaskOutcomeStatusSchema,
   TechnicalPlanOutputSchema: () => TechnicalPlanOutputSchema,
+  TokenUsageSchema: () => TokenUsageSchema,
   ToolProviderNamesSchema: () => ToolProviderNamesSchema,
   VerificationReportSchema: () => VerificationReportSchema,
   WorkflowCommandSchema: () => WorkflowCommandSchema,
@@ -11401,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();
@@ -11566,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"]),
@@ -11574,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"]
@@ -11951,7 +11991,8 @@ var init_schemas = __esm(() => {
     "prototype",
     "handoff",
     "clarify",
-    "security"
+    "security",
+    "odd"
   ]);
   CcepOutputFormatSchema = exports_external.enum(["taskcard", "plan", "verdict"]);
   CommandEnvelopeSchema = exports_external.object({
@@ -12167,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(),
@@ -12190,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",
@@ -12670,7 +12752,7 @@ var init_safety = __esm(() => {
 // src/core/filesystem/path-containment.ts
 import { constants as constants2 } from "node:fs";
 import { lstat, mkdir, open, realpath } from "node:fs/promises";
-import { basename, dirname as dirname2, isAbsolute, join as join2, relative, resolve as resolve3, sep as sep2 } from "node:path";
+import { basename as basename2, dirname as dirname2, isAbsolute, join as join2, relative, resolve as resolve3, sep as sep2 } from "node:path";
 function isInside(root, target) {
   const rel = relative(root, target);
   return rel !== "" && rel !== ".." && !rel.startsWith(`..${sep2}`) && !isAbsolute(rel);
@@ -12745,7 +12827,7 @@ async function canonicalizeExistingPrefix(target) {
       if (parent === current) {
         throw error;
       }
-      pending.unshift(basename(current));
+      pending.unshift(basename2(current));
       current = parent;
     }
   }
@@ -13031,8 +13113,8 @@ function mergeDeep(target, source) {
 }
 function extractAgentRole(filePath) {
   const parts = filePath.replace(/\\/g, "/").split("/");
-  const basename2 = parts[parts.length - 1];
-  const name = basename2.replace(/\.md$/, "");
+  const basename3 = parts[parts.length - 1];
+  const name = basename3.replace(/\.md$/, "");
   const knownRoles = [
     "architect",
     "implementer",
@@ -14282,7 +14364,7 @@ var init_agy_installer = __esm(() => {
 
 // src/core/presets/update-checker.ts
 import { stat as stat2, readFile as readFile7 } from "node:fs/promises";
-import { resolve as resolve7, join as join5, basename as basename2, dirname as dirname4 } from "node:path";
+import { resolve as resolve7, join as join5, basename as basename3, dirname as dirname4 } from "node:path";
 import { homedir as homedir3 } from "node:os";
 function getTargetInstallationPath(target, basePath, isGlobal) {
   if (target === "agy") {
@@ -14399,7 +14481,7 @@ async function validateSkillFrontmatterFiles(basePath, isGlobal) {
       }
       const files = await resolveEntryFiles(resolvedEntry, PRESETS_DIR, targetBaseDir);
       for (const { dest } of files) {
-        if (basename2(dest) !== "SKILL.md")
+        if (basename3(dest) !== "SKILL.md")
           continue;
         let content;
         try {
@@ -14412,7 +14494,7 @@ async function validateSkillFrontmatterFiles(basePath, isGlobal) {
           results.push({ path: dest, error: `${parsed.error.kind}: ${parsed.error.message}` });
           continue;
         }
-        const dir = basename2(dirname4(dest));
+        const dir = basename3(dirname4(dest));
         const ident = skillIdentifier(parsed.frontmatter);
         if (ident !== dir) {
           results.push({
@@ -15387,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,
@@ -16149,7 +16250,7 @@ __export(exports_init_command, {
 });
 import { access as access4, mkdir as mkdir5, readFile as readFile10, writeFile as writeFile4 } from "node:fs/promises";
 import { homedir as homedir6 } from "node:os";
-import { basename as basename3, resolve as resolve11 } from "node:path";
+import { basename as basename4, resolve as resolve11 } from "node:path";
 async function initCommand(options) {
   const { projectRoot, dryRun, force, global: isGlobal, output, locale } = options;
   const baseDir = isGlobal ? homedir6() : projectRoot;
@@ -16170,7 +16271,7 @@ async function initCommand(options) {
     }
     const config = profile ? {
       project: {
-        name: basename3(projectRoot) || "unnamed-project",
+        name: basename4(projectRoot) || "unnamed-project",
         profile: profile.runtimes[0] || "unknown"
       },
       defaults: {
@@ -16887,7 +16988,7 @@ __export(exports_install_command, {
 });
 import { readFile as readFile11 } from "node:fs/promises";
 import { homedir as homedir7 } from "node:os";
-import { basename as basename4, dirname as dirname6, resolve as resolve12, sep as sep3 } from "node:path";
+import { basename as basename5, dirname as dirname6, resolve as resolve12, sep as sep3 } from "node:path";
 async function installCommand(options) {
   const { target, dryRun, force, global: isGlobal, output, projectRoot } = options;
   const baseDir = isGlobal ? homedir7() : projectRoot;
@@ -17026,12 +17127,12 @@ async function verifyRenderedFiles(manifest, baseDir, results) {
     if (leaked.length > 0) {
       warnings.push(`${r.dest}: unresolved placeholder(s) ${leaked.join(", ")}`);
     }
-    if (basename4(r.dest) === "SKILL.md") {
+    if (basename5(r.dest) === "SKILL.md") {
       const parsed = parseSkillFrontmatter(content);
       if (!parsed.ok) {
         warnings.push(`${r.dest}: ${parsed.error.kind} — ${parsed.error.message}`);
       } else {
-        const dir = basename4(dirname6(r.dest));
+        const dir = basename5(dirname6(r.dest));
         const ident = skillIdentifier(parsed.frontmatter);
         if (ident !== dir) {
           warnings.push(`${r.dest}: identifier "${ident}" does not match its directory "${dir}"`);
@@ -17274,6 +17375,7 @@ __export(exports_status_command, {
 });
 import { resolve as resolve13 } from "node:path";
 async function statusCommand(options) {
+  const bin = resolveCliBin();
   const [configResult, state] = await Promise.all([
     loadConfig(options.projectRoot),
     readInstallationState(options.projectRoot)
@@ -17316,7 +17418,7 @@ async function statusCommand(options) {
     ...modifiedFiles.length ? [`  locally modified managed files: ${modifiedFiles.length}`] : [],
     ...data.updates?.conflicts.length ? [`  conflicts: ${data.updates.conflicts.join(", ")}`] : [],
     "",
-    "Run `cc doctor` for diagnostics."
+    `Run \`${bin} doctor\` for diagnostics.`
   ].join(`
 `);
   return { code: 0, data: { ...data, output } };
@@ -17326,6 +17428,7 @@ var init_status_command = __esm(() => {
   init_installation_state();
   init_update_checker();
   init_runner_target();
+  init_cli_bin();
 });
 
 // src/commands/detect.command.ts
@@ -20118,7 +20221,7 @@ async function loadGraph(projectRoot) {
     return ok(ProductGraphSchema.parse(JSON.parse(raw)));
   } catch (e) {
     if (e.code === "ENOENT") {
-      return err(new Error("Product graph not found. Run `cc ingest` first."));
+      return err(new Error(`Product graph not found. Run \`${resolveCliBin()} ingest\` first.`));
     }
     return err(e instanceof Error ? e : new Error(String(e)));
   }
@@ -20212,6 +20315,7 @@ function getNeighbors(graph, nodeId, relation) {
 }
 var init_graph_store = __esm(() => {
   init_schemas();
+  init_cli_bin();
   init_paths();
 });
 
@@ -20740,9 +20844,9 @@ import { join as join15 } from "node:path";
 async function parseAdrFile(filePath) {
   try {
     const content = await readFile19(filePath, "utf-8");
-    const basename5 = filePath.split("/").pop() ?? "";
-    const idMatch = basename5.match(/adr-(\d+)/i);
-    const id = idMatch ? `adr-${idMatch[1]}` : slugify(basename5);
+    const basename6 = filePath.split("/").pop() ?? "";
+    const idMatch = basename6.match(/adr-(\d+)/i);
+    const id = idMatch ? `adr-${idMatch[1]}` : slugify(basename6);
     const titleMatch = content.match(/^#\s+ADR-\d+:\s*(.+)$/m);
     const statusMatch = content.match(/\*\*Status:\*\*\s*(\w+)/i);
     const contextSection = extractSection(content, "Context");
@@ -20752,7 +20856,7 @@ async function parseAdrFile(filePath) {
 `).filter((l) => l.trim().startsWith("-") || l.trim().startsWith("*")).map((l) => l.replace(/^[\s*-]+/, "").trim()).filter(Boolean);
     return {
       id,
-      title: titleMatch?.[1]?.trim() ?? basename5,
+      title: titleMatch?.[1]?.trim() ?? basename6,
       status: statusMatch?.[1]?.toLowerCase() ?? "unknown",
       context: contextSection.trim(),
       decision: decisionSection.trim(),
@@ -21452,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 {
@@ -21484,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;
@@ -21494,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])
@@ -22147,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":
@@ -22168,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);
@@ -22196,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)));
   }
@@ -22204,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);
@@ -22225,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")
@@ -22306,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",
@@ -22314,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",
@@ -22322,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)
@@ -22345,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:
@@ -22366,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(() => {
@@ -22379,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
@@ -23230,7 +23549,7 @@ async function handleRun(projectRoot, output, taskId, complete, allowCompileChec
       data: {
         success: false,
         command: "orchestrate",
-        errors: ["Verification failed. Run `cc verify --task " + taskId + "`"]
+        errors: ["Verification failed. Run `" + resolveCliBin() + " verify --task " + taskId + "`"]
       }
     };
   }
@@ -23294,6 +23613,7 @@ var init_orchestrate_command = __esm(() => {
   init_product_planner();
   init_graph_store();
   init_loop_engine();
+  init_cli_bin();
 });
 
 // src/core/impact/impact-engine.ts
@@ -23500,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 };
@@ -23805,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) {
@@ -23838,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 };
@@ -23883,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" }
   };
 });
 
@@ -23910,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);
 }
@@ -23963,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;
@@ -23988,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");
@@ -24033,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 = {}) {
@@ -24090,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) {
@@ -24124,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)));
@@ -24235,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;
 }
@@ -24258,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) {
@@ -24281,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)));
@@ -24306,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({
@@ -24388,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,
@@ -24416,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 {
@@ -24668,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 {
@@ -25229,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
         }
       };
@@ -25472,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) {
@@ -25483,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 {
@@ -25721,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 basename5, 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");
 }
@@ -25787,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}
 `;
@@ -25801,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 ?? [];
@@ -25847,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:
@@ -25868,25 +26366,25 @@ capabilities:
   return `openspec/changes/${slug}`;
 }
 async function archiveChangeFolder(projectRoot, changePath) {
-  const src = resolve30(projectRoot, changePath);
-  const slug = basename5(changePath);
-  const destDir = resolve30(projectRoot, "openspec", "changes", "archive");
-  await mkdir21(destDir, { recursive: true });
-  const dest = resolve30(destDir, slug);
-  await rename4(src, dest);
+  const src = resolve32(projectRoot, changePath);
+  const slug = basename6(changePath);
+  const destDir = resolve32(projectRoot, "openspec", "changes", "archive");
+  await mkdir22(destDir, { recursive: true });
+  const dest = resolve32(destDir, slug);
+  await rename5(src, dest);
   return `openspec/changes/archive/${slug}`;
 }
 async function ensureOpenspecConfig(projectRoot) {
-  const configPath = resolve30(projectRoot, "openspec", "config.yaml");
+  const configPath = resolve32(projectRoot, "openspec", "config.yaml");
   try {
     const { access: access7 } = await import("node:fs/promises");
     await access7(configPath);
   } catch {
-    await mkdir21(resolve30(projectRoot, "openspec"), { recursive: true });
+    await mkdir22(resolve32(projectRoot, "openspec"), { recursive: true });
     const stub = `# OpenSpec project config (CodeConductor native compatible)
 schema: spec-driven
 `;
-    await writeFile21(configPath, stub, "utf-8");
+    await writeFile22(configPath, stub, "utf-8");
   }
 }
 var init_openspec_generator = __esm(() => {
@@ -25894,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 ?? [])];
 }
@@ -26012,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")) {
@@ -26027,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,
@@ -26046,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,
@@ -26105,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)];
 }
@@ -26140,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(`
@@ -26228,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;
   }
@@ -26257,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"))
@@ -26344,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"] };
   }
@@ -26356,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: []
   };
 }
@@ -26399,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) {
@@ -26422,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:
@@ -26444,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);
@@ -26454,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);
@@ -26652,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;
       }
     }
@@ -26847,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.`
       ]);
     }
   }
@@ -26925,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) {
@@ -27001,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();
@@ -27019,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();
@@ -27170,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;
@@ -27198,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"
   ];
@@ -27248,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;
@@ -27666,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 = {};
@@ -27712,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,
@@ -27783,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)));
@@ -27811,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") {
@@ -27821,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);
@@ -27900,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 });
   }
 }
@@ -27923,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);
@@ -27940,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);
@@ -27974,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) {
@@ -28035,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,
@@ -28086,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 {
@@ -28170,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 [];
@@ -28220,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);
@@ -28261,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 = "";
     }
@@ -28306,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 {
@@ -28366,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)));
@@ -28410,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]) => {
@@ -28431,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) {
@@ -28455,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";
 }
@@ -28624,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;
@@ -28641,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;
 }
@@ -28703,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);
@@ -28787,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,
@@ -28802,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
   };
@@ -28923,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: {
@@ -30398,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) {
@@ -30411,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 });
@@ -30680,6 +31424,7 @@ __export(exports_onboarding_command, {
   onboardingCommand: () => onboardingCommand
 });
 async function onboardingCommand(projectRoot) {
+  const bin = resolveCliBin();
   const [config, profile, state] = await Promise.all([
     loadConfig(projectRoot),
     detectProject(projectRoot),
@@ -30703,18 +31448,18 @@ async function onboardingCommand(projectRoot) {
           "",
           "Get started:",
           "  1. Inspect what will be installed",
-          "     cc setup --dry-run",
+          `     ${bin} setup --dry-run`,
           "  2. Configure the harness",
-          "     cc setup",
+          `     ${bin} setup`,
           "  3. Verify the installation",
-          "     cc doctor",
+          `     ${bin} doctor`,
           "",
           `Detected project: ${[...profile.runtimes, ...profile.frameworks].join(", ") || "unknown"}`,
           `Recommended preset: ${recommendation.stack}`,
           "",
           "Documentation:",
-          "  cc help setup",
-          "  cc docs getting-started"
+          `  ${bin} help setup`,
+          `  ${bin} docs getting-started`
         ].join(`
 `)
       }
@@ -30737,12 +31482,12 @@ async function onboardingCommand(projectRoot) {
         `  locale          ${config.data.defaults.locale}`,
         "",
         "Run:",
-        "  cc status",
-        "  cc doctor",
-        "  cc update --check",
+        `  ${bin} status`,
+        `  ${bin} doctor`,
+        `  ${bin} update --check`,
         "",
         "Other commands:",
-        "  cc help"
+        `  ${bin} help`
       ].join(`
 `)
     }
@@ -30753,6 +31498,7 @@ var init_onboarding_command = __esm(() => {
   init_config_loader();
   init_project_detector();
   init_installation_state();
+  init_cli_bin();
 });
 
 // src/cli/execute.ts
@@ -30765,36 +31511,38 @@ init_runner_target();
 
 // src/cli/command-registry.ts
 init_package();
+init_cli_bin();
 var COMMANDS = [
-  { name: "setup", group: "getting-started", summary: "Configure and install CodeConductor.", usage: ["cc setup [--target <target>] [--locale en|es] [--yes] [--dry-run]"] },
-  { name: "detect", group: "getting-started", summary: "Inspect the project stack and recommended presets.", usage: ["cc detect"] },
-  { name: "init", group: "getting-started", summary: "Initialize low-level CodeConductor configuration.", usage: ["cc init [--locale en|es]"] },
-  { name: "install", group: "getting-started", summary: "Install harness components.", usage: ["cc install preset --target <target>"], options: ["--target opencode|claude|codex|gemini|cursor|agy|pi|all"], subcommands: [
-    { name: "preset", group: "getting-started", summary: "Install agents, prompts, skills, and commands.", usage: ["cc install preset --target <target> [--locale en|es]"] },
-    { name: "council", group: "getting-started", summary: "Install generated council files.", usage: ["cc install council --target <target>"] },
-    { name: "lsp", group: "getting-started", summary: "Install supported language servers.", usage: ["cc install lsp --target <target> [--lang typescript,python]"] }
+  { name: "setup", group: "getting-started", summary: "Configure and install CodeConductor.", usage: ["cc-codeconductor setup [--target <target>] [--locale en|es] [--yes] [--dry-run]"] },
+  { name: "detect", group: "getting-started", summary: "Inspect the project stack and recommended presets.", usage: ["cc-codeconductor detect"] },
+  { name: "init", group: "getting-started", summary: "Initialize low-level CodeConductor configuration.", usage: ["cc-codeconductor init [--locale en|es]"] },
+  { name: "install", group: "getting-started", summary: "Install harness components.", usage: ["cc-codeconductor install preset --target <target>"], options: ["--target opencode|claude|codex|gemini|cursor|agy|pi|all"], subcommands: [
+    { name: "preset", group: "getting-started", summary: "Install agents, prompts, skills, and commands.", usage: ["cc-codeconductor install preset --target <target> [--locale en|es]"] },
+    { name: "council", group: "getting-started", summary: "Install generated council files.", usage: ["cc-codeconductor install council --target <target>"] },
+    { name: "lsp", group: "getting-started", summary: "Install supported language servers.", usage: ["cc-codeconductor install lsp --target <target> [--lang typescript,python]"] }
   ] },
-  { name: "version", group: "maintenance", summary: "Show CLI and project harness versions.", usage: ["cc version [--json]"] },
-  { name: "status", group: "maintenance", summary: "Show installed harness state.", usage: ["cc status [--json]"] },
-  { name: "doctor", group: "maintenance", summary: "Diagnose the installation.", usage: ["cc doctor"] },
-  { name: "update", group: "maintenance", summary: "Safely reconcile managed harness files.", usage: ["cc update [--dry-run] [--force]"] },
-  { name: "migrate", group: "maintenance", summary: "Apply compatibility migrations.", usage: ["cc migrate [--dry-run]"] },
-  { name: "docs", group: "maintenance", summary: "Read bundled command documentation.", usage: ["cc docs [command]"] },
-  { name: "completion", group: "maintenance", summary: "Generate shell completion.", usage: ["cc completion <bash|zsh|fish|powershell>"] },
-  { name: "hook", group: "maintenance", summary: "Run installed agent hooks.", usage: ["cc hook <pre-tool|post-tool|session-start>"] },
-  { name: "cc-help", group: "maintenance", summary: "Show a target preset inventory.", usage: ["cc cc-help --target <target>"] },
-  { name: "ask", group: "workflow", summary: "Recommend a slash-command workflow.", usage: ['cc ask "problem"'] },
-  { name: "goal", aliases: ["cc-goal"], group: "workflow", summary: "Plan a goal into dependent tasks.", usage: ['cc goal "objective"'] },
-  { name: "ingest", group: "workflow", summary: "Ingest repository knowledge into the product graph.", usage: ["cc ingest"] },
-  { name: "product", group: "workflow", summary: "Explore the product graph and memory.", usage: ["cc product <subcommand>"] },
-  { name: "ccep", group: "workflow", summary: "Run CCEP contract workflows.", usage: ["cc ccep <subcommand>"] },
-  { name: "openspec", group: "workflow", summary: "Run the OpenSpec delivery loop.", usage: ["cc openspec <subcommand>"] },
-  { name: "scorecard", group: "workflow", summary: "Record and aggregate outcomes.", usage: ["cc scorecard <subcommand>"] },
-  { name: "orchestrate", group: "workflow", summary: "Run goal execution orchestration.", usage: ["cc orchestrate <subcommand>"] },
-  { name: "impact", group: "workflow", summary: "Analyze change impact.", usage: ["cc impact [--files <paths>]"] },
-  { name: "verify", group: "workflow", summary: "Verify task completion with evidence.", usage: ["cc verify --task <id>"] },
-  { name: "seo", group: "tool", summary: "Audit SEO and generate llms.txt.", usage: ["cc seo audit --url <url>"] },
-  { name: "debt-harvest", aliases: ["harvest"], group: "tool", summary: "Scan source files for deferred debt.", usage: ["cc debt-harvest"] }
+  { name: "version", group: "maintenance", summary: "Show CLI and project harness versions.", usage: ["cc-codeconductor version [--json]"] },
+  { name: "status", group: "maintenance", summary: "Show installed harness state.", usage: ["cc-codeconductor status [--json]"] },
+  { name: "doctor", group: "maintenance", summary: "Diagnose the installation.", usage: ["cc-codeconductor doctor"] },
+  { name: "update", group: "maintenance", summary: "Safely reconcile managed harness files.", usage: ["cc-codeconductor update [--dry-run] [--force]"] },
+  { name: "migrate", group: "maintenance", summary: "Apply compatibility migrations.", usage: ["cc-codeconductor migrate [--dry-run]"] },
+  { name: "docs", group: "maintenance", summary: "Read bundled command documentation.", usage: ["cc-codeconductor docs [command]"] },
+  { name: "completion", group: "maintenance", summary: "Generate shell completion.", usage: ["cc-codeconductor completion <bash|zsh|fish|powershell>"] },
+  { name: "hook", group: "maintenance", summary: "Run installed agent hooks.", usage: ["cc-codeconductor hook <pre-tool|post-tool|session-start>"] },
+  { name: "cc-help", group: "maintenance", summary: "Show a target preset inventory.", usage: ["cc-codeconductor cc-help --target <target>"] },
+  { name: "ask", group: "workflow", summary: "Recommend a slash-command workflow.", usage: ['cc-codeconductor ask "problem"'] },
+  { name: "goal", aliases: ["cc-goal"], group: "workflow", summary: "Plan a goal into dependent tasks.", usage: ['cc-codeconductor goal "objective"'] },
+  { name: "ingest", group: "workflow", summary: "Ingest repository knowledge into the product graph.", usage: ["cc-codeconductor ingest"] },
+  { name: "product", group: "workflow", summary: "Explore the product graph and memory.", usage: ["cc-codeconductor product <subcommand>"] },
+  { name: "ccep", group: "workflow", summary: "Run CCEP contract workflows.", usage: ["cc-codeconductor ccep <subcommand>"] },
+  { name: "openspec", group: "workflow", summary: "Run the OpenSpec delivery loop.", usage: ["cc-codeconductor openspec <subcommand>"] },
+  { name: "scorecard", group: "workflow", summary: "Record and aggregate outcomes.", usage: ["cc-codeconductor scorecard <subcommand>"] },
+  { 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"] }
 ];
 var GROUP_LABELS = {
   "getting-started": "GETTING STARTED",
@@ -30806,7 +31554,7 @@ function findCommand(name, subcommand) {
   const command = COMMANDS.find((candidate) => candidate.name === name || candidate.aliases?.includes(name ?? ""));
   return subcommand ? command?.subcommands?.find((candidate) => candidate.name === subcommand) : command;
 }
-function renderHelp(command, subcommand, all = false) {
+function renderHelp(command, subcommand, all = false, bin = resolveCliBin()) {
   const definition = findCommand(command, subcommand);
   if (definition) {
     return [
@@ -30815,11 +31563,11 @@ function renderHelp(command, subcommand, all = false) {
       definition.summary,
       "",
       "Usage:",
-      ...definition.usage.map((usage) => `  ${usage}`),
+      ...definition.usage.map((usage) => `  ${formatUsage(usage, bin)}`),
       ...definition.options?.length ? ["", "Options:", ...definition.options.map((option) => `  ${option}`)] : [],
       ...definition.subcommands?.length ? ["", "Subcommands:", ...definition.subcommands.map((item) => `  ${item.name.padEnd(12)} ${item.summary}`)] : [],
       "",
-      "Run `cc help --all` for every command."
+      `Run \`${bin} help --all\` for every command.`
     ].join(`
 `);
   }
@@ -30830,14 +31578,14 @@ function renderHelp(command, subcommand, all = false) {
   ]);
   const details = all ? COMMANDS.flatMap((item) => [
     `## ${item.name}`,
-    ...item.usage.map((usage) => `  ${usage}`),
+    ...item.usage.map((usage) => `  ${formatUsage(usage, bin)}`),
     ...item.subcommands?.map((sub) => `  ${item.name} ${sub.name} — ${sub.summary}`) ?? [],
     ""
   ]) : [];
-  return [`CodeConductor CLI v${package_default.version}`, "", "Usage: cc <command> [options]", "", ...grouped, ...details, "Run `cc help <command>` for details."].join(`
+  return [`CodeConductor CLI v${package_default.version}`, "", `Usage: ${bin} <command> [options]`, "", ...grouped, ...details, `Run \`${bin} help <command>\` for details.`].join(`
 `);
 }
-function renderDocs(command) {
+function renderDocs(command, bin = "cc-codeconductor") {
   const groupAliases = {
     "getting-started": "getting-started",
     maintenance: "maintenance",
@@ -30853,7 +31601,7 @@ function renderDocs(command) {
     item.summary,
     "",
     "```text",
-    ...item.usage,
+    ...item.usage.map((usage) => formatUsage(usage, bin)),
     "```",
     ""
   ])].join(`
@@ -30864,15 +31612,20 @@ function renderCompletion(shell) {
   const targets = "opencode claude codex gemini cursor agy pi all";
   if (shell === "bash")
     return `_cc(){ local cur="${"${COMP_WORDS[COMP_CWORD]}"}"; local prev="${"${COMP_WORDS[COMP_CWORD-1]}"}"; if [[ "$prev" == "--target" ]]; then COMPREPLY=( $(compgen -W "${targets}" -- "$cur") ); else COMPREPLY=( $(compgen -W "${names}" -- "$cur") ); fi; }
-complete -F _cc cc codeconductor`;
+complete -F _cc cc-codeconductor codeconductor cc`;
   if (shell === "zsh")
-    return `#compdef cc codeconductor
+    return `#compdef cc-codeconductor codeconductor cc
 _arguments '1:command:(${names})' '--target[target]:target:(${targets})'`;
   if (shell === "fish")
-    return [...COMMANDS.map((item) => `complete -c cc -a ${item.name} -d '${item.summary}'`), `complete -c cc -l target -a '${targets}'`].join(`
+    return [
+      ...["cc-codeconductor", "codeconductor", "cc"].flatMap((bin) => [
+        ...COMMANDS.map((item) => `complete -c ${bin} -a ${item.name} -d '${item.summary}'`),
+        `complete -c ${bin} -l target -a '${targets}'`
+      ])
+    ].join(`
 `);
   if (shell === "powershell")
-    return `Register-ArgumentCompleter -CommandName cc,codeconductor -ScriptBlock { param($wordToComplete,$commandAst,$cursorPosition) $values = if ($commandAst.ToString() -match '--target\\s+$') { '${targets}' } else { '${names}' }; $values.Split(' ') | Where-Object { $_ -like "$wordToComplete*" } }`;
+    return `Register-ArgumentCompleter -CommandName cc-codeconductor,codeconductor,cc -ScriptBlock { param($wordToComplete,$commandAst,$cursorPosition) $values = if ($commandAst.ToString() -match '--target\\s+$') { '${targets}' } else { '${names}' }; $values.Split(' ') | Where-Object { $_ -like "$wordToComplete*" } }`;
   return null;
 }
 
@@ -31266,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)) {
@@ -31304,6 +32075,7 @@ async function routeCommand(args, projectRoot) {
         "start",
         "done",
         "block",
+        "unblock",
         "archive"
       ];
       let openspecSub = "validate";
@@ -31326,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)) {
@@ -31389,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,