cclaw-cli 6.10.0 → 6.12.0

package/dist/artifact-linter/shared.d.ts

@@ -412,11 +412,14 @@ export interface TddEvidencePointerOptions {
      */
     pointerSatisfied?: boolean;
     /**
-     * True when `06-tdd-slices.jsonl` contains a slice with the matching
-     * output ref (`redOutputRef`/`greenOutputRef`); the markdown evidence
-     * block is auto-satisfied because the sidecar is the source of truth.
+     * v6.11.0 (D5) — true when `delegation-events.jsonl` carries at least
+     * one slice-tagged event for the current run with the matching phase
+     * (`phase=red` for RED, `phase=green` for GREEN) and a non-empty
+     * `evidenceRefs` array. Phase events are the new source of truth in
+     * v6.11.0, so the markdown evidence block is auto-satisfied without
+     * requiring hand-pasted stdout content.
      */
-    sidecarAutoSatisfy?: boolean;
+    phaseEventsSatisfied?: boolean;
 }
 /**
  * Sync helper that scans for `Evidence:` lines in a section body and

package/dist/artifact-linter/shared.js

@@ -1442,10 +1442,10 @@ export function extractEvidencePointers(sectionBody) {
     return pointers;
 }
 export function validateTddRedEvidence(sectionBody, opts = {}) {
-    if (opts.sidecarAutoSatisfy) {
+    if (opts.phaseEventsSatisfied) {
         return {
             ok: true,
-            details: "RED Evidence auto-satisfied: 06-tdd-slices.jsonl carries a redOutputRef for the matching slice."
+            details: "RED Evidence auto-satisfied: delegation-events.jsonl carries a phase=red row with non-empty evidenceRefs for the active run."
         };
     }
     if (opts.pointerSatisfied) {
@@ -1479,10 +1479,10 @@ export function validateTddRedEvidence(sectionBody, opts = {}) {
     };
 }
 export function validateTddGreenEvidence(sectionBody, opts = {}) {
-    if (opts.sidecarAutoSatisfy) {
+    if (opts.phaseEventsSatisfied) {
         return {
             ok: true,
-            details: "GREEN Evidence auto-satisfied: 06-tdd-slices.jsonl carries a greenOutputRef for the matching slice."
+            details: "GREEN Evidence auto-satisfied: delegation-events.jsonl carries a phase=green row with non-empty evidenceRefs for the active run."
         };
     }
     if (opts.pointerSatisfied) {

package/dist/artifact-linter/tdd.d.ts

@@ -1,33 +1,83 @@
-import { type TddSliceLedgerEntry } from "../tdd-slices.js";
-import { type StageLintContext } from "./shared.js";
+import type { DelegationEntry } from "../delegation.js";
+import { type LintFinding, type StageLintContext } from "./shared.js";
+/**
+ * v6.11.0 — TDD stage linter.
+ *
+ * Source-of-truth ladder, in order of precedence:
+ *
+ * 1. **Phase events** in `delegation-events.jsonl` for the active run
+ *    (`stage=tdd`, `sliceId=S-N`, `phase=red|green|refactor|refactor-deferred|doc`).
+ *    When at least one slice carries any phase event, the linter
+ *    auto-derives Watched-RED / Vertical Slice Cycle from the events
+ *    and writes a rendered summary block between auto-render markers
+ *    in `06-tdd.md`. Markdown table content is no longer required.
+ * 2. **Legacy markdown tables** (Watched-RED Proof + Vertical Slice
+ *    Cycle) — used as a fallback when the events ledger has no slice
+ *    phase rows for the active run. Existing v6.10 and earlier
+ *    artifacts continue to validate via this path.
+ * 3. **Sharded slice files** under `<artifacts-dir>/tdd-slices/S-*.md`.
+ *    Per-slice prose lives there. The main `06-tdd.md` is auto-indexed
+ *    via `## Slices Index`.
+ */
 export declare function lintTddStage(ctx: StageLintContext): Promise<void>;
+interface SliceFileInfo {
+    sliceId: string;
+    absPath: string;
+}
 interface ParsedSliceCycleResult {
     ok: boolean;
     details: string;
 }
+interface ExpandedSliceCycleResult extends ParsedSliceCycleResult {
+    findings: LintFinding[];
+}
+export declare function evaluateEventsWatchedRed(slices: Map<string, DelegationEntry[]>): ParsedSliceCycleResult;
+export declare function evaluateEventsSliceCycle(slices: Map<string, DelegationEntry[]>): ExpandedSliceCycleResult;
+interface DocCoverageResult {
+    missing: string[];
+}
+export declare function evaluateSliceDocumenterCoverage(slices: Map<string, DelegationEntry[]>): DocCoverageResult;
+interface ImplementerCoverageResult {
+    missing: string[];
+}
 /**
- * v6.10.0 (T2) — sidecar-aware Watched-RED check. Validates that every
- * slice currently recorded in `06-tdd-slices.jsonl` (folded latest-row
- * per `sliceId`) has the structural evidence the markdown table would
- * have required: RED observation timestamp, test file, test command,
- * and at least one claimed path.
+ * v6.12.0 Phase M — slice-implementer must own GREEN. For each slice
+ * that recorded a phase=red event with non-empty evidenceRefs, require a
+ * phase=green event whose `agent === "slice-implementer"`. Slices whose
+ * GREEN event came from a different agent (e.g. controller wrote GREEN
+ * itself and recorded a green row under another agent name) are flagged.
  */
-export declare function evaluateSidecarWatchedRed(rawEntries: TddSliceLedgerEntry[]): ParsedSliceCycleResult;
+export declare function evaluateSliceImplementerCoverage(slices: Map<string, DelegationEntry[]>): ImplementerCoverageResult;
+interface RedCheckpointResult {
+    ok: boolean;
+    details: string;
+}
 /**
- * v6.10.0 (T2) — sidecar-aware Vertical Slice Cycle check. Each slice
- * must have a row whose effective status (latest by sliceId) implies a
- * monotonic progression. Once a slice carries `greenAt`, the linter
- * requires `greenAt >= redObservedAt`. `refactor-deferred` requires a
- * non-empty `refactorRationale`. `refactor-done` requires a `refactorAt`
- * that is `>= greenAt`. Slices stuck at `red` are tolerated only when
- * the run is still in TDD; the linter surfaces them as advisory through
- * the watched-RED check above.
+ * v6.12.0 Phase W — RED checkpoint enforcement. The wave protocol
+ * requires ALL Phase A REDs to land before ANY Phase B GREEN starts.
+ * The rule is enforced on a per-wave basis, where a wave is defined by
+ * `<artifacts-dir>/wave-plans/wave-NN.md` files (when present) listing
+ * slice ids. When no wave manifest exists, the linter falls back to a
+ * conservative implicit detection: a wave is a contiguous run of
+ * `phase=red` events with no other-phase events between them; the rule
+ * fires only when the implicit wave has 2+ members.
+ *
+ * @param waveMembers Optional explicit wave manifest. Map key is wave
+ * name (e.g. `"W-01"`); value is the set of slice ids in that wave.
  */
-export declare function evaluateSidecarSliceCycle(rawEntries: TddSliceLedgerEntry[]): ParsedSliceCycleResult;
+export declare function evaluateRedCheckpoint(slices: Map<string, DelegationEntry[]>, waveMembers?: Map<string, Set<string>> | null): RedCheckpointResult;
 export declare function parseVerticalSliceCycle(body: string): ParsedSliceCycleResult;
 interface VerificationLadderResult {
     ok: boolean;
     details: string;
 }
 export declare function evaluateVerificationLadder(body: string | null): VerificationLadderResult;
+interface RenderInput {
+    mainArtifactPath: string;
+    slicesByEvents: Map<string, DelegationEntry[]>;
+    sliceFiles: SliceFileInfo[];
+    renderSummary?: boolean;
+    renderIndex?: boolean;
+}
+export declare function renderTddSliceSummary(input: RenderInput): Promise<void>;
 export {};