cclaw-cli 7.7.1 → 8.1.1

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

@@ -1,2 +0,0 @@
-import { type StageLintContext } from "./shared.js";
-export declare function lintShipStage(ctx: StageLintContext): Promise<void>;

package/dist/artifact-linter/ship.js

@@ -1,250 +0,0 @@
-import { execFile } from "node:child_process";
-import fs from "node:fs/promises";
-import path from "node:path";
-import { promisify } from "node:util";
-import { readDelegationLedger } from "../delegation.js";
-import { resolveArtifactPath as resolveStageArtifactPath } from "../artifact-paths.js";
-import { exists } from "../fs-utils.js";
-import { extractAcceptanceCriterionIdsFromMarkdown, extractH2Sections, sectionBodyByName } from "./shared.js";
-import { readFlowState } from "../run-persistence.js";
-const execFileAsync = promisify(execFile);
-function extractSliceCardClosedAcceptanceCriteria(content) {
-    const ids = new Set();
-    for (const match of content.matchAll(/^\s*(?:[-*]\s*)?closes\s*:\s*(.+)$/gimu)) {
-        const tail = match[1] ?? "";
-        for (const id of extractAcceptanceCriterionIdsFromMarkdown(tail)) {
-            ids.add(id);
-        }
-    }
-    return [...ids];
-}
-function escapeForRegex(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-}
-function entryTimestamp(entry) {
-    return entry.startTs ?? entry.ts ?? entry.launchedTs ?? entry.ackTs ?? entry.completedTs ?? entry.endTs ?? "";
-}
-async function readSpecAcceptanceCriteriaIds(projectRoot, track) {
-    const specArtifact = await resolveStageArtifactPath("spec", {
-        projectRoot,
-        track,
-        intent: "read"
-    });
-    if (!(await exists(specArtifact.absPath))) {
-        return [];
-    }
-    try {
-        const specRaw = await fs.readFile(specArtifact.absPath, "utf8");
-        const sections = extractH2Sections(specRaw);
-        const acceptanceBody = sectionBodyByName(sections, "Acceptance Criteria") ?? specRaw;
-        return extractAcceptanceCriterionIdsFromMarkdown(acceptanceBody);
-    }
-    catch {
-        return [];
-    }
-}
-async function collectAcceptanceSlicesMap(tddSlicesDir) {
-    const map = new Map();
-    let names = [];
-    try {
-        names = await fs.readdir(tddSlicesDir);
-    }
-    catch {
-        return map;
-    }
-    for (const name of names) {
-        const match = /^(S-[A-Za-z0-9._-]+)\.md$/u.exec(name);
-        if (!match)
-            continue;
-        const sliceId = match[1];
-        let content = "";
-        try {
-            content = await fs.readFile(path.join(tddSlicesDir, name), "utf8");
-        }
-        catch {
-            continue;
-        }
-        const acIds = extractSliceCardClosedAcceptanceCriteria(content);
-        for (const acId of acIds) {
-            const set = map.get(acId) ?? new Set();
-            set.add(sliceId);
-            map.set(acId, set);
-        }
-    }
-    return map;
-}
-async function sliceHasManagedCommit(projectRoot, sliceId, sinceTs) {
-    const grepPattern = `^${escapeForRegex(sliceId)}/`;
-    const args = ["log", "--extended-regexp", "--grep", grepPattern, "--pretty=%H"];
-    if (sinceTs && sinceTs.length > 0) {
-        args.push(`--since=${sinceTs}`);
-    }
-    try {
-        const { stdout } = await execFileAsync("git", args, { cwd: projectRoot });
-        return stdout.trim().length > 0;
-    }
-    catch {
-        return false;
-    }
-}
-async function resolveActiveRunStartTs(projectRoot, runId) {
-    const ledger = await readDelegationLedger(projectRoot).catch(() => null);
-    const runRows = ledger
-        ? ledger.entries.filter((entry) => entry.runId === runId)
-        : [];
-    const stamps = runRows
-        .map((entry) => entryTimestamp(entry))
-        .filter((value) => typeof value === "string" && value.length > 0)
-        .sort();
-    if (stamps.length > 0) {
-        return stamps[0];
-    }
-    try {
-        const state = await readFlowState(projectRoot);
-        if (state.activeRunId === runId) {
-            const completed = Object.values(state.completedStageMeta ?? {})
-                .map((meta) => meta?.completedAt)
-                .filter((value) => typeof value === "string" && value.length > 0)
-                .sort();
-            if (completed.length > 0) {
-                return completed[0];
-            }
-        }
-    }
-    catch {
-        // no-op fallback
-    }
-    return null;
-}
-export async function lintShipStage(ctx) {
-    const { projectRoot, track, raw, absFile, sections, findings, parsedFrontmatter, brainstormShortCircuitBody, brainstormShortCircuitActivated, staleDiagramAuditEnabled, isTrivialOverride } = ctx;
-    // Universal Layer 2.8 structural checks (superpowers finishing-a-development-branch).
-    const optionsBody = sectionBodyByName(sections, "Finalization Options");
-    if (optionsBody !== null) {
-        const required = ["MERGE_LOCAL", "OPEN_PR", "KEEP_BRANCH", "DISCARD"];
-        const missing = required.filter((token) => !optionsBody.includes(token));
-        findings.push({
-            section: "Finalization Options Coverage",
-            required: true,
-            rule: "Finalization Options must surface all four canonical options (MERGE_LOCAL, OPEN_PR, KEEP_BRANCH, DISCARD).",
-            found: missing.length === 0,
-            details: missing.length === 0
-                ? "All four finalization options surfaced."
-                : `Finalization Options is missing token(s): ${missing.join(", ")}.`
-        });
-    }
-    const prBody = sectionBodyByName(sections, "Structured PR Body");
-    if (prBody !== null) {
-        const required = ["## Summary", "## Test Plan", "## Commits Included"];
-        const missing = required.filter((token) => !prBody.includes(token));
-        findings.push({
-            section: "Structured PR Body Shape",
-            required: true,
-            rule: "Structured PR Body must include `## Summary`, `## Test Plan`, and `## Commits Included` subsections.",
-            found: missing.length === 0,
-            details: missing.length === 0
-                ? "Structured PR Body covers all required subsections."
-                : `Structured PR Body is missing subsection(s): ${missing.join(", ")}.`
-        });
-    }
-    const verifyBody = sectionBodyByName(sections, "Verify Tests Gate");
-    if (verifyBody !== null) {
-        const ok = /\bResult:\s*(PASS|FAIL)\b/iu.test(verifyBody);
-        findings.push({
-            section: "Verify Tests Gate Result",
-            required: true,
-            rule: "Verify Tests Gate must declare a Result of PASS or FAIL.",
-            found: ok,
-            details: ok
-                ? "Verify Tests Gate result declared."
-                : "Verify Tests Gate is missing a `Result: PASS|FAIL` line."
-        });
-    }
-    const delegationLedger = await readDelegationLedger(projectRoot);
-    const activeRunRows = delegationLedger.entries.filter((entry) => entry.stage === "ship" &&
-        entry.runId === delegationLedger.runId &&
-        entry.agent === "architect" &&
-        entry.status === "completed");
-    const hasCrossStageReferenceInArtifact = /\barchitect-cross-stage-verification\b/iu.test(raw) ||
-        /\barchitect\b[\s\S]{0,180}\bcross[-\s]?stage\b/iu.test(raw) ||
-        /\bCROSS_STAGE_VERIFIED\b/u.test(raw) ||
-        /\bDRIFT_DETECTED\b/u.test(raw);
-    findings.push({
-        section: "ship.cross_stage_cohesion_missing",
-        required: true,
-        rule: "Ship artifact must include architect cross-stage verification reference (`architect-cross-stage-verification` / CROSS_STAGE_VERIFIED / DRIFT_DETECTED) before finalization.",
-        found: hasCrossStageReferenceInArtifact,
-        details: hasCrossStageReferenceInArtifact
-            ? "Architect cross-stage verification reference is present in ship artifact."
-            : activeRunRows.length > 0
-                ? "Completed architect delegation exists in ledger, but ship artifact is missing explicit cross-stage verification reference."
-                : "Ship artifact is missing architect cross-stage verification reference."
-    });
-    const driftDetectedInArtifact = /\bDRIFT_DETECTED\b/u.test(raw);
-    const driftDetectedInDelegation = activeRunRows.some((row) => {
-        const refs = Array.isArray(row.evidenceRefs) ? row.evidenceRefs.join(" ") : "";
-        return /\bDRIFT_DETECTED\b/u.test(refs);
-    });
-    const driftDetected = driftDetectedInArtifact || driftDetectedInDelegation;
-    findings.push({
-        section: "ship.cross_stage_drift_detected",
-        required: true,
-        rule: "If architect cross-stage verification reports DRIFT_DETECTED, ship must be blocked until drift is resolved or explicitly waived.",
-        found: !driftDetected,
-        details: driftDetected
-            ? "Architect cross-stage verification reported DRIFT_DETECTED; ship must not proceed."
-            : "No DRIFT_DETECTED signal found in ship artifact or architect delegation evidence."
-    });
-    const specAcceptanceIds = await readSpecAcceptanceCriteriaIds(projectRoot, track);
-    const tddSlicesDir = path.join(path.dirname(absFile), "tdd-slices");
-    const acceptanceSlices = await collectAcceptanceSlicesMap(tddSlicesDir);
-    const gitPresent = await exists(path.join(projectRoot, ".git"));
-    const runStartTs = gitPresent
-        ? await resolveActiveRunStartTs(projectRoot, delegationLedger.runId)
-        : null;
-    const uncoveredCriteria = [];
-    if (specAcceptanceIds.length > 0 && gitPresent && runStartTs !== null) {
-        for (const acId of specAcceptanceIds) {
-            const slices = [...(acceptanceSlices.get(acId) ?? new Set())];
-            let covered = false;
-            if (slices.length > 0) {
-                for (const sliceId of slices) {
-                    if (await sliceHasManagedCommit(projectRoot, sliceId, runStartTs)) {
-                        covered = true;
-                        break;
-                    }
-                }
-            }
-            if (!covered) {
-                const reason = slices.length === 0
-                    ? `${acId} has no \`Closes: ${acId}\` slice mapping`
-                    : `${acId} mapped slices ${slices.join(", ")} have no managed commit since run start`;
-                uncoveredCriteria.push(reason);
-                findings.push({
-                    section: `acceptance_criterion_${acId}_uncovered`,
-                    required: true,
-                    rule: "Every acceptance criterion must map to at least one slice card and at least one managed slice commit.",
-                    found: false,
-                    details: reason
-                });
-            }
-        }
-    }
-    const allAcceptanceCovered = specAcceptanceIds.length === 0 ||
-        ((!gitPresent || runStartTs !== null) && uncoveredCriteria.length === 0);
-    findings.push({
-        section: "ship_all_acceptance_criteria_have_commits",
-        required: true,
-        rule: "For every spec AC-N, at least one `tdd-slices/S-*.md` card must declare `Closes: AC-N` and at least one managed slice commit (`^S-<id>/`) must exist since run start.",
-        found: allAcceptanceCovered,
-        details: specAcceptanceIds.length === 0
-            ? "Spec acceptance criteria list is empty or unreadable; AC commit coverage check is idle."
-            : !gitPresent
-                ? "No .git directory detected; AC-to-commit coverage check is skipped for no-VCS mode."
-                : runStartTs === null
-                    ? "Unable to resolve active run start timestamp from delegation ledger/flow-state."
-                    : uncoveredCriteria.length > 0
-                        ? `Uncovered acceptance criteria: ${uncoveredCriteria.join(" | ")}.`
-                        : `All ${specAcceptanceIds.length} acceptance criteria map to slice cards and managed commits since ${runStartTs}.`
-    });
-}

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

@@ -1,2 +0,0 @@
-import { type StageLintContext } from "./shared.js";
-export declare function lintSpecStage(ctx: StageLintContext): Promise<void>;

package/dist/artifact-linter/spec.js

@@ -1,176 +0,0 @@
-import { getMarkdownTableRows, evaluateLayeredDocumentReviewStatus, extractAcceptanceCriterionIdsFromMarkdown, sectionBodyByName, SPEC_MAX_MODULES } from "./shared.js";
-import { CONFIDENCE_FINDING_REGEX_SOURCE } from "../content/skills.js";
-export async function lintSpecStage(ctx) {
-    const { projectRoot, track, raw, absFile, sections, findings, parsedFrontmatter, brainstormShortCircuitBody, brainstormShortCircuitActivated, staleDiagramAuditEnabled, isTrivialOverride } = ctx;
-    // Universal Layer 2.4 structural checks (evanflow-prd + superpowers).
-    // All checks fire only when the matching section is present so legacy
-    // fixtures keep working while v3-template artifacts are validated.
-    const synthesisBody = sectionBodyByName(sections, "Synthesis Sources");
-    if (synthesisBody !== null) {
-        const tableRows = synthesisBody
-            .split("\n")
-            .filter((line) => /^\|/u.test(line));
-        const dataRows = tableRows.length >= 3 ? tableRows.slice(2) : [];
-        const populatedRows = dataRows.filter((row) => row
-            .split("|")
-            .slice(1, -1)
-            .some((cell) => cell.trim().length > 0));
-        const hasRow = populatedRows.length >= 1;
-        findings.push({
-            section: "Synthesis Sources Coverage",
-            required: true,
-            rule: "Synthesis Sources must cite at least one source artifact (synthesize-not-interview).",
-            found: hasRow,
-            details: hasRow
-                ? `Detected ${populatedRows.length} populated source row(s).`
-                : "Synthesis Sources is empty; spec must cite at least one upstream artifact or context file."
-        });
-    }
-    const behaviorBody = sectionBodyByName(sections, "Behavior Contract");
-    if (behaviorBody !== null) {
-        const optedOut = /(^|\n)\s*-\s*None\b/iu.test(behaviorBody);
-        const userStoryRegex = /(^|\n)\s*-\s*as\s+a\b[\s\S]*?,\s*i\s+can\b[\s\S]*?,\s*so that\b/imu;
-        const givenWhenThenRegex = /(^|\n)\s*-\s*given\b[\s\S]*?,\s*when\b[\s\S]*?,\s*then\b/imu;
-        const matches = [
-            ...behaviorBody.matchAll(/(^|\n)\s*-\s*as\s+a\b[\s\S]*?,\s*i\s+can\b[\s\S]*?,\s*so that\b/gimu),
-            ...behaviorBody.matchAll(/(^|\n)\s*-\s*given\b[\s\S]*?,\s*when\b[\s\S]*?,\s*then\b/gimu)
-        ];
-        const ok = optedOut || matches.length >= 3;
-        findings.push({
-            section: "Behavior Contract Shape",
-            required: true,
-            rule: "Behavior Contract must list ≥3 behaviors in user-story (As a/I can/so that) or Given/When/Then form, or declare `- None.` for single-step specs.",
-            found: ok,
-            details: optedOut
-                ? "Single-step spec; behaviors opted out via `- None.`."
-                : ok
-                    ? `Detected ${matches.length} behavior(s) in canonical form.`
-                    : `Detected ${matches.length} behavior(s) in canonical form; need ≥3 (or `
-                        + "`- None.`).",
-        });
-        // Bonus: detect if at least one user-story OR given/when/then form is present
-        // (mirrors existing helpers).
-        void userStoryRegex;
-        void givenWhenThenRegex;
-    }
-    const archModulesBody = sectionBodyByName(sections, "Architecture Modules");
-    if (archModulesBody !== null) {
-        const codeFenceCount = (archModulesBody.match(/```/gu) ?? []).length;
-        const fnSignatureRegex = /\b(function|class|def|fn|method)\b\s+[A-Za-z_]/u;
-        const noCode = codeFenceCount === 0 && !fnSignatureRegex.test(archModulesBody);
-        findings.push({
-            section: "Architecture Modules No-Code",
-            required: true,
-            rule: "Architecture Modules must not contain code blocks, function signatures, or class definitions — modules listed by responsibility only.",
-            found: noCode,
-            details: noCode
-                ? "Architecture Modules is free of code blocks and function/class signatures."
-                : "Architecture Modules contains a code fence or function/class signature; remove code-level details."
-        });
-        const tableRows = archModulesBody.split("\n").filter((line) => /^\|/u.test(line));
-        const dataRows = tableRows.length >= 3 ? tableRows.slice(2) : [];
-        const moduleNames = dataRows
-            .map((row) => row.split("|").slice(1, -1)[0]?.trim() ?? "")
-            .filter((name) => name.length > 0 && name !== "-" && !/^module$/iu.test(name));
-        const uniqueModuleCount = new Set(moduleNames).size;
-        findings.push({
-            section: "Single-Subsystem Scope",
-            required: false,
-            rule: `Architecture Modules should stay within one coherent subsystem boundary (<= ${SPEC_MAX_MODULES} named modules).`,
-            found: uniqueModuleCount <= SPEC_MAX_MODULES,
-            details: uniqueModuleCount <= SPEC_MAX_MODULES
-                ? `Module count (${uniqueModuleCount}) stays within single-subsystem guidance.`
-                : `Architecture Modules lists ${uniqueModuleCount} modules (> ${SPEC_MAX_MODULES}); split into sub-specs or narrow scope before plan handoff.`
-        });
-    }
-    const selfReviewBody = sectionBodyByName(sections, "Spec Self-Review");
-    if (selfReviewBody === null) {
-        findings.push({
-            section: "Spec Self-Review Coverage",
-            required: true,
-            rule: "Spec Self-Review must cover placeholder/consistency/scope/ambiguity checks.",
-            found: false,
-            details: "No ## heading matching required section \"Spec Self-Review\"."
-        });
-    }
-    else {
-        const required = ["placeholder", "consistency", "scope", "ambiguity"];
-        const missing = required.filter((token) => !new RegExp(token, "iu").test(selfReviewBody));
-        findings.push({
-            section: "Spec Self-Review Coverage",
-            required: true,
-            rule: "Spec Self-Review must cover placeholder/consistency/scope/ambiguity checks.",
-            found: missing.length === 0,
-            details: missing.length === 0
-                ? "Spec Self-Review covers all required checks."
-                : `Spec Self-Review is missing check(s): ${missing.join(", ")}.`
-        });
-    }
-    const layeredDocumentReview = evaluateLayeredDocumentReviewStatus(sections, CONFIDENCE_FINDING_REGEX_SOURCE);
-    if (layeredDocumentReview !== null) {
-        findings.push({
-            section: "Document Reviewer Structured Findings",
-            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
-                ? `Structured findings present for reviewers: ${layeredDocumentReview.triggeredReviewers.join(", ")}.`
-                : `Missing status or calibrated findings for: ${layeredDocumentReview.missingStructured.join(", ")}.`
-        });
-        findings.push({
-            section: "document-review.fail_without_waiver",
-            required: true,
-            rule: "[P1] document-review.fail_without_waiver — reviewer FAIL/PARTIAL requires fix evidence or explicit waiver.",
-            found: layeredDocumentReview.failOrPartialWithoutWaiver.length === 0,
-            details: layeredDocumentReview.failOrPartialWithoutWaiver.length === 0
-                ? "No unwaived FAIL/PARTIAL reviewer statuses detected."
-                : `Unwaived FAIL/PARTIAL statuses: ${layeredDocumentReview.failOrPartialWithoutWaiver.join(", ")}.`
-        });
-    }
-    const acceptanceCriteriaBody = sectionBodyByName(sections, "Acceptance Criteria");
-    if (acceptanceCriteriaBody === null) {
-        findings.push({
-            section: "spec_ac_ids_present",
-            required: true,
-            rule: "Acceptance Criteria must assign stable IDs in `AC-N` format for every criterion row.",
-            found: false,
-            details: "No ## heading matching required section \"Acceptance Criteria\"."
-        });
-    }
-    else {
-        const tableRows = getMarkdownTableRows(acceptanceCriteriaBody);
-        const bulletRows = acceptanceCriteriaBody
-            .split("\n")
-            .map((line) => line.trim())
-            .filter((line) => /^[-*]\s+/u.test(line));
-        const candidateRows = tableRows.length > 0
-            ? tableRows.map((row) => row.join(" | ").trim()).filter((row) => row.length > 0)
-            : bulletRows;
-        const missingIds = candidateRows.filter((row) => extractAcceptanceCriterionIdsFromMarkdown(row).length === 0);
-        const found = candidateRows.length > 0 && missingIds.length === 0;
-        findings.push({
-            section: "spec_ac_ids_present",
-            required: true,
-            rule: "Acceptance Criteria must assign stable IDs in `AC-N` format for every criterion row.",
-            found,
-            details: candidateRows.length === 0
-                ? "Acceptance Criteria has no populated criterion rows."
-                : missingIds.length === 0
-                    ? `All ${candidateRows.length} acceptance criterion row(s) include AC-N identifiers.`
-                    : `${missingIds.length} acceptance criterion row(s) are missing AC-N identifiers.`
-        });
-    }
-    if (acceptanceCriteriaBody !== null && /\|/u.test(acceptanceCriteriaBody)) {
-        const hasParallel = /\bparallelSafe\b/iu.test(acceptanceCriteriaBody);
-        const hasTouch = /\btouchSurface\b/iu.test(acceptanceCriteriaBody);
-        findings.push({
-            section: "spec_acs_not_sliceable",
-            required: false,
-            rule: "Acceptance criteria should declare `parallelSafe` and `touchSurface` per row so plan/TDD can schedule slices safely.",
-            found: hasParallel && hasTouch,
-            details: hasParallel && hasTouch
-                ? "Acceptance Criteria mentions parallelSafe and touchSurface."
-                : "Add columns or inline markers for parallelSafe (true|false) and touchSurface (short area description) for each AC."
-        });
-    }
-}

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

@@ -1,118 +0,0 @@
-import type { DelegationEntry, DelegationEvent } from "../delegation.js";
-import { type LintFinding, type StageLintContext } from "./shared.js";
-/**
- * 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. **Hand-authored 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.
- * 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 SliceNoOrphanChangesResult {
-    ok: boolean;
-    details: string;
-}
-export declare function evaluateSliceNoOrphanChanges(projectRoot: string, rows: DelegationEntry[]): Promise<SliceNoOrphanChangesResult>;
-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 evaluateSliceDocCoverage(slices: Map<string, DelegationEntry[]>): DocCoverageResult;
-interface BuilderCoverageResult {
-    missing: string[];
-}
-/**
- * `slice-builder` must own GREEN. For each slice that recorded a phase=red
- * event with non-empty evidenceRefs, require a phase=green whose agent is
- * `slice-builder`.
- */
-export declare function evaluateSliceBuilderCoverage(slices: Map<string, DelegationEntry[]>): BuilderCoverageResult;
-interface RedCheckpointResult {
-    ok: boolean;
-    details: string;
-}
-/**
- * Detect single-slice dispatch when the merged wave plan requires parallel
- * ready slice-builder fan-out.
- */
-export declare function evaluateWavePlanDispatchIgnored(params: {
-    artifactsDir: string;
-    planMarkdown: string;
-    runEvents: DelegationEvent[];
-    runId: string;
-    slices: Map<string, DelegationEntry[]>;
-}): Promise<LintFinding | null>;
-/**
- * Global RED checkpoint enforcement (`global-red` mode).
- *
- * 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 the managed `## Parallel Execution Plan` block in
- * `05-plan.md` and/or `<artifacts-dir>/wave-plans/wave-NN.md` files. 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.
- *
- * Default mode is `per-slice` (see `evaluatePerSliceRedBeforeGreen`);
- * this checkpoint applies when a project explicitly opts into
- * `global-red`. Exported under both `evaluateGlobalRedCheckpoint`
- * (canonical name) and `evaluateRedCheckpoint` (back-compat alias for
- * existing tests/consumers).
- *
- * @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 evaluateGlobalRedCheckpoint(slices: Map<string, DelegationEntry[]>, waveMembers?: Map<string, Set<string>> | null): RedCheckpointResult;
-/**
- * Back-compat alias for `evaluateGlobalRedCheckpoint`. The default mode
- * uses `evaluatePerSliceRedBeforeGreen` instead.
- */
-export declare const evaluateRedCheckpoint: typeof evaluateGlobalRedCheckpoint;
-/**
- * Per-slice RED-before-GREEN enforcement (default mode).
- *
- * For each slice with both phase=red and phase=green completed events,
- * fail if any green completedTs precedes the slice's last red completedTs.
- * No global wave barrier — different slices may freely interleave their
- * RED/GREEN/REFACTOR phases.
- */
-export declare function evaluatePerSliceRedBeforeGreen(slices: Map<string, DelegationEntry[]>): 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 {};