cclaw-cli 6.8.0 → 6.10.0

package/dist/artifact-linter/design.js

@@ -424,7 +424,7 @@ export async function lintDesignStage(ctx) {
     if (layeredDocumentReview !== null) {
         findings.push({
             section: "Document Reviewer Structured Findings",
-            required: false,
+            required: true,
             rule: "When Layered review references coherence-reviewer/scope-guardian-reviewer/feasibility-reviewer, include explicit reviewer status plus calibrated finding lines.",
             found: layeredDocumentReview.missingStructured.length === 0,
             details: layeredDocumentReview.missingStructured.length === 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 {
@@ -1881,7 +1929,8 @@ export function checkInvestigationTrace(sectionBody) {
  */
 export function evaluateInvestigationTrace(ctx, sectionName) {
     const body = sectionBodyByName(ctx.sections, sectionName);
-    const result = checkInvestigationTrace(body);
+    const authoredBody = body === null ? null : extractAuthoredBody(body);
+    const result = checkInvestigationTrace(authoredBody);
     if (result === null)
         return;
     ctx.findings.push({
@@ -2057,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,2 +1,33 @@
+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;
+    details: string;
+}
+export declare function evaluateVerificationLadder(body: string | null): VerificationLadderResult;
+export {};

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,28 +80,55 @@ 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\"."
+            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 required = ["RED", "GREEN", "REFACTOR"];
-        const missing = required.filter((token) => !new RegExp(token, "u").test(sliceCycleBody));
-        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: missing.length === 0,
-            details: missing.length === 0
-                ? "Vertical Slice Cycle references RED/GREEN/REFACTOR."
-                : `Vertical Slice Cycle is missing phase token(s): ${missing.join(", ")}.`
-        });
+        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) {
@@ -196,4 +240,300 @@ export async function lintTddStage(ctx) {
                     : "integration-overseer completion exists, but PASS/PASS_WITH_GAPS evidence is missing in delegation evidenceRefs and artifact text."
         });
     }
+    {
+        const verificationBody = sectionBodyByName(sections, "Verification Ladder") ??
+            sectionBodyByName(sections, "Verification Status") ??
+            sectionBodyByName(sections, "Verification");
+        const ladderResult = evaluateVerificationLadder(verificationBody);
+        findings.push({
+            section: "tdd_verification_pending",
+            required: true,
+            rule: "Verification Ladder rows must not remain `pending`; promote each row to `passed`, `n/a`, `failed`, `skipped`, or `deferred` (with rationale) before stage-complete.",
+            found: ladderResult.ok,
+            details: ladderResult.details
+        });
+    }
+}
+/**
+ * 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) {
+        return {
+            ok: false,
+            details: "Vertical Slice Cycle table must have a header, separator, and at least one slice row."
+        };
+    }
+    const headerCells = splitMarkdownRow(tableLines[0]).map((cell) => cell.toLowerCase());
+    const findIdx = (token) => headerCells.findIndex((cell) => cell.includes(token));
+    const sliceIdx = findIdx("slice");
+    const redIdx = findIdx("red");
+    const greenIdx = findIdx("green");
+    const refactorIdx = findIdx("refactor");
+    if (sliceIdx < 0 || redIdx < 0 || greenIdx < 0 || refactorIdx < 0) {
+        return {
+            ok: false,
+            details: "Vertical Slice Cycle header must include Slice, RED, GREEN, and REFACTOR columns."
+        };
+    }
+    const dataRows = tableLines.slice(2);
+    const populated = dataRows.filter((row) => splitMarkdownRow(row).some((cell) => cell.length > 0));
+    if (populated.length === 0) {
+        return {
+            ok: false,
+            details: "Vertical Slice Cycle has no populated slice rows."
+        };
+    }
+    const errors = [];
+    for (const row of populated) {
+        const cells = splitMarkdownRow(row);
+        const slice = cells[sliceIdx] ?? "";
+        const red = cells[redIdx] ?? "";
+        const green = cells[greenIdx] ?? "";
+        const refactor = cells[refactorIdx] ?? "";
+        const label = slice.length > 0 ? slice : `row ${populated.indexOf(row) + 1}`;
+        const redTs = parseTimestampCell(red);
+        const greenTs = parseTimestampCell(green);
+        if (red.length === 0) {
+            errors.push(`${label}: RED ts is empty.`);
+            continue;
+        }
+        if (green.length === 0) {
+            errors.push(`${label}: GREEN ts is empty.`);
+            continue;
+        }
+        if (redTs === null) {
+            errors.push(`${label}: RED ts \`${red}\` is not an ISO timestamp.`);
+            continue;
+        }
+        if (greenTs === null) {
+            errors.push(`${label}: GREEN ts \`${green}\` is not an ISO timestamp.`);
+            continue;
+        }
+        if (greenTs < redTs) {
+            errors.push(`${label}: GREEN (${green}) precedes RED (${red}) — order must be monotonic.`);
+            continue;
+        }
+        if (refactor.length === 0) {
+            errors.push(`${label}: REFACTOR cell is empty; provide a timestamp or \`deferred because <reason>\`.`);
+            continue;
+        }
+        if (isDeferredOrNotNeeded(refactor)) {
+            const rationale = extractDeferRationale(refactor);
+            if (rationale.length === 0) {
+                errors.push(`${label}: REFACTOR marked deferred/not-needed but rationale is missing — use \`deferred because <reason>\` or \`not needed because <reason>\`.`);
+            }
+            continue;
+        }
+        const refactorTs = parseTimestampCell(refactor);
+        if (refactorTs === null) {
+            errors.push(`${label}: REFACTOR cell \`${refactor}\` is not an ISO timestamp and not marked deferred/not-needed with rationale.`);
+            continue;
+        }
+        if (refactorTs < greenTs) {
+            errors.push(`${label}: REFACTOR (${refactor}) precedes GREEN (${green}) — order must be monotonic.`);
+            continue;
+        }
+    }
+    if (errors.length > 0) {
+        return { ok: false, details: errors.join(" ") };
+    }
+    return {
+        ok: true,
+        details: `${populated.length} slice row(s) show monotonic RED -> GREEN -> REFACTOR (deferred-with-rationale accepted).`
+    };
+}
+function splitMarkdownRow(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("|"))
+        return [];
+    const inner = trimmed.replace(/^\|/u, "").replace(/\|$/u, "");
+    return inner.split("|").map((cell) => cell.trim());
+}
+function parseTimestampCell(cell) {
+    const trimmed = cell.replace(/^[`*_\s]+|[`*_\s]+$/gu, "");
+    if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/u.test(trimmed))
+        return null;
+    const t = Date.parse(trimmed);
+    return Number.isFinite(t) ? t : null;
+}
+function isDeferredOrNotNeeded(cell) {
+    return /\b(deferred|not[\s-]?needed|n\/?a|skipped)\b/iu.test(cell);
+}
+function extractDeferRationale(cell) {
+    const cleaned = cell.replace(/`/gu, "").trim();
+    const match = /(?:deferred|not[\s-]?needed|skipped)\s+(?:because|since|due to|—|-)\s*(.+)/iu.exec(cleaned);
+    if (match !== null && match[1] !== undefined && match[1].trim().length > 0) {
+        return match[1].trim();
+    }
+    // Accept any free-form rationale text following the deferral marker.
+    const fallback = cleaned.replace(/^\s*(deferred|not[\s-]?needed|skipped|n\/?a)\b[:\s-]*/iu, "").trim();
+    return fallback;
+}
+export function evaluateVerificationLadder(body) {
+    if (body === null) {
+        return {
+            ok: true,
+            details: "No Verification Ladder section present; rule advisory."
+        };
+    }
+    const tableLines = body.split("\n").filter((line) => /^\|/u.test(line));
+    if (tableLines.length < 3) {
+        return {
+            ok: true,
+            details: "Verification Ladder section has no table rows; rule advisory."
+        };
+    }
+    const dataRows = tableLines.slice(2);
+    const pendingRows = [];
+    for (const row of dataRows) {
+        const cells = splitMarkdownRow(row);
+        if (cells.length === 0)
+            continue;
+        if (cells.every((cell) => cell.length === 0))
+            continue;
+        const cellsLower = cells.map((cell) => cell.toLowerCase().replace(/`/gu, "").trim());
+        const hasPending = cellsLower.some((cell) => /\bpending\b/u.test(cell));
+        if (hasPending) {
+            const label = cells[0] !== undefined && cells[0].length > 0
+                ? cells[0]
+                : `row ${dataRows.indexOf(row) + 1}`;
+            pendingRows.push(label);
+        }
+    }
+    if (pendingRows.length === 0) {
+        return {
+            ok: true,
+            details: "Verification Ladder has no rows still marked `pending`."
+        };
+    }
+    return {
+        ok: false,
+        details: `Verification Ladder has ${pendingRows.length} row(s) still marked \`pending\`: ${pendingRows.join(", ")}. ` +
+            "Promote each to `passed`, `n/a`, `failed`, `skipped`, or `deferred` (with rationale) before stage-complete."
+    };
 }