cclaw-cli 0.55.2 → 1.0.0

package/README.md

@@ -16,7 +16,7 @@
                                                                                   +--------+      +------+
                                                                                                       |
                                                                                                       v
-                                                                                         retro -> compound -> archive
+                                                                                         post_ship_review -> archive
 ```
 
 The promise is simple: at any point you can ask **where are we, what is blocked, what evidence exists, and what should run next?**
@@ -90,7 +90,7 @@ That gives you:
    npx cclaw-cli sync
 
 5. Close out after ship
-   /cc continues retro -> compound -> archive
+   /cc continues post_ship_review -> archive
 ```
 
 Tracks keep the flow proportional:
@@ -164,7 +164,7 @@ Enforced by generated helpers and state checks:
 - Mandatory delegations need terminal evidence or explicit waiver.
 - Stale stages block until redone and acknowledged.
 - Review criticals route back to TDD.
-- Ship continues through `retro -> compound -> archive` with `closeout.shipSubstate`.
+- Ship continues through `post_ship_review -> archive` with `closeout.shipSubstate`.
 
 Advisory/model-guided:
 

package/dist/artifact-linter/brainstorm.js

@@ -1,4 +1,6 @@
-import { sectionBodyByName, validateApproachesTaxonomy, headingLineIndex, meaningfulLineCount, parseShortCircuitStatus, validateCalibratedSelfReview, markdownFieldRegex } from "./shared.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { checkCriticPredictionsContract, sectionBodyByName, validateApproachesTaxonomy, headingLineIndex, meaningfulLineCount, parseShortCircuitStatus, validateCalibratedSelfReview, markdownFieldRegex } from "./shared.js";
 export async function lintBrainstormStage(ctx) {
     const { projectRoot, track, raw, absFile, sections, findings, parsedFrontmatter, brainstormShortCircuitBody, brainstormShortCircuitActivated, staleDiagramAuditEnabled, isTrivialOverride } = ctx;
     // Brainstorm Iron Law: "NO ARTIFACT IS COMPLETE WITHOUT AN EXPLICITLY
@@ -165,6 +167,16 @@ export async function lintBrainstormStage(ctx) {
             details: selfReview.details
         });
     }
+    const criticPredictions = checkCriticPredictionsContract(sections);
+    if (criticPredictions !== null) {
+        findings.push({
+            section: "critic.predictions_missing",
+            required: true,
+            rule: "[P2] critic.predictions_missing — pre-commitment predictions block missing or empty",
+            found: criticPredictions.found,
+            details: criticPredictions.details
+        });
+    }
     // Universal structural checks (Layer 2.1). Each fires only when the
     // matching section is present so legacy fixtures keep their current
     // shape, while artifacts emitted from the v3 template have to satisfy
@@ -242,4 +254,36 @@ export async function lintBrainstormStage(ctx) {
                 : `Outside Voice section is missing field(s): ${missing.join(", ")}.`
         });
     }
+    const wavePlansDir = path.join(projectRoot, ".cclaw", "wave-plans");
+    let wavePlanEntries = [];
+    try {
+        wavePlanEntries = (await fs.readdir(wavePlansDir))
+            .filter((entry) => entry !== ".gitkeep" && !entry.startsWith("."));
+    }
+    catch {
+        wavePlanEntries = [];
+    }
+    const multiWaveDetected = wavePlanEntries.length >= 2;
+    if (multiWaveDetected) {
+        const carryForwardBody = sectionBodyByName(sections, "Wave Carry-forward");
+        const hasCarryForwardSection = carryForwardBody !== null;
+        const hasCarryForwardContent = carryForwardBody !== null && meaningfulLineCount(carryForwardBody) > 0;
+        const hasDriftAuditMarkers = carryForwardBody !== null &&
+            /\bcarrying\s+forward\b/iu.test(carryForwardBody) &&
+            /\bdrift\s+detected\b/iu.test(carryForwardBody);
+        const waveDriftAddressed = hasCarryForwardSection && hasCarryForwardContent && hasDriftAuditMarkers;
+        findings.push({
+            section: "wave.drift_unaddressed",
+            required: true,
+            rule: "[P1] wave.drift_unaddressed — when `.cclaw/wave-plans/` has >=2 entries, brainstorm must include `## Wave Carry-forward` with carry-forward and drift audit markers.",
+            found: waveDriftAddressed,
+            details: waveDriftAddressed
+                ? `Multi-wave context detected (${wavePlanEntries.length} wave-plan entries); Wave Carry-forward audit is present.`
+                : !hasCarryForwardSection
+                    ? "Multi-wave context detected but `## Wave Carry-forward` section is missing."
+                    : !hasCarryForwardContent
+                        ? "`## Wave Carry-forward` exists but has no meaningful content."
+                        : "Wave Carry-forward section must include both `Carrying forward` and `Drift detected` markers."
+        });
+    }
 }

package/dist/artifact-linter/design.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import { resolveArtifactPath as resolveStageArtifactPath } from "../artifact-paths.js";
 import { exists } from "../fs-utils.js";
 import { CONFIDENCE_FINDING_REGEX_SOURCE } from "../content/skills.js";
-import { extractMarkdownSectionBody, getMarkdownTableRows, meaningfulLineCount, sectionBodyByName, markdownFieldRegex } from "./shared.js";
+import { checkCriticPredictionsContract, evaluateLayeredDocumentReviewStatus, extractMarkdownSectionBody, getMarkdownTableRows, meaningfulLineCount, sectionBodyByName, markdownFieldRegex } from "./shared.js";
 const DESIGN_DIAGRAM_REQUIREMENTS = {
     lightweight: [
         {
@@ -204,6 +204,16 @@ async function runStaleDiagramAudit(projectRoot, artifactPath, artifactRaw, code
 }
 export async function lintDesignStage(ctx) {
     const { projectRoot, track, raw, absFile, sections, findings, parsedFrontmatter, brainstormShortCircuitBody, brainstormShortCircuitActivated, staleDiagramAuditEnabled, isTrivialOverride } = ctx;
+    const criticPredictions = checkCriticPredictionsContract(sections);
+    if (criticPredictions !== null) {
+        findings.push({
+            section: "critic.predictions_missing",
+            required: true,
+            rule: "[P2] critic.predictions_missing — pre-commitment predictions block missing or empty",
+            found: criticPredictions.found,
+            details: criticPredictions.details
+        });
+    }
     const tierResolution = await resolveDesignDiagramTier(projectRoot, track, raw);
     const diagramTier = isTrivialOverride
         ? "lightweight"
@@ -320,4 +330,25 @@ export async function lintDesignStage(ctx) {
                     : "No calibrated findings detected. Use `[P1|P2|P3] (confidence: <n>/10) <repo-path>[:<line>] — <description>`."
         });
     }
+    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/plan.js

@@ -1,4 +1,4 @@
-import { headingPresent, sectionBodyByName, collectPatternHits, PLACEHOLDER_PATTERNS, extractDecisionIds, SCOPE_REDUCTION_PATTERNS } from "./shared.js";
+import { evaluateLayeredDocumentReviewStatus, headingPresent, sectionBodyByName, collectPatternHits, PLACEHOLDER_PATTERNS, extractDecisionIds, SCOPE_REDUCTION_PATTERNS } from "./shared.js";
 import { resolveArtifactPath as resolveStageArtifactPath } from "../artifact-paths.js";
 import { exists } from "../fs-utils.js";
 import { FORBIDDEN_PLACEHOLDER_TOKENS, CONFIDENCE_FINDING_REGEX_SOURCE } from "../content/skills.js";
@@ -159,4 +159,25 @@ export async function lintPlanStage(ctx) {
                 : "Regression Iron Rule section is present but missing `Iron rule acknowledged: yes`."
         });
     }
+    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/review.js

@@ -1,4 +1,4 @@
-import { sectionBodyByName } from "./shared.js";
+import { markdownFieldRegex, sectionBodyByName } from "./shared.js";
 export async function lintReviewStage(ctx) {
     const { projectRoot, track, raw, absFile, sections, findings, parsedFrontmatter, brainstormShortCircuitBody, brainstormShortCircuitActivated, staleDiagramAuditEnabled, isTrivialOverride } = ctx;
     // Universal Layer 2.7 structural checks (superpowers requesting + receiving).
@@ -62,4 +62,38 @@ export async function lintReviewStage(ctx) {
                 : "Receiving Posture is missing the anti-sycophancy acknowledgement line."
         });
     }
+    const lensCoverageBody = sectionBodyByName(sections, "Lens Coverage");
+    if (lensCoverageBody === null) {
+        findings.push({
+            section: "reviewer.lens_coverage_missing",
+            required: true,
+            rule: "[P1] reviewer.lens_coverage_missing — review artifact must include `## Lens Coverage` with Performance/Compatibility/Observability/Security lines.",
+            found: false,
+            details: "No ## heading matching required section \"Lens Coverage\"."
+        });
+    }
+    else {
+        const performance = markdownFieldRegex("Performance", "NO_IMPACT|FOUND_\\d+").test(lensCoverageBody);
+        const compatibility = markdownFieldRegex("Compatibility", "NO_IMPACT|FOUND_\\d+").test(lensCoverageBody);
+        const observability = markdownFieldRegex("Observability", "NO_IMPACT|FOUND_\\d+").test(lensCoverageBody);
+        const security = markdownFieldRegex("Security", "routed\\s+to\\s+security-reviewer").test(lensCoverageBody);
+        const missing = [];
+        if (!performance)
+            missing.push("Performance");
+        if (!compatibility)
+            missing.push("Compatibility");
+        if (!observability)
+            missing.push("Observability");
+        if (!security)
+            missing.push("Security");
+        findings.push({
+            section: "reviewer.lens_coverage_missing",
+            required: true,
+            rule: "[P1] reviewer.lens_coverage_missing — `Lens Coverage` must include Performance/Compatibility/Observability (`NO_IMPACT` or `FOUND_<n>`) and Security routing line.",
+            found: missing.length === 0,
+            details: missing.length === 0
+                ? "Lens Coverage includes all required reviewer lens lines."
+                : `Lens Coverage missing or malformed line(s): ${missing.join(", ")}.`
+        });
+    }
 }

package/dist/artifact-linter/scope.js

@@ -1,4 +1,4 @@
-import { sectionBodyByHeadingPrefix, sectionBodyByName, extractCanonicalScopeMode, sectionBodyByAnyName, collectPatternHits, SCOPE_REDUCTION_PATTERNS, validateLockedDecisionAnchors, getMarkdownTableRows } from "./shared.js";
+import { checkCriticPredictionsContract, sectionBodyByHeadingPrefix, sectionBodyByName, extractCanonicalScopeMode, sectionBodyByAnyName, collectPatternHits, SCOPE_REDUCTION_PATTERNS, validateLockedDecisionAnchors, getMarkdownTableRows } from "./shared.js";
 import { readDelegationLedger } from "../delegation.js";
 export async function lintScopeStage(ctx) {
     const { projectRoot, track, raw, absFile, sections, findings, parsedFrontmatter, brainstormShortCircuitBody, brainstormShortCircuitActivated, staleDiagramAuditEnabled, isTrivialOverride } = ctx;
@@ -15,22 +15,32 @@ export async function lintScopeStage(ctx) {
     const strategistRequired = selectedScopeMode === "SCOPE EXPANSION" || selectedScopeMode === "SELECTIVE EXPANSION";
     if (strategistRequired) {
         const delegationLedger = await readDelegationLedger(projectRoot);
-        const strategistRows = delegationLedger.entries.filter((entry) => entry.stage === "scope" &&
-            entry.agent === "product-strategist" &&
+        const discoveryRows = delegationLedger.entries.filter((entry) => entry.stage === "scope" &&
+            entry.agent === "product-discovery" &&
             entry.runId === delegationLedger.runId &&
             entry.status === "completed");
-        const hasCompleted = strategistRows.length > 0;
-        const hasEvidence = strategistRows.some((entry) => Array.isArray(entry.evidenceRefs) && entry.evidenceRefs.length > 0);
+        const hasCompleted = discoveryRows.length > 0;
+        const hasEvidence = discoveryRows.some((entry) => Array.isArray(entry.evidenceRefs) && entry.evidenceRefs.length > 0);
         findings.push({
             section: "Expansion Strategist Delegation",
             required: true,
-            rule: "When Scope Summary selects SCOPE EXPANSION or SELECTIVE EXPANSION, a completed `product-strategist` delegation for the active run with non-empty evidenceRefs is required.",
+            rule: "When Scope Summary selects SCOPE EXPANSION or SELECTIVE EXPANSION, a completed `product-discovery` delegation for the active run with non-empty evidenceRefs is required.",
             found: hasCompleted && hasEvidence,
             details: !hasCompleted
-                ? `Scope mode ${selectedScopeMode} requires a completed product-strategist delegation row for active run ${delegationLedger.runId}.`
+                ? `Scope mode ${selectedScopeMode} requires a completed product-discovery delegation row for active run ${delegationLedger.runId}.`
                 : hasEvidence
-                    ? `product-strategist delegation satisfied for mode ${selectedScopeMode}.`
-                    : "product-strategist delegation exists but evidenceRefs is empty; add at least one artifact/code evidence reference."
+                    ? `product-discovery delegation satisfied for mode ${selectedScopeMode}.`
+                    : "product-discovery delegation exists but evidenceRefs is empty; add at least one artifact/code evidence reference."
+        });
+    }
+    const criticPredictions = checkCriticPredictionsContract(sections);
+    if (criticPredictions !== null) {
+        findings.push({
+            section: "critic.predictions_missing",
+            required: true,
+            rule: "[P2] critic.predictions_missing — pre-commitment predictions block missing or empty",
+            found: criticPredictions.found,
+            details: criticPredictions.details
         });
     }
     const reductionHits = collectPatternHits(scopeSections, SCOPE_REDUCTION_PATTERNS);

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

@@ -30,6 +30,17 @@ export declare function headingPresent(sections: H2SectionMap, section: string):
 export declare function sectionBodyByName(sections: H2SectionMap, section: string): string | null;
 export declare function sectionBodyByAnyName(sections: H2SectionMap, sectionNames: string[]): string | null;
 export declare function sectionBodyByHeadingPrefix(sections: H2SectionMap, prefix: string): string | null;
+export interface CriticPredictionsContractCheck {
+    found: boolean;
+    details: string;
+}
+export declare function checkCriticPredictionsContract(sections: H2SectionMap): CriticPredictionsContractCheck | null;
+export interface LayeredDocumentReviewStatus {
+    triggeredReviewers: string[];
+    missingStructured: string[];
+    failOrPartialWithoutWaiver: string[];
+}
+export declare function evaluateLayeredDocumentReviewStatus(sections: H2SectionMap, confidenceFindingRegexSource: string): LayeredDocumentReviewStatus | null;
 /**
  * Build a regex that matches `<field>: <value>` even when the field name
  * and/or value are wrapped in markdown emphasis (`*`, `**`, `_`, `__`).
@@ -153,8 +164,6 @@ export declare function hasVerificationLadderTableRow(sectionBody: string): bool
 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" | "idea" | "manual";
 export interface LearningSeedEntry {
     type: LearningEntryType;
@@ -162,20 +171,14 @@ export interface LearningSeedEntry {
     action: string;
     confidence: LearningConfidence;
     severity?: LearningSeverity;
-    domain?: string | null;
     stage?: FlowStage | null;
     origin_stage?: FlowStage | null;
-    origin_run?: 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;
@@ -187,8 +190,6 @@ export interface LearningsParseResult {
 export declare const LEARNING_TYPE_SET: Set<LearningEntryType>;
 export declare const LEARNING_CONFIDENCE_SET: Set<LearningConfidence>;
 export declare const LEARNING_SEVERITY_SET: Set<LearningSeverity>;
-export declare const LEARNING_UNIVERSALITY_SET: Set<LearningUniversality>;
-export declare const LEARNING_MATURITY_SET: Set<LearningMaturity>;
 export declare const LEARNING_SOURCE_SET: Set<LearningSource>;
 export declare const FLOW_STAGE_SET: Set<"brainstorm" | "scope" | "design" | "spec" | "plan" | "tdd" | "review" | "ship">;
 export declare const LEARNING_ALLOWED_KEYS: Set<string>;

package/dist/artifact-linter/shared.js

@@ -93,6 +93,75 @@ export function sectionBodyByHeadingPrefix(sections, prefix) {
     }
     return null;
 }
+export function checkCriticPredictionsContract(sections) {
+    const criticFindingsBody = sectionBodyByName(sections, "Critic Findings");
+    const layeredReviewBody = sectionBodyByHeadingPrefix(sections, "Layered review");
+    const layeredReviewMentionsCritic = layeredReviewBody !== null && /\bcritic\b/iu.test(layeredReviewBody);
+    const sourceBody = criticFindingsBody ?? (layeredReviewMentionsCritic ? layeredReviewBody : null);
+    if (sourceBody === null)
+        return null;
+    const predictionsMatch = /(?:^|\n)#{3,4}\s*Pre-commitment predictions\b([\s\S]*?)(?=\n#{2,4}\s+|$)/iu.exec(sourceBody);
+    const predictionsCount = predictionsMatch ? countListItems(predictionsMatch[1] ?? "") : 0;
+    const hasPredictions = predictionsCount >= 1;
+    const hasValidated = /(?:^|\n)#{3,4}\s*Validated\s*\/\s*Disproven\b/iu.test(sourceBody);
+    const hasOpenQuestions = /(?:^|\n)#{3,4}\s*Open Questions\b/iu.test(sourceBody);
+    const missing = [];
+    if (!hasPredictions) {
+        missing.push("`Pre-commitment predictions` subsection is missing or has no list items");
+    }
+    if (!hasValidated) {
+        missing.push("`Validated / Disproven` subsection is missing");
+    }
+    if (!hasOpenQuestions) {
+        missing.push("`Open Questions` subsection is missing");
+    }
+    return {
+        found: missing.length === 0,
+        details: missing.length === 0
+            ? "Critic pre-commitment predictions contract is present (predictions, validated/disproven mapping, open questions)."
+            : missing.join("; ")
+    };
+}
+const DOCUMENT_REVIEWER_NAMES = [
+    "coherence-reviewer",
+    "scope-guardian-reviewer",
+    "feasibility-reviewer"
+];
+export function evaluateLayeredDocumentReviewStatus(sections, confidenceFindingRegexSource) {
+    const layeredReviewBody = sectionBodyByHeadingPrefix(sections, "Layered review");
+    if (layeredReviewBody === null)
+        return null;
+    const triggeredReviewers = DOCUMENT_REVIEWER_NAMES.filter((reviewer) => new RegExp(`\\b${reviewer}\\b`, "iu").test(layeredReviewBody));
+    if (triggeredReviewers.length === 0)
+        return null;
+    const findingRegex = new RegExp(confidenceFindingRegexSource, "iu");
+    const hasCalibratedFinding = findingRegex.test(layeredReviewBody);
+    const missingStructured = [];
+    const failOrPartialWithoutWaiver = [];
+    const waiverRegex = /(?:explicit\s+waiver|waiver\s*:|waived\s*:|accepted[-\s]?risk)/iu;
+    for (const reviewer of triggeredReviewers) {
+        const escaped = reviewer.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+        const subsectionMatch = new RegExp(`(?:^|\\n)#{3,4}\\s*${escaped}\\b([\\s\\S]*?)(?=\\n#{2,4}\\s+|$)`, "iu")
+            .exec(layeredReviewBody);
+        const reviewerBlock = subsectionMatch?.[1] ?? layeredReviewBody;
+        const statusMatch = /\b(?:Status|Result|Verdict)\s*:\s*(PASS|PASS_WITH_GAPS|FAIL|PARTIAL|BLOCKED)\b/iu
+            .exec(reviewerBlock);
+        const inlineStatusMatch = new RegExp(`${escaped}[\\s\\S]{0,120}\\b(PASS|PASS_WITH_GAPS|FAIL|PARTIAL|BLOCKED)\\b`, "iu")
+            .exec(layeredReviewBody);
+        const status = (statusMatch?.[1] ?? inlineStatusMatch?.[1] ?? "").toUpperCase();
+        if (!hasCalibratedFinding || status.length === 0) {
+            missingStructured.push(reviewer);
+        }
+        if ((status === "FAIL" || status === "PARTIAL") && !waiverRegex.test(reviewerBlock) && !waiverRegex.test(layeredReviewBody)) {
+            failOrPartialWithoutWaiver.push(`${reviewer}:${status}`);
+        }
+    }
+    return {
+        triggeredReviewers,
+        missingStructured,
+        failOrPartialWithoutWaiver
+    };
+}
 /**
  * Build a regex that matches `<field>: <value>` even when the field name
  * and/or value are wrapped in markdown emphasis (`*`, `**`, `_`, `__`).
@@ -991,8 +1060,6 @@ export function hasVerificationLadderTableRow(sectionBody) {
 export const LEARNING_TYPE_SET = new Set(["rule", "pattern", "lesson", "compound"]);
 export const LEARNING_CONFIDENCE_SET = new Set(["high", "medium", "low"]);
 export const LEARNING_SEVERITY_SET = new Set(["critical", "important", "suggestion"]);
-export const LEARNING_UNIVERSALITY_SET = new Set(["project", "personal", "universal"]);
-export const LEARNING_MATURITY_SET = new Set(["raw", "lifted-to-rule", "lifted-to-enforcement"]);
 export const LEARNING_SOURCE_SET = new Set([
     "stage",
     "retro",
@@ -1007,20 +1074,14 @@ export const LEARNING_ALLOWED_KEYS = new Set([
     "action",
     "confidence",
     "severity",
-    "domain",
     "stage",
     "origin_stage",
-    "origin_run",
     "frequency",
-    "universality",
-    "maturity",
     "created",
     "first_seen_ts",
     "last_seen_ts",
     "project",
-    "source",
-    "supersedes",
-    "superseded_by"
+    "source"
 ]);
 export function isIsoUtcTimestamp(value) {
     return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/u.test(value);
@@ -1079,9 +1140,6 @@ export function parseLearningSeedEntry(raw, index) {
             error: `Learnings bullet #${index} field "severity" must be critical|important|suggestion.`
         };
     }
-    if (obj.domain !== undefined && !isNullableString(obj.domain)) {
-        return { ok: false, error: `Learnings bullet #${index} field "domain" must be string or null.` };
-    }
     if (obj.stage !== undefined && !isNullableStage(obj.stage)) {
         return {
             ok: false,
@@ -1094,9 +1152,6 @@ export function parseLearningSeedEntry(raw, index) {
             error: `Learnings bullet #${index} field "origin_stage" must be one of ${FLOW_STAGES.join(", ")} or null.`
         };
     }
-    if (obj.origin_run !== undefined && !isNullableString(obj.origin_run)) {
-        return { ok: false, error: `Learnings bullet #${index} field "origin_run" must be string or null.` };
-    }
     if (obj.project !== undefined && !isNullableString(obj.project)) {
         return { ok: false, error: `Learnings bullet #${index} field "project" must be string or null.` };
     }
@@ -1112,21 +1167,6 @@ export function parseLearningSeedEntry(raw, index) {
         (typeof obj.frequency !== "number" || !Number.isInteger(obj.frequency) || obj.frequency < 1)) {
         return { ok: false, error: `Learnings bullet #${index} field "frequency" must be an integer >= 1.` };
     }
-    if (obj.universality !== undefined &&
-        (typeof obj.universality !== "string" ||
-            !LEARNING_UNIVERSALITY_SET.has(obj.universality))) {
-        return {
-            ok: false,
-            error: `Learnings bullet #${index} field "universality" must be project|personal|universal.`
-        };
-    }
-    if (obj.maturity !== undefined &&
-        (typeof obj.maturity !== "string" || !LEARNING_MATURITY_SET.has(obj.maturity))) {
-        return {
-            ok: false,
-            error: `Learnings bullet #${index} field "maturity" must be raw|lifted-to-rule|lifted-to-enforcement.`
-        };
-    }
     for (const timestampField of ["created", "first_seen_ts", "last_seen_ts"]) {
         const value = obj[timestampField];
         if (value === undefined)
@@ -1138,17 +1178,6 @@ export function parseLearningSeedEntry(raw, index) {
             };
         }
     }
-    if (obj.supersedes !== undefined) {
-        if (!Array.isArray(obj.supersedes) ||
-            obj.supersedes.length === 0 ||
-            obj.supersedes.some((value) => typeof value !== "string" || value.trim().length === 0)) {
-            return { ok: false, error: `Learnings bullet #${index} field "supersedes" must be a non-empty array of strings.` };
-        }
-    }
-    if (obj.superseded_by !== undefined &&
-        (typeof obj.superseded_by !== "string" || obj.superseded_by.trim().length === 0)) {
-        return { ok: false, error: `Learnings bullet #${index} field "superseded_by" must be a non-empty string.` };
-    }
     return {
         ok: true,
         entry: {

package/dist/artifact-linter/ship.js

@@ -1,3 +1,4 @@
+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;
@@ -43,4 +44,39 @@ export async function lintShipStage(ctx) {
                 : "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.js

@@ -1,4 +1,5 @@
-import { sectionBodyByName, SPEC_MAX_MODULES } from "./shared.js";
+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).
@@ -105,4 +106,25 @@ export async function lintSpecStage(ctx) {
                 : `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.js

@@ -1,3 +1,6 @@
+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;
@@ -121,4 +124,75 @@ export async function lintTddStage(ctx) {
                     : "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."
+        });
+    }
 }