cclaw-cli 6.9.0 → 6.10.0

package/dist/artifact-linter/plan.js

@@ -3,6 +3,8 @@ import { resolveArtifactPath as resolveStageArtifactPath } from "../artifact-pat
 import { exists } from "../fs-utils.js";
 import { FORBIDDEN_PLACEHOLDER_TOKENS, CONFIDENCE_FINDING_REGEX_SOURCE } from "../content/skills.js";
 import fs from "node:fs/promises";
+import path from "node:path";
+import { PLAN_SPLIT_SMALL_PLAN_THRESHOLD, parseImplementationUnits } from "../internal/plan-split-waves.js";
 export async function lintPlanStage(ctx) {
     const { projectRoot, track, raw, absFile, sections, findings, parsedFrontmatter, brainstormShortCircuitBody, brainstormShortCircuitActivated, staleDiagramAuditEnabled, isTrivialOverride } = ctx;
     evaluateInvestigationTrace(ctx, "Implementation Units");
@@ -114,6 +116,41 @@ export async function lintPlanStage(ctx) {
             ? "No forbidden placeholder tokens detected outside the rule section."
             : `Detected forbidden token(s) elsewhere in plan: ${filteredPlanHits.join(", ")}.`
     });
+    // v6.10.0 (P4) — advisory `plan_too_large_no_waves`. Fires when a
+    // standard-track plan has more than the wave-split threshold of
+    // implementation units AND the wave-plans/ directory is empty.
+    // Linter advisories never block stage-complete (`required: false`),
+    // so the agent gets a nudge to run `cclaw-cli internal plan-split-waves`
+    // without the plan stage failing.
+    try {
+        const planUnits = parseImplementationUnits(raw);
+        if (planUnits.length > PLAN_SPLIT_SMALL_PLAN_THRESHOLD) {
+            const artifactsDir = path.dirname(absFile);
+            const wavePlansDir = path.join(artifactsDir, "wave-plans");
+            let wavePlansHasContent = false;
+            try {
+                const dirEntries = await fs.readdir(wavePlansDir);
+                wavePlansHasContent = dirEntries.some((name) => /^wave-\d+\.md$/u.test(name));
+            }
+            catch {
+                wavePlansHasContent = false;
+            }
+            if (!wavePlansHasContent) {
+                findings.push({
+                    section: "plan_too_large_no_waves",
+                    required: false,
+                    rule: "Plans with > 50 implementation units benefit from being split into manageable waves via `cclaw-cli internal plan-split-waves`.",
+                    found: false,
+                    details: `Plan has ${planUnits.length} implementation unit(s) (threshold ${PLAN_SPLIT_SMALL_PLAN_THRESHOLD}) and no wave-plans/ directory yet. ` +
+                        "Run `cclaw-cli internal plan-split-waves` to break this plan into manageable waves; the linter is advisory only and will not block stage-complete."
+                });
+            }
+        }
+    }
+    catch {
+        // Parser errors should never block the linter — the advisory is
+        // purely a nudge.
+    }
     const handoffBody = sectionBodyByName(sections, "Execution Handoff");
     if (handoffBody !== null) {
         const ok = /(subagent-driven|inline executor)/iu.test(handoffBody);

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

@@ -395,11 +395,46 @@ export interface ArchitectureDiagramValidationResult {
  * mentioning external-dependency keywords).
  */
 export declare function validateArchitectureDiagram(sectionBody: string, context?: ArchitectureDiagramValidationContext): ArchitectureDiagramValidationResult;
-export declare function validateTddRedEvidence(sectionBody: string): {
+/**
+ * v6.10.0 (T3) — pointer-mode evidence acceptance. RED/GREEN sections may
+ * substitute pasted stdout with a single line of the form
+ * `Evidence: <relative-or-abs-path>` or `Evidence: spanId:<id>`. The
+ * validator alone cannot reach the filesystem or delegation ledger
+ * synchronously, so the lint pipeline pre-resolves pointers and then
+ * passes booleans through these option flags.
+ */
+export interface TddEvidencePointerOptions {
+    /**
+     * True when the section body has at least one `Evidence:` pointer line
+     * AND the pointer resolved to either an existing file or a known
+     * delegation spanId. The validator then short-circuits without
+     * requiring pasted stdout markers.
+     */
+    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.
+     */
+    sidecarAutoSatisfy?: boolean;
+}
+/**
+ * Sync helper that scans for `Evidence:` lines in a section body and
+ * returns the trimmed value of each. Used by the lint pipeline to
+ * pre-resolve pointers (filesystem path-existence or delegation ledger
+ * spanId match) before invoking the validators.
+ *
+ * Recognised forms:
+ *   Evidence: <path>
+ *   Evidence: spanId:<id>
+ *   - Evidence: <path>
+ */
+export declare function extractEvidencePointers(sectionBody: string): string[];
+export declare function validateTddRedEvidence(sectionBody: string, opts?: TddEvidencePointerOptions): {
     ok: boolean;
     details: string;
 };
-export declare function validateTddGreenEvidence(sectionBody: string): {
+export declare function validateTddGreenEvidence(sectionBody: string, opts?: TddEvidencePointerOptions): {
     ok: boolean;
     details: string;
 };
@@ -543,6 +578,17 @@ export interface ValidateSectionBodyContext {
      * in the Architecture Diagram body.
      */
     liteTier?: boolean;
+    /**
+     * v6.10.0 (T3) — pre-resolved RED/GREEN Evidence pointer state. The
+     * artifact linter resolves `Evidence: <path|spanId:...>` lines and
+     * inspects the TDD slice sidecar before invoking
+     * `validateSectionBody`; the resulting booleans here let the
+     * validator short-circuit without re-doing async work.
+     */
+    tddEvidence?: {
+        red?: TddEvidencePointerOptions;
+        green?: TddEvidencePointerOptions;
+    };
 }
 export declare function validateSectionBody(sectionBody: string, rule: string, sectionName: string, context?: ValidateSectionBodyContext): {
     ok: boolean;

package/dist/artifact-linter/shared.js

@@ -1417,7 +1417,43 @@ function shouldEnforceFailureEdge(diagramBody, context) {
         return true;
     return false;
 }
-export function validateTddRedEvidence(sectionBody) {
+/**
+ * Sync helper that scans for `Evidence:` lines in a section body and
+ * returns the trimmed value of each. Used by the lint pipeline to
+ * pre-resolve pointers (filesystem path-existence or delegation ledger
+ * spanId match) before invoking the validators.
+ *
+ * Recognised forms:
+ *   Evidence: <path>
+ *   Evidence: spanId:<id>
+ *   - Evidence: <path>
+ */
+export function extractEvidencePointers(sectionBody) {
+    const pointers = [];
+    const pattern = /^\s*-?\s*evidence\s*:\s*(.+?)\s*$/imu;
+    for (const line of sectionBody.split(/\r?\n/u)) {
+        const match = pattern.exec(line);
+        if (match && match[1] !== undefined) {
+            const value = match[1].trim();
+            if (value.length > 0)
+                pointers.push(value);
+        }
+    }
+    return pointers;
+}
+export function validateTddRedEvidence(sectionBody, opts = {}) {
+    if (opts.sidecarAutoSatisfy) {
+        return {
+            ok: true,
+            details: "RED Evidence auto-satisfied: 06-tdd-slices.jsonl carries a redOutputRef for the matching slice."
+        };
+    }
+    if (opts.pointerSatisfied) {
+        return {
+            ok: true,
+            details: "RED Evidence satisfied via `Evidence: <path|spanId:...>` pointer (resolved to an existing artifact or delegation span)."
+        };
+    }
     const meaningful = meaningfulLineCount(sectionBody);
     if (meaningful < 2) {
         return {
@@ -1442,7 +1478,19 @@ export function validateTddRedEvidence(sectionBody) {
         details: "RED Evidence includes command + failing output markers."
     };
 }
-export function validateTddGreenEvidence(sectionBody) {
+export function validateTddGreenEvidence(sectionBody, opts = {}) {
+    if (opts.sidecarAutoSatisfy) {
+        return {
+            ok: true,
+            details: "GREEN Evidence auto-satisfied: 06-tdd-slices.jsonl carries a greenOutputRef for the matching slice."
+        };
+    }
+    if (opts.pointerSatisfied) {
+        return {
+            ok: true,
+            details: "GREEN Evidence satisfied via `Evidence: <path|spanId:...>` pointer (resolved to an existing artifact or delegation span)."
+        };
+    }
     const meaningful = meaningfulLineCount(sectionBody);
     if (meaningful < 2) {
         return {
@@ -2058,10 +2106,10 @@ export function validateSectionBody(sectionBody, rule, sectionName, context = {}
     }
     const sectionNameNormalized = normalizeHeadingTitle(sectionName).toLowerCase();
     if (sectionNameNormalized === "red evidence") {
-        return validateTddRedEvidence(sectionBody);
+        return validateTddRedEvidence(sectionBody, context.tddEvidence?.red ?? {});
     }
     if (sectionNameNormalized === "green evidence") {
-        return validateTddGreenEvidence(sectionBody);
+        return validateTddGreenEvidence(sectionBody, context.tddEvidence?.green ?? {});
     }
     if (sectionNameNormalized === "verification ladder") {
         return validateVerificationLadder(sectionBody);

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

@@ -1,9 +1,29 @@
+import { type TddSliceLedgerEntry } from "../tdd-slices.js";
 import { type StageLintContext } from "./shared.js";
 export declare function lintTddStage(ctx: StageLintContext): Promise<void>;
 interface ParsedSliceCycleResult {
     ok: boolean;
     details: 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.
+ */
+export declare function evaluateSidecarWatchedRed(rawEntries: TddSliceLedgerEntry[]): ParsedSliceCycleResult;
+/**
+ * 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.
+ */
+export declare function evaluateSidecarSliceCycle(rawEntries: TddSliceLedgerEntry[]): ParsedSliceCycleResult;
 export declare function parseVerticalSliceCycle(body: string): ParsedSliceCycleResult;
 interface VerificationLadderResult {
     ok: boolean;

package/dist/artifact-linter/tdd.js

@@ -1,9 +1,12 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { readDelegationLedger } from "../delegation.js";
+import { foldTddSliceLedger, readTddSliceLedger } from "../tdd-slices.js";
 import { evaluateInvestigationTrace, sectionBodyByName } from "./shared.js";
 export async function lintTddStage(ctx) {
     const { projectRoot, track, raw, absFile, sections, findings, parsedFrontmatter, brainstormShortCircuitBody, brainstormShortCircuitActivated, staleDiagramAuditEnabled, isTrivialOverride } = ctx;
+    const sliceLedger = await readTddSliceLedger(projectRoot);
+    const sidecarActive = sliceLedger.entries.length > 0;
     evaluateInvestigationTrace(ctx, "Watched-RED Proof");
     // Universal Layer 2.6 structural checks (superpowers TDD + evanflow vertical slices).
     const ironLawBody = sectionBodyByName(sections, "Iron Law Acknowledgement");
@@ -29,7 +32,21 @@ export async function lintTddStage(ctx) {
         });
     }
     const watchedRedBody = sectionBodyByName(sections, "Watched-RED Proof");
-    if (watchedRedBody === null) {
+    if (sidecarActive) {
+        // v6.10.0 (T2): when 06-tdd-slices.jsonl carries rows, the sidecar is
+        // the source of truth for RED observation evidence; the markdown
+        // table is auto-derived (or left as a template stub) and must not
+        // block stage advance.
+        const sidecarResult = evaluateSidecarWatchedRed(sliceLedger.entries);
+        findings.push({
+            section: "Watched-RED Proof Shape",
+            required: true,
+            rule: "Watched-RED Proof: when 06-tdd-slices.jsonl is present, every slice row with status >= red must include redObservedAt, testFile, testCommand, and claimedPaths.",
+            found: sidecarResult.ok,
+            details: sidecarResult.details
+        });
+    }
+    else if (watchedRedBody === null) {
         findings.push({
             section: "Watched-RED Proof Shape",
             required: true,
@@ -63,26 +80,56 @@ export async function lintTddStage(ctx) {
                     : `${populatedRows.length - validProofRows.length} watched-RED proof row(s) lack an ISO timestamp.`
         });
     }
-    const sliceCycleBody = sectionBodyByName(sections, "Vertical Slice Cycle");
-    if (sliceCycleBody === null) {
+    if (sidecarActive) {
+        const cycleResult = evaluateSidecarSliceCycle(sliceLedger.entries);
         findings.push({
             section: "Vertical Slice Cycle Coverage",
             required: true,
-            rule: "Vertical Slice Cycle must include RED, GREEN, and REFACTOR per slice (refactor may be deferred with rationale).",
-            found: false,
-            details: "No ## heading matching required section \"Vertical Slice Cycle\"."
-        });
-    }
-    else {
-        const cycleResult = parseVerticalSliceCycle(sliceCycleBody);
-        findings.push({
-            section: "Vertical Slice Cycle Coverage",
-            required: true,
-            rule: "Vertical Slice Cycle must show RED -> GREEN -> REFACTOR monotonic progression per slice (refactor may be deferred with one-line rationale, e.g. `deferred because <reason>`).",
+            rule: "Vertical Slice Cycle: 06-tdd-slices.jsonl rows must show RED -> GREEN monotonic progression per slice; REFACTOR is satisfied by `refactor-done` (with refactorAt > greenAt) or `refactor-deferred` (with non-empty refactorRationale).",
             found: cycleResult.ok,
             details: cycleResult.details
         });
     }
+    else {
+        const sliceCycleBody = sectionBodyByName(sections, "Vertical Slice Cycle");
+        if (sliceCycleBody === null) {
+            findings.push({
+                section: "Vertical Slice Cycle Coverage",
+                required: true,
+                rule: "Vertical Slice Cycle must include RED, GREEN, and REFACTOR per slice (refactor may be deferred with rationale).",
+                found: false,
+                details: "No ## heading matching required section \"Vertical Slice Cycle\"."
+            });
+        }
+        else {
+            const cycleResult = parseVerticalSliceCycle(sliceCycleBody);
+            findings.push({
+                section: "Vertical Slice Cycle Coverage",
+                required: true,
+                rule: "Vertical Slice Cycle must show RED -> GREEN -> REFACTOR monotonic progression per slice (refactor may be deferred with one-line rationale, e.g. `deferred because <reason>`).",
+                found: cycleResult.ok,
+                details: cycleResult.details
+            });
+        }
+    }
+    if (!sidecarActive) {
+        // Advisory nudge: stage finished without ever migrating to the sidecar.
+        // Detect "filled markdown" by checking whether the Watched-RED Proof
+        // table or Vertical Slice Cycle has any populated rows.
+        const sliceCycleBodyAdvisory = sectionBodyByName(sections, "Vertical Slice Cycle");
+        const watchedRedBodyAdvisory = sectionBodyByName(sections, "Watched-RED Proof");
+        const markdownIsAuthored = hasPopulatedTableRows(watchedRedBodyAdvisory) ||
+            hasPopulatedTableRows(sliceCycleBodyAdvisory);
+        if (markdownIsAuthored) {
+            findings.push({
+                section: "tdd_slice_ledger_missing",
+                required: false,
+                rule: "When markdown TDD tables are filled, prefer recording slice events via `cclaw-cli internal tdd-slice-record` so 06-tdd-slices.jsonl becomes the source of truth.",
+                found: false,
+                details: "06-tdd-slices.jsonl is empty even though the markdown tables are populated. Migrate this stage's slices to the sidecar with `cclaw-cli internal tdd-slice-record --slice <id> --status <red|green|refactor-done|refactor-deferred> ...`."
+            });
+        }
+    }
     const assertionBody = sectionBodyByName(sections, "Assertion Correctness Notes");
     if (assertionBody !== null) {
         const tableRows = assertionBody.split("\n").filter((line) => /^\|/u.test(line));
@@ -207,6 +254,132 @@ export async function lintTddStage(ctx) {
         });
     }
 }
+/**
+ * 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.
+ */
+export function evaluateSidecarWatchedRed(rawEntries) {
+    if (rawEntries.length === 0) {
+        return {
+            ok: false,
+            details: "Sidecar 06-tdd-slices.jsonl is empty; record at least one slice via `cclaw-cli internal tdd-slice-record`."
+        };
+    }
+    const folded = foldTddSliceLedger(rawEntries);
+    const errors = [];
+    for (const entry of folded) {
+        const issues = [];
+        if (!entry.redObservedAt || entry.redObservedAt.trim().length === 0) {
+            issues.push("missing redObservedAt");
+        }
+        else if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/u.test(entry.redObservedAt)) {
+            issues.push("redObservedAt is not an ISO timestamp");
+        }
+        if (!entry.testFile || entry.testFile.length === 0) {
+            issues.push("missing testFile");
+        }
+        if (!entry.testCommand || entry.testCommand.length === 0) {
+            issues.push("missing testCommand");
+        }
+        if (!Array.isArray(entry.claimedPaths) || entry.claimedPaths.length === 0) {
+            issues.push("missing claimedPaths");
+        }
+        if (issues.length > 0) {
+            errors.push(`${entry.sliceId}: ${issues.join(", ")}`);
+        }
+    }
+    if (errors.length > 0) {
+        return {
+            ok: false,
+            details: `Sidecar slice rows missing RED evidence fields: ${errors.join(" | ")}.`
+        };
+    }
+    return {
+        ok: true,
+        details: `Sidecar 06-tdd-slices.jsonl has ${folded.length} slice row(s) with required RED evidence fields.`
+    };
+}
+/**
+ * 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.
+ */
+export function evaluateSidecarSliceCycle(rawEntries) {
+    if (rawEntries.length === 0) {
+        return {
+            ok: false,
+            details: "Sidecar 06-tdd-slices.jsonl is empty; the vertical slice cycle has no rows."
+        };
+    }
+    const folded = foldTddSliceLedger(rawEntries);
+    const errors = [];
+    for (const entry of folded) {
+        if (entry.greenAt) {
+            const redIso = parseTimestampCell(entry.redObservedAt ?? "");
+            const greenIso = parseTimestampCell(entry.greenAt);
+            if (greenIso === null) {
+                errors.push(`${entry.sliceId}: greenAt is not an ISO timestamp.`);
+                continue;
+            }
+            if (redIso !== null && greenIso < redIso) {
+                errors.push(`${entry.sliceId}: greenAt (${entry.greenAt}) precedes redObservedAt (${entry.redObservedAt}) — order must be monotonic.`);
+                continue;
+            }
+        }
+        if (entry.status === "refactor-deferred") {
+            if (!entry.refactorRationale || entry.refactorRationale.trim().length === 0) {
+                errors.push(`${entry.sliceId}: status=refactor-deferred requires a non-empty refactorRationale.`);
+                continue;
+            }
+        }
+        if (entry.status === "refactor-done") {
+            const greenIso = parseTimestampCell(entry.greenAt ?? "");
+            const refactorIso = parseTimestampCell(entry.refactorAt ?? "");
+            if (refactorIso === null) {
+                errors.push(`${entry.sliceId}: status=refactor-done requires a refactorAt ISO timestamp.`);
+                continue;
+            }
+            if (greenIso !== null && refactorIso < greenIso) {
+                errors.push(`${entry.sliceId}: refactorAt (${entry.refactorAt}) precedes greenAt (${entry.greenAt}) — order must be monotonic.`);
+                continue;
+            }
+        }
+    }
+    if (errors.length > 0) {
+        return { ok: false, details: errors.join(" ") };
+    }
+    return {
+        ok: true,
+        details: `${folded.length} sidecar slice row(s) show monotonic RED -> GREEN -> REFACTOR (deferred-with-rationale accepted).`
+    };
+}
+function hasPopulatedTableRows(body) {
+    if (body === null)
+        return false;
+    const tableLines = body.split("\n").filter((line) => /^\|/u.test(line));
+    if (tableLines.length < 3)
+        return false;
+    const dataRows = tableLines.slice(2);
+    for (const row of dataRows) {
+        const cells = row
+            .split("|")
+            .slice(1, -1)
+            .map((cell) => cell.trim());
+        // Skip cells that are entirely placeholder slice IDs (S-1 default).
+        const meaningful = cells.filter((cell, idx) => idx !== 0 && cell.length > 0);
+        if (meaningful.length > 0)
+            return true;
+    }
+    return false;
+}
 export function parseVerticalSliceCycle(body) {
     const tableLines = body.split("\n").filter((line) => /^\|/u.test(line));
     if (tableLines.length < 3) {

package/dist/artifact-linter.js

@@ -1,9 +1,11 @@
 import fs from "node:fs/promises";
+import path from "node:path";
 import { resolveArtifactPath as resolveStageArtifactPath } from "./artifact-paths.js";
 import { exists } from "./fs-utils.js";
 import { stageSchema } from "./content/stage-schema.js";
 import { readFlowState } from "./run-persistence.js";
-import { duplicateH2Headings, extractH2Sections, extractRequirementIdsFromMarkdown, isShortCircuitActivated, normalizeHeadingTitle, parseFrontmatter, parseLearningsSection, sectionBodyByAnyName, sectionBodyByHeadingPrefix, sectionBodyByName, validateSectionBody, formatLearningsErrorsBullets } from "./artifact-linter/shared.js";
+import { duplicateH2Headings, extractEvidencePointers, extractH2Sections, extractRequirementIdsFromMarkdown, isShortCircuitActivated, normalizeHeadingTitle, parseFrontmatter, parseLearningsSection, sectionBodyByAnyName, sectionBodyByHeadingPrefix, sectionBodyByName, validateSectionBody, formatLearningsErrorsBullets } from "./artifact-linter/shared.js";
+import { foldTddSliceLedger, readTddSliceLedger } from "./tdd-slices.js";
 import { shouldDemoteArtifactValidationByTrack } from "./content/stage-schema.js";
 import { readDelegationLedger, recordArtifactValidationDemotedByTrack } from "./delegation.js";
 import { classifyAndPersistFindings } from "./artifact-linter/findings-dedup.js";
@@ -145,6 +147,17 @@ export async function lintArtifact(projectRoot, stage, track = "standard", optio
         }
     }
     const liteTierForValidators = shouldDemoteArtifactValidationByTrack(track, taskClass);
+    // v6.10.0 (T3) — pre-resolve RED/GREEN Evidence pointers and sidecar
+    // auto-satisfy state once for the whole TDD loop, then thread the
+    // booleans through `validateSectionBody`. We do the async resolution
+    // here (path existence + delegation spanId match) so the validators
+    // themselves stay sync.
+    const tddEvidenceContext = stage === "tdd"
+        ? await resolveTddEvidencePointerContext({
+            projectRoot,
+            sections
+        })
+        : { red: {}, green: {} };
     for (const v of schema.artifactValidation) {
         const sectionKey = normalizeHeadingTitle(v.section).toLowerCase();
         const scopeBoundaryAlias = stage === "scope" && sectionKey === "in scope / out of scope";
@@ -164,7 +177,8 @@ export async function lintArtifact(projectRoot, stage, track = "standard", optio
             ? { ok: false, details: `No ## heading matching required section "${v.section}".` }
             : validateSectionBody(body, v.validationRule, v.section, {
                 sections,
-                liteTier: liteTierForValidators
+                liteTier: liteTierForValidators,
+                tddEvidence: stage === "tdd" ? tddEvidenceContext : undefined
             });
         const found = hasHeading && validation.ok;
         findings.push({
@@ -420,3 +434,74 @@ const ARTIFACT_VALIDATION_LITE_DEMOTE_SECTIONS = new Set([
     "Stale Diagram Drift Check",
     "Product Discovery Delegation (Strategist Mode)"
 ]);
+/**
+ * v6.10.0 (T3) — pre-resolve `Evidence:` pointers and sidecar
+ * auto-satisfy state for the TDD stage's RED/GREEN Evidence rows so
+ * `validateSectionBody` (sync) can short-circuit. A pointer of the form
+ * `<path>` is satisfied when the path exists on disk relative to the
+ * project root; `spanId:<id>` is satisfied when any delegation ledger
+ * row carries that span id. Sidecar auto-satisfy fires when
+ * `06-tdd-slices.jsonl` carries at least one slice with a non-empty
+ * `redOutputRef` / `greenOutputRef`.
+ */
+async function resolveTddEvidencePointerContext(input) {
+    const { projectRoot, sections } = input;
+    const redSection = sectionBodyByName(sections, "RED Evidence") ?? "";
+    const greenSection = sectionBodyByName(sections, "GREEN Evidence") ?? "";
+    const redPointers = extractEvidencePointers(redSection);
+    const greenPointers = extractEvidencePointers(greenSection);
+    let knownSpanIds = new Set();
+    if (redPointers.length > 0 || greenPointers.length > 0) {
+        try {
+            const ledger = await readDelegationLedger(projectRoot);
+            knownSpanIds = new Set(ledger.entries
+                .map((entry) => entry.spanId)
+                .filter((id) => typeof id === "string" && id.length > 0));
+        }
+        catch {
+            knownSpanIds = new Set();
+        }
+    }
+    async function pointerResolves(value) {
+        const trimmed = value.replace(/[`*_]/gu, "").trim();
+        if (trimmed.length === 0)
+            return false;
+        if (/^spanid\s*:/iu.test(trimmed)) {
+            const id = trimmed.replace(/^spanid\s*:\s*/iu, "").trim();
+            return id.length > 0 && knownSpanIds.has(id);
+        }
+        const candidate = path.isAbsolute(trimmed) ? trimmed : path.join(projectRoot, trimmed);
+        return exists(candidate);
+    }
+    async function anyResolved(values) {
+        for (const value of values) {
+            if (await pointerResolves(value))
+                return true;
+        }
+        return false;
+    }
+    let redSidecarAutoSatisfy = false;
+    let greenSidecarAutoSatisfy = false;
+    try {
+        const sidecar = await readTddSliceLedger(projectRoot);
+        if (sidecar.entries.length > 0) {
+            const folded = foldTddSliceLedger(sidecar.entries);
+            redSidecarAutoSatisfy = folded.some((entry) => typeof entry.redOutputRef === "string" && entry.redOutputRef.length > 0);
+            greenSidecarAutoSatisfy = folded.some((entry) => typeof entry.greenOutputRef === "string" && entry.greenOutputRef.length > 0);
+        }
+    }
+    catch {
+        redSidecarAutoSatisfy = false;
+        greenSidecarAutoSatisfy = false;
+    }
+    return {
+        red: {
+            pointerSatisfied: await anyResolved(redPointers),
+            sidecarAutoSatisfy: redSidecarAutoSatisfy
+        },
+        green: {
+            pointerSatisfied: await anyResolved(greenPointers),
+            sidecarAutoSatisfy: greenSidecarAutoSatisfy
+        }
+    };
+}

package/dist/content/examples.js

@@ -36,10 +36,10 @@ export const BEHAVIOR_ANCHORS = [
     },
     {
         stage: "tdd",
-        section: "RED Evidence",
-        bad: "RED: `expect(true).toBe(true)` then \"failing test observed\" — the assertion can never have caught the bug it claims to prove.",
-        good: "RED: `expect(api.fetchFeed()).rejects.toThrow(AuthError)`; the failure output names the missing guard and ties to AC-3.",
-        ruleHint: "Mental mutation test: name a plausible bug that would still pass the assertion. If you can, the assertion is too coarse."
+        section: "Watched-RED Proof",
+        bad: "Hand-edit `S-1 | 2026-04-15T10:00 | observed RED` into the markdown table; nothing lands in the JSONL sidecar, so retries silently overwrite the row.",
+        good: "Run `cclaw-cli internal tdd-slice-record --slice S-1 --status red --test-file tests/feed.spec.ts --command \"npm test\" --paths src/api/feed.ts --ac AC-3`; the linter reads the sidecar.",
+        ruleHint: "RED/GREEN/REFACTOR transitions are recorded by `cclaw-cli internal tdd-slice-record`; the markdown tables are an auto-derived view from v6.10.0 onward."
     },
     {
         stage: "review",
@@ -247,12 +247,12 @@ Plan is ready to execute after user confirmation.
 | S-1 feed window | expected 30d window, got 7d |
 | S-2 degraded banner | banner absent after forced disconnect |
 
-## Acceptance Mapping
+## Acceptance & Failure Map
 
-| Slice | AC IDs |
-| --- | --- |
-| S-1 | AC-1 |
-| S-2 | AC-3 |
+| Slice | Source ID | AC ID | Expected behavior | RED-link |
+| --- | --- | --- | --- | --- |
+| S-1 | SRC-1 | AC-1 | feed window honors 30d cap | spanId:tdd-feed-window-red |
+| S-2 | SRC-2 | AC-3 | degraded banner appears on disconnect | .cclaw/artifacts/06-tdd-slices.jsonl |
 
 ## GREEN