cclaw-cli 0.51.30 → 1.0.0

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

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

package/dist/artifact-linter/ship.js

@@ -0,0 +1,82 @@
+import { readDelegationLedger } from "../delegation.js";
+import { sectionBodyByName } from "./shared.js";
+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."
+    });
+}

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

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

package/dist/artifact-linter/spec.js

@@ -0,0 +1,130 @@
+import { evaluateLayeredDocumentReviewStatus, 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(", ")}.`
+        });
+    }
+}

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

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

package/dist/artifact-linter/tdd.js

@@ -0,0 +1,198 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { readDelegationLedger } from "../delegation.js";
+import { sectionBodyByName } from "./shared.js";
+export async function lintTddStage(ctx) {
+    const { projectRoot, track, raw, absFile, sections, findings, parsedFrontmatter, brainstormShortCircuitBody, brainstormShortCircuitActivated, staleDiagramAuditEnabled, isTrivialOverride } = ctx;
+    // Universal Layer 2.6 structural checks (superpowers TDD + evanflow vertical slices).
+    const ironLawBody = sectionBodyByName(sections, "Iron Law Acknowledgement");
+    if (ironLawBody === null) {
+        findings.push({
+            section: "TDD Iron Law Acknowledgement",
+            required: true,
+            rule: "Iron Law Acknowledgement must affirm `Acknowledged: yes`.",
+            found: false,
+            details: "No ## heading matching required section \"Iron Law Acknowledgement\"."
+        });
+    }
+    else {
+        const ack = /acknowledged:\s*(yes|true|y)\b/iu.test(ironLawBody);
+        findings.push({
+            section: "TDD Iron Law Acknowledgement",
+            required: true,
+            rule: "Iron Law Acknowledgement must affirm `Acknowledged: yes`.",
+            found: ack,
+            details: ack
+                ? "TDD Iron Law acknowledged."
+                : "Iron Law Acknowledgement is missing explicit `Acknowledged: yes`."
+        });
+    }
+    const watchedRedBody = sectionBodyByName(sections, "Watched-RED Proof");
+    if (watchedRedBody === null) {
+        findings.push({
+            section: "Watched-RED Proof Shape",
+            required: true,
+            rule: "Watched-RED Proof must include at least one populated row, and each row must include an ISO timestamp showing when the test was observed failing.",
+            found: false,
+            details: "No ## heading matching required section \"Watched-RED Proof\"."
+        });
+    }
+    else {
+        const rows = watchedRedBody.split("\n").filter((line) => /^\|/u.test(line));
+        const dataRows = rows.length >= 3 ? rows.slice(2) : [];
+        const populatedRows = dataRows.filter((row) => row
+            .split("|")
+            .slice(1, -1)
+            .filter((_, idx) => idx !== 0) // skip slice column
+            .some((cell) => cell.trim().length > 0));
+        // Each populated row must include an ISO timestamp in column 3.
+        const isoRegex = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/u;
+        const validProofRows = populatedRows.filter((row) => isoRegex.test(row));
+        const hasPopulatedRows = populatedRows.length > 0;
+        const allRowsHaveIso = validProofRows.length === populatedRows.length;
+        findings.push({
+            section: "Watched-RED Proof Shape",
+            required: true,
+            rule: "Watched-RED Proof must include at least one populated row, and each row must include an ISO timestamp showing when the test was observed failing.",
+            found: hasPopulatedRows && allRowsHaveIso,
+            details: !hasPopulatedRows
+                ? "Watched-RED Proof has no populated rows; add at least one slice row with observed RED evidence."
+                : allRowsHaveIso
+                    ? `All ${populatedRows.length} watched-RED proof row(s) include an ISO timestamp.`
+                    : `${populatedRows.length - validProofRows.length} watched-RED proof row(s) lack an ISO timestamp.`
+        });
+    }
+    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 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 assertionBody = sectionBodyByName(sections, "Assertion Correctness Notes");
+    if (assertionBody !== null) {
+        const tableRows = assertionBody.split("\n").filter((line) => /^\|/u.test(line));
+        const dataRows = tableRows.length >= 3 ? tableRows.slice(2) : [];
+        const ok = dataRows.length === 0 || dataRows.some((row) => row
+            .split("|")
+            .slice(1, -1)
+            .some((cell) => cell.trim().length > 0));
+        findings.push({
+            section: "Assertion Correctness Notes Shape",
+            required: true,
+            rule: "Assertion Correctness Notes must include at least one populated row when the slice has new assertions.",
+            found: ok,
+            details: ok
+                ? "Assertion Correctness Notes is populated or absent (single-step slice)."
+                : "Assertion Correctness Notes table has no populated rows."
+        });
+    }
+    const testDiscoveryBody = sectionBodyByName(sections, "Test Discovery") ?? "";
+    const redEvidenceBody = sectionBodyByName(sections, "RED Evidence") ?? "";
+    const mockPreferenceScanBody = `${testDiscoveryBody}\n${redEvidenceBody}`;
+    const mockTokenRegex = /\b(jest\.mock|vi\.mock|sinon\.stub|mock\.patch|unittest\.mock|magicmock|spyon|tohavebeencalled)\b/iu;
+    if (mockTokenRegex.test(mockPreferenceScanBody)) {
+        const boundaryJustificationRegex = /\b(justified\s+by\s+boundary|boundary:\s*[A-Za-z0-9/_ -]*(network|fs|filesystem|time|clock|external)|network|filesystem|clock|external\s+service)\b/iu;
+        const hasBoundaryJustification = boundaryJustificationRegex.test(mockPreferenceScanBody);
+        const realPathRegex = /\b(?:src|lib|packages|apps)\/[A-Za-z0-9_./-]+\b/u;
+        const hasRealPathHint = realPathRegex.test(mockPreferenceScanBody);
+        findings.push({
+            section: "Mock Preference Heuristic",
+            required: false,
+            rule: "When mocks/spies appear in Test Discovery or RED Evidence, prefer Real > Fake > Stub > Mock. Mock-heavy slices need explicit boundary justification (network/fs/time/external).",
+            found: hasBoundaryJustification,
+            details: hasBoundaryJustification
+                ? "Mock usage is explicitly justified by boundary constraints."
+                : hasRealPathHint
+                    ? "Mocks/spies detected while real implementation paths are listed; prefer Real > Fake > Stub > Mock unless a boundary justification is added."
+                    : "Mocks/spies detected without boundary justification; add explicit trust-boundary rationale or replace with real/fake/stub coverage."
+        });
+    }
+    const delegationLedger = await readDelegationLedger(projectRoot);
+    const activeRunEntries = delegationLedger.entries.filter((entry) => entry.stage === "tdd" && entry.runId === delegationLedger.runId);
+    const completedSliceImplementers = activeRunEntries.filter((entry) => entry.agent === "slice-implementer" && entry.status === "completed");
+    const fanOutDetected = completedSliceImplementers.length > 1;
+    if (fanOutDetected) {
+        const artifactsDir = path.dirname(absFile);
+        const cohesionContractMarkdownPath = path.join(artifactsDir, "cohesion-contract.md");
+        const cohesionContractJsonPath = path.join(artifactsDir, "cohesion-contract.json");
+        let cohesionContractFound = true;
+        const cohesionErrors = [];
+        try {
+            const markdown = await fs.readFile(cohesionContractMarkdownPath, "utf8");
+            if (!/#\s*Cohesion Contract\b/u.test(markdown)) {
+                cohesionContractFound = false;
+                cohesionErrors.push("cohesion-contract.md exists but missing `# Cohesion Contract` heading.");
+            }
+        }
+        catch {
+            cohesionContractFound = false;
+            cohesionErrors.push("cohesion-contract.md is missing.");
+        }
+        try {
+            const jsonRaw = await fs.readFile(cohesionContractJsonPath, "utf8");
+            const parsed = JSON.parse(jsonRaw);
+            const objectLike = parsed !== null && typeof parsed === "object" && !Array.isArray(parsed);
+            const parsedRecord = objectLike ? parsed : null;
+            const hasRequiredShape = parsedRecord !== null &&
+                Array.isArray(parsedRecord.sharedTypes) &&
+                Array.isArray(parsedRecord.touchpoints) &&
+                Array.isArray(parsedRecord.slices) &&
+                parsedRecord.status !== undefined &&
+                typeof parsedRecord.status === "object" &&
+                parsedRecord.status !== null;
+            if (!hasRequiredShape) {
+                cohesionContractFound = false;
+                cohesionErrors.push("cohesion-contract.json must parse and include `sharedTypes[]`, `touchpoints[]`, `slices[]`, and `status`.");
+            }
+        }
+        catch {
+            cohesionContractFound = false;
+            cohesionErrors.push("cohesion-contract.json is missing or invalid JSON.");
+        }
+        findings.push({
+            section: "tdd.cohesion_contract_missing",
+            required: true,
+            rule: "When delegation ledger has >1 completed slice-implementer rows for active TDD run, require `.cclaw/artifacts/cohesion-contract.md` and parseable `.cclaw/artifacts/cohesion-contract.json` sidecar.",
+            found: cohesionContractFound,
+            details: cohesionContractFound
+                ? `Fan-out detected (${completedSliceImplementers.length} completed slice-implementer rows); cohesion contract markdown+JSON sidecar are present and parseable.`
+                : cohesionErrors.join(" ")
+        });
+        const completedOverseerRows = activeRunEntries.filter((entry) => entry.agent === "integration-overseer" && entry.status === "completed");
+        const overseerStatusInEvidence = completedOverseerRows.some((entry) => {
+            const refs = Array.isArray(entry.evidenceRefs) ? entry.evidenceRefs.join(" ") : "";
+            return /\b(?:PASS_WITH_GAPS|PASS)\b/u.test(refs);
+        });
+        const overseerStatusInArtifact = /\bintegration-overseer\b[\s\S]{0,200}\b(?:PASS_WITH_GAPS|PASS)\b/iu.test(raw);
+        const integrationOverseerFound = completedOverseerRows.length > 0 &&
+            (overseerStatusInEvidence || overseerStatusInArtifact);
+        findings.push({
+            section: "tdd.integration_overseer_missing",
+            required: true,
+            rule: "When fan-out is detected, require completed `integration-overseer` evidence with PASS or PASS_WITH_GAPS.",
+            found: integrationOverseerFound,
+            details: integrationOverseerFound
+                ? "integration-overseer completion recorded with PASS/PASS_WITH_GAPS evidence."
+                : completedOverseerRows.length === 0
+                    ? "Fan-out detected but no completed integration-overseer delegation row exists for active run."
+                    : "integration-overseer completion exists, but PASS/PASS_WITH_GAPS evidence is missing in delegation evidenceRefs and artifact text."
+        });
+    }
+}

package/dist/artifact-linter.d.ts

@@ -1,77 +1,5 @@
-import { type FlowStage, type FlowTrack } from "./types.js";
-export interface LintFinding {
-    section: string;
-    required: boolean;
-    rule: string;
-    found: boolean;
-    details: string;
-}
-export interface LintResult {
-    stage: string;
-    file: string;
-    passed: boolean;
-    findings: LintFinding[];
-}
-export declare function extractMarkdownSectionBody(markdown: string, section: string): string | null;
-export type LearningEntryType = "rule" | "pattern" | "lesson" | "compound";
-export type LearningConfidence = "high" | "medium" | "low";
-export type LearningSeverity = "critical" | "important" | "suggestion";
-export type LearningUniversality = "project" | "personal" | "universal";
-export type LearningMaturity = "raw" | "lifted-to-rule" | "lifted-to-enforcement";
-export type LearningSource = "stage" | "retro" | "compound" | "ideate" | "manual";
-export interface LearningSeedEntry {
-    type: LearningEntryType;
-    trigger: string;
-    action: string;
-    confidence: LearningConfidence;
-    severity?: LearningSeverity;
-    domain?: string | null;
-    stage?: FlowStage | null;
-    origin_stage?: FlowStage | null;
-    origin_run?: string | null;
-    /** @deprecated Use `origin_run`. Accepted only for legacy learning bullets. */
-    origin_feature?: string | null;
-    frequency?: number;
-    universality?: LearningUniversality;
-    maturity?: LearningMaturity;
-    created?: string;
-    first_seen_ts?: string;
-    last_seen_ts?: string;
-    project?: string | null;
-    source?: LearningSource | null;
-    supersedes?: string[];
-    superseded_by?: string;
-}
-export interface LearningsParseResult {
-    ok: boolean;
-    none: boolean;
-    entries: LearningSeedEntry[];
-    errors: string[];
-    details: string;
-}
-export declare function parseLearningsSection(sectionBody: string): LearningsParseResult;
+import type { FlowStage, FlowTrack } from "./types.js";
+import { type LintResult } from "./artifact-linter/shared.js";
+export { validateReviewArmy, checkReviewVerdictConsistency, checkReviewSecurityNoChangeAttestation, type ReviewVerdictConsistencyResult, type ReviewSecurityNoChangeAttestationResult } from "./artifact-linter/review-army.js";
+export { type LintFinding, type LintResult, type LearningEntryType, type LearningConfidence, type LearningSeverity, type LearningSource, type LearningSeedEntry, type LearningsParseResult, extractMarkdownSectionBody, parseLearningsSection } from "./artifact-linter/shared.js";
 export declare function lintArtifact(projectRoot: string, stage: FlowStage, track?: FlowTrack): Promise<LintResult>;
-export declare function validateReviewArmy(projectRoot: string): Promise<{
-    valid: boolean;
-    errors: string[];
-}>;
-export interface ReviewVerdictConsistencyResult {
-    ok: boolean;
-    errors: string[];
-    finalVerdict: "APPROVED" | "APPROVED_WITH_CONCERNS" | "BLOCKED" | "UNKNOWN";
-    openCriticalCount: number;
-    shipBlockerCount: number;
-}
-export interface ReviewSecurityNoChangeAttestationResult {
-    ok: boolean;
-    errors: string[];
-    hasSecurityFinding: boolean;
-    hasNoChangeAttestation: boolean;
-}
-/**
- * Ensure the narrative verdict in 07-review.md is consistent with the
- * structured review-army reconciliation. A review cannot declare
- * APPROVED while open Critical findings or shipBlockers remain.
- */
-export declare function checkReviewVerdictConsistency(projectRoot: string): Promise<ReviewVerdictConsistencyResult>;
-export declare function checkReviewSecurityNoChangeAttestation(projectRoot: string): Promise<ReviewSecurityNoChangeAttestationResult>;