cclaw-cli 0.51.29 → 0.55.2

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,46 @@
+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."
+        });
+    }
+}

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,108 @@
+import { sectionBodyByName, SPEC_MAX_MODULES } from "./shared.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(", ")}.`
+        });
+    }
+}

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,124 @@
+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."
+        });
+    }
+}

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 LearningUniversality, type LearningMaturity, 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>;