cc-codeconductor 1.4.1 → 1.4.2

package/README.md

@@ -134,12 +134,21 @@ what they do rather than which subsystem they touch:
 | Entry         | `/cc-ask`, `/cc-triage`, `/cc-explore`                                                                          | Recommend a next command and stop — no writes.  |
 | Delivery      | `/cc-feature`, `/cc-fix`, `/cc-refactor`, `/cc-tdd-cycle`, `/cc-api-contract`, `/cc-db-migration`, `/cc-spec-mutation` | Implement, test-before-implement where both apply. |
 | Verification  | `/cc-review`, `/cc-council`, `/cc-scorecard`, `/cc-test-plan`, `/cc-security`                                    | Gate a diff or a decision before merge.         |
-| Management    | `/cc-backlog`, `/cc-openspec`, `/cc-handoff`, `/cc-clarify`, `/cc-prototype`, `/cc-pagespeed`, `/cc-iterative`   | Author BACKLOG.md, deliver it, or one-off ops.  |
+| Management    | `/cc-backlog`, `/cc-openspec`, `/cc-handoff`, `/cc-clarify`, `/cc-prototype`, `/cc-pagespeed`, `/cc-iterative`, `/cc-odd`   | Author BACKLOG.md, deliver it, or one-off ops.  |
 
 Prefer `/cc-iterative`, `/cc-triage`, and `/cc-handoff` for wayfinding.
 `/cc-ask` recommends a command from a natural-language problem; it does not
 start the workflow.
 
+### ODD adoption and escalation
+
+ODD is opt-in until paired delivery evidence shows non-inferior acceptance,
+tests, and findings with lower context than OpenSpec. Run
+`bun run dev scorecard suite-run --suite odd-adoption` to keep that decision
+reproducible. The [ODD adoption guide](docs/odd-adoption.md) explains route
+selection, ledger-based resumption, and when to return to OpenSpec, TDD, or
+Council.
+
 ### OpenSpec and TDD
 
 OpenSpec is the delivery loop for `BACKLOG.md`:
@@ -152,6 +161,18 @@ Agent phases: validate-backlog → discover → design → **test** → implemen
 review. Test-before-implement is required whenever both phases apply.
 `/cc-tdd-cycle` enforces Red → Green → Refactor (`tester` then `implementer`).
 
+### Receipt-Driven Development
+
+RDD binds local verification evidence to the exact code, tests, contracts,
+lockfiles, and configuration it observed. Use `bun run dev rdd capture --task
+<id>`, `bun run dev rdd verify --receipt <id>`, and `bun run dev rdd status` to
+inspect that evidence. A changed candidate invalidates its receipt and requires
+the affected verification to run again. RDD complements TDD and Mutation
+Testing: it checks evidence freshness rather than behavioral coverage.
+Run `bun run dev rdd install-hooks` in a Git repository to install preserving
+pre-commit and pre-push checks; the hook runs `rdd git-check` against the latest
+receipt.
+
 ### Review agents
 
 15 Conductor Agents ship in `presets/<target>/agents/`. Review path:
@@ -630,7 +651,9 @@ npx cc-codeconductor openspec next
 npx cc-codeconductor openspec start BC-001-discover
 npx cc-codeconductor openspec done BC-001-discover
 npx cc-codeconductor openspec block BC-001-implement --reason "waiting on design"
+npx cc-codeconductor openspec unblock BC-001-implement
 npx cc-codeconductor openspec archive BC-001
+npx cc-codeconductor odd read delivery-001
 ```
 
 Subcommands: `validate` / `scan` / `plan` / `analyze` / `status` / `next` /

package/dist/core/verification/rdd-receipt.d.ts

@@ -0,0 +1,39 @@
+export type RddPhase = 'red' | 'green' | 'refactor' | 'verification' | 'mutation' | 'review';
+export interface RddReceiptPath {
+    readonly path: string;
+    readonly hash: string;
+}
+export interface RddReceipt {
+    readonly version: 1;
+    readonly taskId: string;
+    readonly phase: RddPhase;
+    readonly paths: readonly RddReceiptPath[];
+    readonly coverage: 'paths' | 'project';
+    readonly manifestHash: string;
+    readonly command?: string;
+    readonly outcome: 'passed' | 'failed';
+    readonly capturedAt: string;
+}
+export interface ReceiptVerification {
+    readonly valid: boolean;
+    readonly expectedHash: string;
+    readonly actualHash: string;
+    readonly changedPaths: readonly string[];
+}
+export declare function isRddReceipt(value: unknown): value is RddReceipt;
+export declare function captureReceipt(projectRoot: string, input: {
+    readonly taskId: string;
+    readonly phase: RddPhase;
+    readonly paths: readonly string[];
+    readonly command?: string;
+    readonly outcome: 'passed' | 'failed';
+    /** Include additions and deletions across the complete project candidate. */
+    readonly coverage?: 'paths' | 'project';
+}): Promise<RddReceipt>;
+/**
+ * Collect the versioned-input candidate for a local verification run. Runtime
+ * state and generated output are deliberately excluded because recording a
+ * receipt itself must not invalidate the candidate it describes.
+ */
+export declare function collectReceiptPaths(projectRoot: string): Promise<string[]>;
+export declare function verifyReceipt(projectRoot: string, receipt: RddReceipt): Promise<ReceiptVerification>;

package/dist/core/verification/verification-runner.d.ts

@@ -1,6 +1,7 @@
 import type { GoalGraphInput } from '../../validation/schemas';
 import type { TddSuiteEvidence } from '../../domain/loop/loop-state';
 import { type Result } from '../../utils/result';
+import { type RddReceipt } from './rdd-receipt';
 export interface VerificationCheck {
     name: string;
     passed: boolean;
@@ -42,6 +43,8 @@ export declare const TDD_CAPTURED_BY = "verification-runner";
 export interface CaptureTddSuiteOptions extends RunVerificationOptions {
     /** Allowlisted test command (`bun test`, `npm test`, …). */
     readonly command: string;
+    /** The TDD transition this runner invocation is expected to prove. */
+    readonly phase?: 'red' | 'green' | 'refactor';
 }
 /**
  * Run a test suite and store TDD evidence. Only this function writes records
@@ -51,14 +54,17 @@ export declare function captureTddSuiteEvidence(projectRoot: string, taskId: str
     evidenceId: string;
     suiteFailed: boolean;
     suitePassed: boolean;
+    receipt: RddReceipt;
 }, Error>>;
 /**
  * Load TDD suite evidence written by `captureTddSuiteEvidence`. Hand-edited
  * files (wrong source/type/`capturedBy`) are rejected.
  */
-export declare function loadTddSuiteEvidence(projectRoot: string, taskId: string, evidenceId: string): Promise<Result<TddSuiteEvidence, Error>>;
+export declare function loadTddSuiteEvidence(projectRoot: string, taskId: string, evidenceId: string): Promise<Result<TddSuiteEvidence & {
+    receipt: RddReceipt;
+}, Error>>;
 /**
  * True when the verification runner stored TDD evidence for this task.
  * Handmade JSON (wrong source/type/capturedBy) does not count.
  */
-export declare function hasTddRunnerEvidence(projectRoot: string, taskId: string): Promise<boolean>;
+export declare function hasTddRunnerEvidence(projectRoot: string, taskId: string, expectedPhase?: 'red' | 'green'): Promise<boolean>;

package/dist/index.d.ts

@@ -9,6 +9,8 @@ export type { OrchestratorNextResult } from './core/orchestrator/runtime-orchest
 export { LoopEngine, runLoop, runLoopForProject, shouldRunAgentLoop, formatFeedback, advanceTddPhase, } from './core/loop/loop-engine';
 export type { LoopConfig, LoopResult, EscalationReport, GuardrailHit, GenerateFn, CompileCheckFn, } from './core/loop/loop-engine';
 export { runVerification, gateTaskCompletion, validateEvidenceIds, captureTddSuiteEvidence, loadTddSuiteEvidence, hasTddRunnerEvidence, } from './core/verification/verification-runner';
+export { captureReceipt, collectReceiptPaths, isRddReceipt, verifyReceipt, } from './core/verification/rdd-receipt';
+export type { RddPhase, RddReceipt, RddReceiptPath, ReceiptVerification } from './core/verification/rdd-receipt';
 export type { RunVerificationOptions, VerificationCheck, CaptureTddSuiteOptions, } from './core/verification/verification-runner';
 export * from './validation/schemas';
 export { createInitialState, loopStateMachine, createInitialTddState, tddCycleStateMachine, } from './domain/loop/loop-state';