cclaw-cli 0.55.2 → 1.0.0

package/dist/knowledge-store.js

@@ -32,9 +32,8 @@ export function effectiveCompoundThreshold(baseThreshold, archivedRunsCount) {
  *
  * Clustering key: `(type, normalizeText(trigger), normalizeText(action))`
  * which mirrors the compound readiness clustering in runtime state.
- * Entries with `maturity === "lifted-to-enforcement"` or `superseded_by`
- * are excluded — they were already promoted/replaced and should not re-appear
- * as ready.
+ * The readiness surface intentionally stays simple: no maturity/supersede
+ * suppression logic in this pass.
  */
 export function computeCompoundReadiness(entries, options = {}) {
     const thresholdRaw = options.threshold ?? DEFAULT_COMPOUND_RECURRENCE_THRESHOLD;
@@ -54,8 +53,6 @@ export function computeCompoundReadiness(entries, options = {}) {
     const { threshold, relaxationApplied } = effectiveCompoundThreshold(baseThreshold, archivedRunsCount);
     const buckets = new Map();
     for (const entry of entries) {
-        if (entry.maturity === "lifted-to-enforcement" || entry.superseded_by !== undefined)
-            continue;
         const key = [
             entry.type,
             normalizeText(entry.trigger),
@@ -71,15 +68,13 @@ export function computeCompoundReadiness(entries, options = {}) {
                 entryCount: 1,
                 severity: entry.severity,
                 lastSeenTs: entry.last_seen_ts,
-                types: new Set([entry.type]),
-                maturity: new Set([entry.maturity])
+                types: new Set([entry.type])
             });
             continue;
         }
         bucket.recurrence += frequency;
         bucket.entryCount += 1;
         bucket.types.add(entry.type);
-        bucket.maturity.add(entry.maturity);
         if (entry.severity === "critical") {
             bucket.severity = "critical";
         }
@@ -104,8 +99,7 @@ export function computeCompoundReadiness(entries, options = {}) {
             qualification: criticalOverride && !meetsRecurrence ? "critical_override" : "recurrence",
             ...(bucket.severity ? { severity: bucket.severity } : {}),
             lastSeenTs: bucket.lastSeenTs,
-            types: Array.from(bucket.types).sort(),
-            maturity: Array.from(bucket.maturity).sort()
+            types: Array.from(bucket.types).sort()
         });
     }
     ready.sort((a, b) => {
@@ -143,8 +137,8 @@ export function computeCompoundReadiness(entries, options = {}) {
 const KNOWLEDGE_TYPE_SET = new Set(["rule", "pattern", "lesson", "compound"]);
 const KNOWLEDGE_CONFIDENCE_SET = new Set(["high", "medium", "low"]);
 const KNOWLEDGE_SEVERITY_SET = new Set(["critical", "important", "suggestion"]);
-const KNOWLEDGE_UNIVERSALITY_SET = new Set(["project", "personal", "universal"]);
-const KNOWLEDGE_MATURITY_SET = new Set(["raw", "lifted-to-rule", "lifted-to-enforcement"]);
+const LEGACY_KNOWLEDGE_UNIVERSALITY_SET = new Set(["project", "personal", "universal"]);
+const LEGACY_KNOWLEDGE_MATURITY_SET = new Set(["raw", "lifted-to-rule", "lifted-to-enforcement"]);
 const KNOWLEDGE_SOURCE_SET = new Set([
     "stage",
     "retro",
@@ -158,19 +152,21 @@ const KNOWLEDGE_REQUIRED_KEYS = [
     "trigger",
     "action",
     "confidence",
-    "domain",
     "stage",
     "origin_stage",
-    "origin_run",
     "frequency",
-    "universality",
-    "maturity",
     "created",
     "first_seen_ts",
     "last_seen_ts",
     "project"
 ];
 const KNOWLEDGE_ALLOWED_KEYS = new Set(KNOWLEDGE_REQUIRED_KEYS);
+// Legacy keys are accepted for backwards compatibility when reading historical
+// knowledge entries, but no longer required for newly materialized rows.
+KNOWLEDGE_ALLOWED_KEYS.add("domain");
+KNOWLEDGE_ALLOWED_KEYS.add("origin_run");
+KNOWLEDGE_ALLOWED_KEYS.add("universality");
+KNOWLEDGE_ALLOWED_KEYS.add("maturity");
 KNOWLEDGE_ALLOWED_KEYS.add("source");
 KNOWLEDGE_ALLOWED_KEYS.add("severity");
 KNOWLEDGE_ALLOWED_KEYS.add("supersedes");
@@ -178,6 +174,28 @@ KNOWLEDGE_ALLOWED_KEYS.add("superseded_by");
 function keyAllowedInKnowledgeEntry(key) {
     return KNOWLEDGE_ALLOWED_KEYS.has(key);
 }
+function normalizeParsedKnowledgeEntry(obj) {
+    const normalized = {
+        type: obj.type,
+        trigger: obj.trigger,
+        action: obj.action,
+        confidence: obj.confidence,
+        stage: obj.stage,
+        origin_stage: obj.origin_stage,
+        frequency: obj.frequency,
+        created: obj.created,
+        first_seen_ts: obj.first_seen_ts,
+        last_seen_ts: obj.last_seen_ts,
+        project: obj.project
+    };
+    if (obj.severity !== undefined) {
+        normalized.severity = obj.severity;
+    }
+    if (obj.source !== undefined) {
+        normalized.source = obj.source;
+    }
+    return normalized;
+}
 function knowledgePath(projectRoot) {
     return path.join(projectRoot, RUNTIME_ROOT, "knowledge.jsonl");
 }
@@ -198,16 +216,11 @@ function dedupeKey(entry) {
         entry.type,
         normalizeText(entry.trigger),
         normalizeText(entry.action),
-        entry.domain === null ? "null" : normalizeText(entry.domain),
         entry.stage ?? "null",
         entry.origin_stage ?? "null",
-        entry.origin_run === null ? "null" : normalizeText(entry.origin_run),
-        entry.universality,
         entry.project === null ? "null" : normalizeText(entry.project),
         entry.source === undefined || entry.source === null ? "null" : entry.source,
-        entry.severity === undefined ? "none" : entry.severity,
-        Array.isArray(entry.supersedes) ? entry.supersedes.map(normalizeText).sort().join(",") : "none",
-        entry.superseded_by === undefined ? "none" : normalizeText(entry.superseded_by)
+        entry.severity === undefined ? "none" : entry.severity
     ].join("|");
 }
 function emptyKnowledgeSnapshot() {
@@ -236,7 +249,7 @@ function parseKnowledgeSnapshot(raw) {
                 malformedLines += 1;
                 continue;
             }
-            const entry = parsed;
+            const entry = normalizeParsedKnowledgeEntry(parsed);
             entries.push(entry);
             const key = dedupeKey(entry);
             if (!keyToIndex.has(key)) {
@@ -321,7 +334,7 @@ export function validateKnowledgeEntry(entry) {
         (typeof obj.severity !== "string" || !KNOWLEDGE_SEVERITY_SET.has(obj.severity))) {
         errors.push("severity must be one of: critical, important, suggestion.");
     }
-    if (!isNullableString(obj.domain)) {
+    if (obj.domain !== undefined && !isNullableString(obj.domain)) {
         errors.push("domain must be string or null.");
     }
     if (!isNullableStage(obj.stage)) {
@@ -331,7 +344,7 @@ export function validateKnowledgeEntry(entry) {
         errors.push(`origin_stage must be one of ${FLOW_STAGES.join(", ")} or null.`);
     }
     const originRun = obj.origin_run;
-    if (!isNullableString(originRun)) {
+    if (originRun !== undefined && !isNullableString(originRun)) {
         errors.push("origin_run must be string or null.");
     }
     if (typeof obj.frequency !== "number" ||
@@ -339,10 +352,12 @@ export function validateKnowledgeEntry(entry) {
         obj.frequency < 1) {
         errors.push("frequency must be an integer >= 1.");
     }
-    if (!KNOWLEDGE_UNIVERSALITY_SET.has(obj.universality)) {
+    if (obj.universality !== undefined &&
+        (typeof obj.universality !== "string" || !LEGACY_KNOWLEDGE_UNIVERSALITY_SET.has(obj.universality))) {
         errors.push("universality must be one of: project, personal, universal.");
     }
-    if (!KNOWLEDGE_MATURITY_SET.has(obj.maturity)) {
+    if (obj.maturity !== undefined &&
+        (typeof obj.maturity !== "string" || !LEGACY_KNOWLEDGE_MATURITY_SET.has(obj.maturity))) {
         errors.push("maturity must be one of: raw, lifted-to-rule, lifted-to-enforcement.");
     }
     for (const timestampField of ["created", "first_seen_ts", "last_seen_ts"]) {
@@ -378,20 +393,15 @@ export function materializeKnowledgeEntry(seed, defaults = {}) {
     const now = normalizeUtcIso(defaults.nowIso ?? nowUtcIso());
     const stage = seed.stage ?? defaults.stage ?? null;
     const originStage = seed.origin_stage ?? defaults.originStage ?? stage ?? null;
-    const originRun = seed.origin_run ?? defaults.originRun ?? null;
     const source = seed.source ?? defaults.source ?? null;
     const entry = {
         type: seed.type,
         trigger: seed.trigger.trim(),
         action: seed.action.trim(),
         confidence: seed.confidence,
-        domain: seed.domain ?? null,
         stage,
         origin_stage: originStage,
-        origin_run: originRun,
         frequency: seed.frequency ?? 1,
-        universality: seed.universality ?? "project",
-        maturity: seed.maturity ?? "raw",
         created: normalizeUtcIso(seed.created ?? now),
         first_seen_ts: normalizeUtcIso(seed.first_seen_ts ?? now),
         last_seen_ts: normalizeUtcIso(seed.last_seen_ts ?? now),
@@ -400,12 +410,6 @@ export function materializeKnowledgeEntry(seed, defaults = {}) {
     if (seed.severity !== undefined) {
         entry.severity = seed.severity;
     }
-    if (seed.supersedes !== undefined) {
-        entry.supersedes = seed.supersedes.map((value) => value.trim());
-    }
-    if (seed.superseded_by !== undefined) {
-        entry.superseded_by = seed.superseded_by.trim();
-    }
     if (source !== null) {
         entry.source = source;
     }
@@ -514,18 +518,6 @@ function tokenizeText(value) {
 function uniqueTokens(values) {
     return [...new Set(values)];
 }
-function supersededTriggerSet(entries) {
-    const superseded = new Set();
-    for (const entry of entries) {
-        for (const trigger of entry.supersedes ?? []) {
-            superseded.add(normalizeText(trigger));
-        }
-    }
-    return superseded;
-}
-function isSupersededLearning(entry, supersededTriggers) {
-    return entry.superseded_by !== undefined || supersededTriggers.has(normalizeText(entry.trigger));
-}
 function pathTokens(paths) {
     if (!Array.isArray(paths) || paths.length === 0)
         return [];
@@ -547,9 +539,7 @@ export async function selectRelevantLearnings(projectRoot, options = {}) {
     const limit = typeof options.limit === "number" && Number.isFinite(options.limit) && options.limit > 0
         ? Math.floor(options.limit)
         : 8;
-    const staleTriggers = supersededTriggerSet(entries);
-    const activeEntries = entries.filter((entry) => !isSupersededLearning(entry, staleTriggers));
-    const ranked = activeEntries.map((entry, index) => {
+    const ranked = entries.map((entry, index) => {
         let score = 0;
         let stageScore = 0;
         if (stage) {
@@ -567,13 +557,9 @@ export async function selectRelevantLearnings(projectRoot, options = {}) {
             score += 1;
         if (entry.frequency >= 3)
             score += 1;
-        if (entry.maturity === "lifted-to-enforcement")
-            score -= 1;
         const searchable = [
-            ...tokenizeText(entry.domain),
             ...tokenizeText(entry.trigger),
             ...tokenizeText(entry.action),
-            ...tokenizeText(entry.origin_run),
             ...tokenizeText(entry.project)
         ];
         const searchSet = new Set(searchable);

package/dist/policy.js

@@ -58,7 +58,7 @@ export async function policyChecks(projectRoot, options = {}) {
     const utilitySkillChecks = [
         { file: runtimeFile("skills/learnings/SKILL.md"), needle: "strict JSONL schema", name: "utility_skill:learnings:jsonl_schema" },
         { file: runtimeFile("skills/learnings/SKILL.md"), needle: "knowledge.jsonl", name: "utility_skill:learnings:jsonl_store" },
-        { file: runtimeFile("skills/learnings/SKILL.md"), needle: "type, trigger, action, confidence, domain, stage, origin_stage, origin_run, frequency, universality, maturity, created, first_seen_ts, last_seen_ts, project", name: "utility_skill:learnings:field_order" },
+        { file: runtimeFile("skills/learnings/SKILL.md"), needle: "type, trigger, action, confidence, stage, origin_stage, frequency, created, first_seen_ts, last_seen_ts, project", name: "utility_skill:learnings:field_order" },
         { file: runtimeFile("skills/learnings/SKILL.md"), needle: "## Manual Actions", name: "utility_skill:learnings:manual_actions" },
         { file: runtimeFile("skills/learnings/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:learnings:hard_gate" },
         { file: runtimeFile("commands/start.md"), needle: "## Algorithm", name: "utility_command:start:algorithm" },
@@ -71,7 +71,7 @@ export async function policyChecks(projectRoot, options = {}) {
         { file: runtimeFile("skills/flow-view/SKILL.md"), needle: "## Diff Subcommand", name: "utility_skill:view:diff_section" },
         { file: runtimeFile("skills/subagent-dev/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:sdd:hard_gate" },
         { file: runtimeFile("skills/subagent-dev/SKILL.md"), needle: "## Status Contract", name: "utility_skill:sdd:status_contract" },
-        { file: runtimeFile("skills/subagent-dev/SKILL.md"), needle: "Implementer", name: "utility_skill:sdd:implementer_template" },
+        { file: runtimeFile("skills/subagent-dev/SKILL.md"), needle: "slice-implementer", name: "utility_skill:sdd:implementer_template" },
         { file: runtimeFile("skills/subagent-dev/SKILL.md"), needle: "## Model & Harness Routing Notes", name: "utility_skill:sdd:routing_notes" },
         { file: runtimeFile("skills/parallel-dispatch/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:parallel:hard_gate" },
         { file: runtimeFile("skills/parallel-dispatch/SKILL.md"), needle: "Review Army", name: "utility_skill:parallel:review_army" },
@@ -89,7 +89,7 @@ export async function policyChecks(projectRoot, options = {}) {
         { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Task classification", name: "meta_skill:task_classification" },
         { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Stage quick map", name: "meta_skill:stage_quick_map" },
         { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Whole flow map", name: "meta_skill:whole_flow_map" },
-        { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "retro -> compound -> archive", name: "meta_skill:closeout_chain" },
+        { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "post_ship_review -> archive", name: "meta_skill:closeout_chain" },
         { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Contextual Skill Activation", name: "meta_skill:contextual_skills" },
         { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Protocol Behavior", name: "meta_skill:protocol_behavior" },
         { file: runtimeFile("skills/using-cclaw/SKILL.md"), needle: "## Failure guardrails", name: "meta_skill:failure_guardrails" },

package/dist/retro-gate.js

@@ -1,34 +1,19 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { RUNTIME_ROOT } from "./constants.js";
-import { exists, stripBom } from "./fs-utils.js";
-import { readKnowledgeSafely } from "./knowledge-store.js";
+import { exists } from "./fs-utils.js";
 function activeArtifactsPath(projectRoot) {
     return path.join(projectRoot, RUNTIME_ROOT, "artifacts");
 }
 function retroArtifactPath(projectRoot) {
     return path.join(activeArtifactsPath(projectRoot), "09-retro.md");
 }
-// Fallback window for compound-entry scanning when `retroDraftedAt` /
-// `retroAcceptedAt` are not set (legacy runs or imports): use the retro
-// artifact's mtime ± 7 days. 24h was too narrow for long-running retros
-// that are edited over several days or runs imported from another
-// machine with slightly different clocks; 7 days is still tight enough
-// that entries from an unrelated future run are excluded.
-const RETRO_ARTIFACT_MTIME_FALLBACK_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
 function parseIsoTimestamp(value) {
     if (!value || value.trim().length === 0)
         return null;
     const parsed = Date.parse(value);
     return Number.isFinite(parsed) ? parsed : null;
 }
-function inInclusiveWindow(timestamp, windowStartMs, windowEndMs) {
-    if (windowStartMs !== null && timestamp < windowStartMs)
-        return false;
-    if (windowEndMs !== null && timestamp > windowEndMs)
-        return false;
-    return true;
-}
 export async function evaluateRetroGate(projectRoot, state) {
     const required = state.completedStages.includes("ship");
     const artifactFile = retroArtifactPath(projectRoot);
@@ -42,83 +27,16 @@ export async function evaluateRetroGate(projectRoot, state) {
             hasRetroArtifact = false;
         }
     }
-    let compoundEntries = 0;
-    let windowStartMs = parseIsoTimestamp(state.closeout.retroDraftedAt);
-    let windowEndMs = parseIsoTimestamp(state.closeout.retroAcceptedAt) ?? parseIsoTimestamp(state.retro.completedAt);
-    if (hasRetroArtifact &&
-        windowStartMs === null &&
-        windowEndMs === null) {
-        try {
-            const stats = await fs.stat(artifactFile);
-            const anchor = stats.mtimeMs;
-            if (Number.isFinite(anchor) && anchor > 0) {
-                windowStartMs = anchor - RETRO_ARTIFACT_MTIME_FALLBACK_WINDOW_MS;
-                windowEndMs = anchor + RETRO_ARTIFACT_MTIME_FALLBACK_WINDOW_MS;
-            }
-        }
-        catch {
-            // fallback scan remains disabled when mtime cannot be read
-        }
-    }
-    const shouldScanCompoundEvidence = windowStartMs !== null || windowEndMs !== null;
-    if (shouldScanCompoundEvidence) {
-        const countIfEligible = (parsed) => {
-            if (parsed.type !== "compound") {
-                return 0;
-            }
-            const created = typeof parsed.created === "string" ? parseIsoTimestamp(parsed.created) : null;
-            if (created === null || !inInclusiveWindow(created, windowStartMs, windowEndMs)) {
-                return 0;
-            }
-            const source = typeof parsed.source === "string"
-                ? parsed.source.trim().toLowerCase()
-                : null;
-            const legacyRetroStage = parsed.stage === "retro";
-            return source === "retro" || legacyRetroStage ? 1 : 0;
-        };
-        try {
-            const knowledgeFile = path.join(projectRoot, RUNTIME_ROOT, "knowledge.jsonl");
-            const { entries } = await readKnowledgeSafely(projectRoot);
-            for (const parsed of entries) {
-                compoundEntries += countIfEligible(parsed);
-            }
-            // Backward compatibility for historical/hand-edited rows that don't pass
-            // strict knowledge schema validation but still carry retro evidence.
-            if (compoundEntries === 0 && (await exists(knowledgeFile))) {
-                const raw = stripBom(await fs.readFile(knowledgeFile, "utf8"));
-                for (const line of raw.split(/\r?\n/)) {
-                    const trimmed = line.trim();
-                    if (!trimmed)
-                        continue;
-                    try {
-                        const parsed = JSON.parse(trimmed);
-                        compoundEntries += countIfEligible(parsed);
-                    }
-                    catch {
-                        // ignore malformed lines for retro gate calculation
-                    }
-                }
-            }
-        }
-        catch {
-            compoundEntries = 0;
-        }
-    }
-    // A retro is considered complete when any of:
-    //   - the retro artifact exists AND (at least one compound learning was
-    //     promoted during the retro window OR compound was explicitly skipped
-    //     after reviewing the draft), or
-    //   - the operator explicitly skipped the retro step itself
-    //     (`retroSkipped === true` with a non-empty reason). `retroSkipped` is an
-    //     operator-level override of the artifact requirement, so it must
-    //     bypass `hasRetroArtifact` — otherwise a run that legitimately had
-    //     nothing worth retro-ing dead-locks at closeout waiting for a
-    //     file that will never exist.
     const retroSkipReason = state.closeout.retroSkipReason?.trim() ?? "";
     const retroSkipped = state.closeout.retroSkipped === true && retroSkipReason.length > 0;
+    const retroAccepted = hasRetroArtifact && parseIsoTimestamp(state.closeout.retroAcceptedAt) !== null;
     const compoundSkipped = state.closeout.compoundSkipped === true;
-    const artifactPathComplete = hasRetroArtifact && (compoundEntries > 0 || compoundSkipped);
-    const completed = required ? retroSkipped || artifactPathComplete : true;
+    const compoundReviewed = parseIsoTimestamp(state.closeout.compoundCompletedAt) !== null ||
+        state.closeout.compoundPromoted > 0;
+    const compoundEntries = compoundReviewed ? Math.max(0, Math.floor(state.closeout.compoundPromoted)) : 0;
+    // Keep retro-gate deterministic from closeout state only:
+    // retroComplete = (retroAccepted || retroSkipped) && (compoundReviewed || compoundSkipped)
+    const completed = required ? (retroAccepted || retroSkipped) && (compoundReviewed || compoundSkipped) : true;
     return {
         required,
         completed,

package/dist/run-archive.js

@@ -17,12 +17,10 @@ const STATE_SNAPSHOT_EXCLUDE = new Set([
 ]);
 const DELEGATION_LOG_FILE = "delegation-log.json";
 const TDD_CYCLE_LOG_FILE = "tdd-cycle-log.jsonl";
-const RECONCILIATION_NOTICES_FILE = "reconciliation-notices.json";
 const CRITICAL_STATE_SNAPSHOT_FILES = new Set([
     "flow-state.json",
     DELEGATION_LOG_FILE,
-    TDD_CYCLE_LOG_FILE,
-    RECONCILIATION_NOTICES_FILE
+    TDD_CYCLE_LOG_FILE
 ]);
 function archiveRoot(projectRoot) {
     return path.join(projectRoot, ARCHIVE_DIR_REL_PATH);
@@ -89,7 +87,6 @@ async function resetCarryoverStateFiles(projectRoot, activeRunId) {
     await ensureDir(stateDir);
     await writeFileSafe(path.join(stateDir, DELEGATION_LOG_FILE), `${JSON.stringify({ runId: activeRunId, entries: [] }, null, 2)}\n`, { mode: 0o600 });
     await writeFileSafe(path.join(stateDir, TDD_CYCLE_LOG_FILE), "", { mode: 0o600 });
-    await writeFileSafe(path.join(stateDir, RECONCILIATION_NOTICES_FILE), `${JSON.stringify({ schemaVersion: 1, notices: [] }, null, 2)}\n`, { mode: 0o600 });
 }
 async function restoreStateSnapshot(projectRoot, archiveStatePath) {
     if (!(await exists(archiveStatePath)))

package/dist/run-persistence.js

@@ -17,11 +17,6 @@ export class InvalidStageTransitionError extends Error {
 const FLOW_STATE_REL_PATH = `${RUNTIME_ROOT}/state/flow-state.json`;
 const ARCHIVE_DIR_REL_PATH = `${RUNTIME_ROOT}/archive`;
 const ACTIVE_ARTIFACTS_REL_PATH = `${RUNTIME_ROOT}/artifacts`;
-const RECONCILIATION_NOTICES_REL_PATH = `${RUNTIME_ROOT}/state/reconciliation-notices.json`;
-const RECONCILIATION_NOTICES_LOCK_REL_PATH = `${RUNTIME_ROOT}/state/.reconciliation-notices.lock`;
-const RECONCILIATION_NOTICES_SCHEMA_VERSION = 1;
-const CLOSEOUT_SUBSTATE_DEMOTION_KIND = "closeout_substate_demotion";
-const CLOSEOUT_SUBSTATE_GATE_ID = "closeout.shipSubstate";
 const FLOW_STAGE_SET = new Set(FLOW_STAGES);
 function validateFlowTransition(prev, next) {
     if (prev.activeRunId !== next.activeRunId) {
@@ -74,88 +69,12 @@ function flowStatePath(projectRoot) {
 function flowStateLockPath(projectRoot) {
     return path.join(projectRoot, RUNTIME_ROOT, "state", ".flow-state.lock");
 }
-function reconciliationNoticesPath(projectRoot) {
-    return path.join(projectRoot, RECONCILIATION_NOTICES_REL_PATH);
-}
-function reconciliationNoticesLockPath(projectRoot) {
-    return path.join(projectRoot, RECONCILIATION_NOTICES_LOCK_REL_PATH);
-}
 function archiveRoot(projectRoot) {
     return path.join(projectRoot, ARCHIVE_DIR_REL_PATH);
 }
 function activeArtifactsPath(projectRoot) {
     return path.join(projectRoot, ACTIVE_ARTIFACTS_REL_PATH);
 }
-function asObjectRecord(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return null;
-    return value;
-}
-async function appendCloseoutSubstateDemotionNotice(projectRoot, state, demotion) {
-    await withDirectoryLock(reconciliationNoticesLockPath(projectRoot), async () => {
-        const filePath = reconciliationNoticesPath(projectRoot);
-        const existingNotices = [];
-        if (await exists(filePath)) {
-            try {
-                const raw = JSON.parse(await fs.readFile(filePath, "utf8"));
-                const parsed = asObjectRecord(raw);
-                const noticesRaw = parsed?.notices;
-                if (Array.isArray(noticesRaw)) {
-                    for (const notice of noticesRaw) {
-                        const typed = asObjectRecord(notice);
-                        if (typed)
-                            existingNotices.push(typed);
-                    }
-                }
-            }
-            catch {
-                // Keep going with an empty payload; sync can still report parse errors.
-            }
-        }
-        const alreadyRecorded = existingNotices.some((notice) => {
-            if (notice.runId !== state.activeRunId)
-                return false;
-            if (notice.kind !== CLOSEOUT_SUBSTATE_DEMOTION_KIND)
-                return false;
-            const payload = asObjectRecord(notice.payload);
-            return payload?.previous === demotion.previous &&
-                payload?.next === demotion.next &&
-                payload?.reason === demotion.reason;
-        });
-        if (alreadyRecorded)
-            return;
-        const ts = new Date().toISOString();
-        existingNotices.push({
-            id: `${state.activeRunId}:${state.currentStage}:${CLOSEOUT_SUBSTATE_GATE_ID}:${CLOSEOUT_SUBSTATE_DEMOTION_KIND}:${ts}`,
-            runId: state.activeRunId,
-            stage: state.currentStage,
-            gateId: CLOSEOUT_SUBSTATE_GATE_ID,
-            reason: demotion.reason,
-            demotedAt: ts,
-            kind: CLOSEOUT_SUBSTATE_DEMOTION_KIND,
-            payload: {
-                previous: demotion.previous,
-                next: demotion.next,
-                reason: demotion.reason
-            }
-        });
-        existingNotices.sort((left, right) => {
-            const leftTs = typeof left.demotedAt === "string" ? left.demotedAt : "";
-            const rightTs = typeof right.demotedAt === "string" ? right.demotedAt : "";
-            if (leftTs === rightTs) {
-                const leftId = typeof left.id === "string" ? left.id : "";
-                const rightId = typeof right.id === "string" ? right.id : "";
-                return leftId.localeCompare(rightId);
-            }
-            return leftTs.localeCompare(rightTs);
-        });
-        await ensureDir(path.dirname(filePath));
-        await writeFileSafe(filePath, `${JSON.stringify({
-            schemaVersion: RECONCILIATION_NOTICES_SCHEMA_VERSION,
-            notices: existingNotices
-        }, null, 2)}\n`, { mode: 0o600 });
-    });
-}
 function isFlowStage(value) {
     return typeof value === "string" && FLOW_STAGE_SET.has(value);
 }
@@ -338,14 +257,20 @@ function sanitizeRetroState(value) {
 function isShipSubstate(value) {
     return typeof value === "string" && SHIP_SUBSTATES.includes(value);
 }
-function sanitizeCloseoutState(value, onDemotion) {
+function sanitizeCloseoutState(value) {
     const fallback = createInitialCloseoutState();
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return fallback;
     }
     const typed = value;
-    let shipSubstate = isShipSubstate(typed.shipSubstate) ? typed.shipSubstate : fallback.shipSubstate;
-    const previousShipSubstate = shipSubstate;
+    const rawShipSubstate = typeof typed.shipSubstate === "string" ? typed.shipSubstate : undefined;
+    let shipSubstate;
+    if (rawShipSubstate === "retro_review" || rawShipSubstate === "compound_review") {
+        shipSubstate = "post_ship_review";
+    }
+    else {
+        shipSubstate = isShipSubstate(rawShipSubstate) ? rawShipSubstate : fallback.shipSubstate;
+    }
     const retroDraftedAt = typeof typed.retroDraftedAt === "string" ? typed.retroDraftedAt : undefined;
     const retroAcceptedAt = typeof typed.retroAcceptedAt === "string" ? typed.retroAcceptedAt : undefined;
     const retroSkipReason = typeof typed.retroSkipReason === "string"
@@ -370,21 +295,8 @@ function sanitizeCloseoutState(value, onDemotion) {
     // the compound leg, which would let `archive` skip durable closeout proof.
     const retroDone = retroAcceptedAt !== undefined || retroSkipped === true;
     const compoundDone = compoundCompletedAt !== undefined || compoundPromoted > 0 || compoundSkipped === true;
-    let demotionReason;
-    if (!retroDone && (shipSubstate === "ready_to_archive" || shipSubstate === "compound_review")) {
-        shipSubstate = "retro_review";
-        demotionReason = "retro closeout leg is incomplete (missing retroAcceptedAt or explicit retro skip).";
-    }
-    else if (shipSubstate === "ready_to_archive" && !compoundDone) {
-        shipSubstate = "compound_review";
-        demotionReason = "compound closeout leg is incomplete (missing compound proof).";
-    }
-    if (demotionReason && previousShipSubstate !== shipSubstate) {
-        onDemotion?.({
-            previous: previousShipSubstate,
-            next: shipSubstate,
-            reason: demotionReason
-        });
+    if (shipSubstate === "ready_to_archive" && (!retroDone || !compoundDone)) {
+        shipSubstate = "post_ship_review";
     }
     return {
         shipSubstate,
@@ -405,7 +317,6 @@ function coerceFlowState(parsed) {
     const activeRunId = typeof activeRunIdRaw === "string" && activeRunIdRaw.trim().length > 0
         ? activeRunIdRaw.trim()
         : next.activeRunId;
-    let closeoutDemotion;
     const state = {
         schemaVersion: FLOW_STATE_SCHEMA_VERSION,
         activeRunId,
@@ -418,11 +329,9 @@ function coerceFlowState(parsed) {
         staleStages: sanitizeStaleStages(parsed.staleStages),
         rewinds: sanitizeRewinds(parsed.rewinds),
         retro: sanitizeRetroState(parsed.retro),
-        closeout: sanitizeCloseoutState(parsed.closeout, (demotion) => {
-            closeoutDemotion = demotion;
-        })
+        closeout: sanitizeCloseoutState(parsed.closeout)
     };
-    return { state, closeoutDemotion };
+    return { state };
 }
 export class CorruptFlowStateError extends Error {
     statePath;
@@ -484,11 +393,7 @@ export async function readFlowState(projectRoot, options = {}) {
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
         await quarantineCorruptState(statePath, new Error("flow-state.json did not deserialize to a JSON object"));
     }
-    const coerced = coerceFlowState(parsed);
-    if (coerced.closeoutDemotion) {
-        await appendCloseoutSubstateDemotionNotice(projectRoot, coerced.state, coerced.closeoutDemotion);
-    }
-    return coerced.state;
+    return coerceFlowState(parsed).state;
 }
 export async function writeFlowState(projectRoot, state, options = {}) {
     const doWrite = async () => {

package/dist/runtime/run-hook.entry.d.ts

@@ -0,0 +1,3 @@
+import { type NodeHookRuntimeOptions } from "../content/node-hooks.js";
+export declare function buildRunHookRuntimeScript(options?: NodeHookRuntimeOptions): string;
+export default buildRunHookRuntimeScript;

package/dist/runtime/run-hook.entry.js

@@ -0,0 +1,5 @@
+import { nodeHookRuntimeScript } from "../content/node-hooks.js";
+export function buildRunHookRuntimeScript(options = {}) {
+    return nodeHookRuntimeScript(options);
+}
+export default buildRunHookRuntimeScript;