cclaw-cli 6.9.0 → 6.11.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,49 @@ 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;
+    /**
+     * 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.
+     */
+    phaseEventsSatisfied?: 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 +581,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.phaseEventsSatisfied) {
+        return {
+            ok: true,
+            details: "RED Evidence auto-satisfied: delegation-events.jsonl carries a phase=red row with non-empty evidenceRefs for the active run."
+        };
+    }
+    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.phaseEventsSatisfied) {
+        return {
+            ok: true,
+            details: "GREEN Evidence auto-satisfied: delegation-events.jsonl carries a phase=green row with non-empty evidenceRefs for the active run."
+        };
+    }
+    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,13 +1,54 @@
-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;
 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 {};