cc-codeconductor 1.4.0 → 1.4.2

package/dist/library.js

@@ -149,7 +149,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_runner_target();
   CouncilAgentSpecSchema = z.object({
@@ -313,7 +313,8 @@ var init_schemas = __esm(() => {
     complianceVeto: z.boolean().optional(),
     confidence: z.number().min(0).max(1),
     findings: z.array(CouncilFindingSchema),
-    summary: z.string()
+    summary: z.string(),
+    candidateHash: z.string().min(1).optional()
   });
   ConsensusConfigSchema = z.object({
     algorithm: z.enum(["majority", "unanimous"]),
@@ -321,7 +322,8 @@ var init_schemas = __esm(() => {
     allowComplianceVeto: z.boolean().optional(),
     expectedAgentIds: z.array(z.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: z.number().int().positive().optional(),
-    criticalFindingsPolicy: z.enum(["escalate", "reject", "ignore"]).optional()
+    criticalFindingsPolicy: z.enum(["escalate", "reject", "ignore"]).optional(),
+    candidateHash: z.string().min(1).optional()
   }).refine((config) => config.algorithm !== "unanimous" || config.expectedAgentIds !== undefined, {
     message: "unanimous consensus requires a non-empty expectedAgentIds roster",
     path: ["expectedAgentIds"]
@@ -698,7 +700,8 @@ var init_schemas = __esm(() => {
     "prototype",
     "handoff",
     "clarify",
-    "security"
+    "security",
+    "odd"
   ]);
   CcepOutputFormatSchema = z.enum(["taskcard", "plan", "verdict"]);
   CommandEnvelopeSchema = z.object({
@@ -914,6 +917,46 @@ var init_schemas = __esm(() => {
     "revise",
     "reject"
   ]);
+  DeliveryRouteSchema = z.enum(["read-only", "small", "tracked", "openspec"]);
+  TokenUsageSchema = z.union([
+    z.object({
+      status: z.literal("known"),
+      total: z.number().nonnegative()
+    }),
+    z.object({ status: z.literal("unknown") })
+  ]);
+  DeliveryTelemetrySchema = z.object({
+    route: DeliveryRouteSchema,
+    contextBytes: z.number().int().nonnegative().optional(),
+    handoffs: z.number().int().nonnegative().optional(),
+    checks: z.array(z.string().min(1)).optional(),
+    tokenUsage: TokenUsageSchema
+  });
+  DeliveryLedgerTaskSchema = z.object({
+    id: z.string().min(1),
+    title: z.string().min(1),
+    status: z.enum(["pending", "done", "blocked"])
+  });
+  DeliveryLedgerSchema = z.object({
+    version: z.literal(1),
+    id: z.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/),
+    taskCard: CanonicalTaskCardSchema,
+    tasks: z.array(DeliveryLedgerTaskSchema).min(1),
+    evidence: z.array(z.string().min(1)),
+    nextStep: z.string().min(1),
+    memoryTopicKey: z.string().min(1),
+    workspace: z.record(z.string(), z.string()),
+    createdAt: z.string().datetime(),
+    updatedAt: z.string().datetime()
+  });
+  DeliveryLedgerRequestSchema = z.object({
+    id: z.string().regex(/^[a-z0-9][a-z0-9-]{0,63}$/),
+    authorized: z.boolean(),
+    route: DeliveryRouteSchema,
+    taskCard: CanonicalTaskCardSchema,
+    tasks: z.array(DeliveryLedgerTaskSchema).min(1),
+    nextStep: z.string().min(1)
+  });
   TaskOutcomeSchema = z.object({
     id: z.string(),
     taskId: z.string(),
@@ -937,7 +980,8 @@ var init_schemas = __esm(() => {
     variantId: z.string().optional(),
     suiteTaskId: z.string().optional(),
     harnessFingerprint: z.string().optional(),
-    disabledComponents: z.array(z.string()).optional()
+    disabledComponents: z.array(z.string()).optional(),
+    delivery: DeliveryTelemetrySchema.optional()
   });
   HarnessComponentIdSchema = z.enum([
     "wayfinding",
@@ -1134,6 +1178,34 @@ var init_goal_state = __esm(() => {
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 init_schemas();
 
+// 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";
+}
+
 // src/core/product-graph/paths.ts
 import { join } from "node:path";
 var PRODUCT_DIR = ".codeconductor";
@@ -1161,7 +1233,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)));
   }
@@ -1314,8 +1386,8 @@ async function clearActiveTask(projectRoot, taskId) {
 // src/core/verification/verification-runner.ts
 init_schemas();
 import { existsSync } from "node:fs";
-import { readFile as readFile6 } from "node:fs/promises";
-import { dirname, join as join2, resolve as resolve5 } from "node:path";
+import { readFile as readFile7 } from "node:fs/promises";
+import { dirname, join as join3, resolve as resolve6 } from "node:path";
 
 // src/core/config/config-loader.ts
 import { readFile as readFile5 } from "node:fs/promises";
@@ -1631,7 +1703,128 @@ async function runCompileCheck(options) {
   }
 }
 // src/core/verification/verification-runner.ts
-import { mkdir as mkdir5, readdir, writeFile as writeFile4 } from "node:fs/promises";
+import { mkdir as mkdir5, readdir as readdir2, writeFile as writeFile4 } from "node:fs/promises";
+
+// src/core/verification/rdd-receipt.ts
+import { createHash } from "node:crypto";
+import { readdir, readFile as readFile6 } from "node:fs/promises";
+import { join as join2, relative, resolve as resolve5, sep } from "node:path";
+var EXCLUDED_DIRECTORIES = new Set([
+  ".git",
+  ".codeconductor",
+  "node_modules",
+  "dist",
+  "coverage",
+  "graphify-out"
+]);
+function sha256(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function canonicalPath(projectRoot, input) {
+  const root = resolve5(projectRoot);
+  const absolute = resolve5(root, input);
+  if (absolute !== root && !absolute.startsWith(`${root}${sep}`)) {
+    throw new Error(`RDD receipt path "${input}" is outside the project root`);
+  }
+  const normalized = relative(root, absolute);
+  if (!normalized || normalized === ".") {
+    throw new Error("RDD receipts require file paths, not the project root");
+  }
+  return { absolute, relative: normalized.split(sep).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: sha256(await readFile6(absolute)) });
+  }
+  return result;
+}
+function manifestHash(paths) {
+  return sha256(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 = resolve5(projectRoot);
+  const paths = [];
+  async function visit(current) {
+    const entries = await readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (!EXCLUDED_DIRECTORIES.has(entry.name))
+          await visit(join2(current, entry.name));
+        continue;
+      }
+      if (entry.isFile())
+        paths.push(relative(root, join2(current, entry.name)).split(sep).join("/"));
+    }
+  }
+  await visit(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 = sha256(await readFile6(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
+  };
+}
+
+// src/core/verification/verification-runner.ts
 function isPassingEvidence(ev) {
   switch (ev.type) {
     case "verification":
@@ -1648,9 +1841,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 = resolve5(evDir, `${id.replace(/[^A-Za-z0-9_-]/g, "_")}.json`);
-  if (dirname(path) !== resolve5(evDir)) {
+  const path = resolve6(evDir, `${id.replace(/[^A-Za-z0-9_-]/g, "_")}.json`);
+  if (dirname(path) !== resolve6(evDir)) {
     return err(new Error(`Refusing to write evidence for "${id}" outside ${evDir}`));
   }
   return ok(path);
@@ -1676,7 +1877,7 @@ async function collectTaskEvidence(projectRoot, taskId) {
     return ok({ records, invalid });
   let files;
   try {
-    files = await readdir(evDir);
+    files = await readdir2(evDir);
   } catch (e) {
     return err(e instanceof Error ? e : new Error(String(e)));
   }
@@ -1684,7 +1885,7 @@ async function collectTaskEvidence(projectRoot, taskId) {
     if (!file.endsWith(".json"))
       continue;
     try {
-      const raw = await readFile6(join2(evDir, file), "utf-8");
+      const raw = await readFile7(join3(evDir, file), "utf-8");
       const ev = EvidenceSchema.parse(JSON.parse(raw));
       if (ev.relatedTask === taskId)
         records.push(ev);
@@ -1705,7 +1906,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")
@@ -1786,7 +1987,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",
@@ -1794,6 +2000,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",
@@ -1802,7 +2015,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)
@@ -1825,19 +2038,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:
@@ -1852,12 +2071,26 @@ async function captureTddSuiteEvidence(projectRoot, taskId, options) {
   if (!options.allowCompileCheck && !isAllowlistedTestCommand(options.command)) {
     return err(new Error("TDD suite command is not on the test allowlist. Re-run with --allow-compile-check to trust it."));
   }
+  const paths = await collectReceiptPaths(projectRoot);
+  const before = await captureReceipt(projectRoot, {
+    taskId,
+    phase: options.phase ?? "verification",
+    paths,
+    command: options.command,
+    outcome: "failed",
+    coverage: "project"
+  });
   const result = await runCompileCheck({
     command: options.command,
     cwd: projectRoot
   });
   const suitePassed = result.success && !result.timedOut && result.exitCode === 0;
   const suiteFailed = !result.timedOut && result.exitCode !== 0;
+  const receipt = { ...before, outcome: suitePassed ? "passed" : "failed" };
+  const receiptResult = await verifyReceipt(projectRoot, receipt);
+  if (!receiptResult.valid) {
+    return err(new Error(`RDD candidate changed while the TDD suite ran: ${receiptResult.changedPaths.join(", ")}`));
+  }
   const evidence = {
     id: `ev-tdd-${taskId}-${Date.now()}`,
     source: TDD_EVIDENCE_SOURCE,
@@ -1872,7 +2105,8 @@ async function captureTddSuiteEvidence(projectRoot, taskId, options) {
       suitePassed,
       exitCode: result.exitCode,
       timedOut: result.timedOut,
-      command: options.command
+      command: options.command,
+      rddReceipt: receipt
     }
   };
   const persisted = await persistEvidence(projectRoot, evidence);
@@ -1894,7 +2128,8 @@ async function captureTddSuiteEvidence(projectRoot, taskId, options) {
   return ok({
     evidenceId: evidence.id,
     suiteFailed,
-    suitePassed
+    suitePassed,
+    receipt
   });
 }
 async function loadTddSuiteEvidence(projectRoot, taskId, evidenceId) {
@@ -1904,7 +2139,7 @@ async function loadTddSuiteEvidence(projectRoot, taskId, evidenceId) {
     return path;
   let raw;
   try {
-    raw = await readFile6(path.data, "utf-8");
+    raw = await readFile7(path.data, "utf-8");
   } catch (e) {
     return err(e instanceof Error ? e : new Error(String(e)));
   }
@@ -1926,13 +2161,37 @@ async function loadTddSuiteEvidence(projectRoot, taskId, evidenceId) {
   if (capturedBy !== TDD_CAPTURED_BY || typeof suiteFailed !== "boolean" || typeof suitePassed !== "boolean") {
     return err(new Error(`Evidence "${evidenceId}" was not captured by the verification runner`));
   }
-  return ok({ capturedBy, suiteFailed, suitePassed });
+  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) {
+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;
 }
 
 // src/core/orchestrator/runtime-orchestrator.ts
@@ -2701,6 +2960,11 @@ export {
   CouncilVerdictInputSchema,
   CouncilVerdictSchema,
   DecisionSchema,
+  DeliveryLedgerRequestSchema,
+  DeliveryLedgerSchema,
+  DeliveryLedgerTaskSchema,
+  DeliveryRouteSchema,
+  DeliveryTelemetrySchema,
   EvaluationIndexSchema,
   EvidenceSchema,
   ExecutionContextSchema,
@@ -2766,6 +3030,7 @@ export {
   TaskOutcomeSourceSchema,
   TaskOutcomeStatusSchema,
   TechnicalPlanOutputSchema,
+  TokenUsageSchema,
   ToolProviderNamesSchema,
   VerificationReportSchema,
   WorkflowCommandSchema,
@@ -2774,7 +3039,9 @@ export {
   WorkflowRiskRuleSchema,
   advanceTddPhase,
   buildTaskEnvelope,
+  captureReceipt,
   captureTddSuiteEvidence,
+  collectReceiptPaths,
   completeTask,
   createInitialState,
   createInitialTddState,
@@ -2785,6 +3052,7 @@ export {
   getReadyTasks,
   goalTaskToCanonicalCard,
   hasTddRunnerEvidence,
+  isRddReceipt,
   loadTddSuiteEvidence,
   loopStateMachine,
   rollbackTaskStatus,
@@ -2833,5 +3101,6 @@ export {
   validateSkillsRegistry,
   validateTargetCapabilities,
   validateTaskOutcome,
-  validateWorkflowProfile
+  validateWorkflowProfile,
+  verifyReceipt
 };

package/dist/utils/cli-bin.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Resolve the CLI command prefix based on execution context.
+ *
+ * - When invoked via npx (e.g. `npx cc-codeconductor ...`), returns `npx cc-codeconductor`.
+ * - When invoked via bunx, returns `bunx cc-codeconductor`.
+ * - When invoked during local development (`bun run dev` or executing `src/cli/main.ts`), returns `bun run dev`.
+ * - When invoked via an installed binary (`cc-codeconductor` or `codeconductor`), returns that binary name.
+ * - Respects the `CC_CLI_BIN` environment variable for testing or explicit overrides.
+ * - Defaults to `cc-codeconductor`.
+ */
+export declare function resolveCliBin(env?: NodeJS.ProcessEnv, argv?: readonly string[]): string;
+/**
+ * Formats a command usage string replacing any legacy or alternative command prefix
+ * (`cc `, `cc-codeconductor `, or `codeconductor `) with the resolved bin prefix.
+ */
+export declare function formatUsage(usage: string, bin?: string): string;