cclaw-cli 0.55.2 → 2.0.0

package/dist/knowledge-store.d.ts

@@ -2,8 +2,6 @@ import { type FlowStage } from "./types.js";
 export type KnowledgeEntryType = "rule" | "pattern" | "lesson" | "compound";
 export type KnowledgeEntryConfidence = "high" | "medium" | "low";
 export type KnowledgeEntrySeverity = "critical" | "important" | "suggestion";
-export type KnowledgeEntryUniversality = "project" | "personal" | "universal";
-export type KnowledgeEntryMaturity = "raw" | "lifted-to-rule" | "lifted-to-enforcement";
 export type KnowledgeEntrySource = "stage" | "retro" | "compound" | "idea" | "manual";
 export interface KnowledgeEntry {
     type: KnowledgeEntryType;
@@ -11,20 +9,14 @@ export interface KnowledgeEntry {
     action: string;
     confidence: KnowledgeEntryConfidence;
     severity?: KnowledgeEntrySeverity;
-    domain: string | null;
     stage: FlowStage | null;
     origin_stage: FlowStage | null;
-    origin_run: string | null;
     frequency: number;
-    universality: KnowledgeEntryUniversality;
-    maturity: KnowledgeEntryMaturity;
     created: string;
     first_seen_ts: string;
     last_seen_ts: string;
     project: string | null;
     source?: KnowledgeEntrySource | null;
-    supersedes?: string[];
-    superseded_by?: string;
 }
 export interface KnowledgeSeedEntry {
     type: KnowledgeEntryType;
@@ -32,25 +24,18 @@ export interface KnowledgeSeedEntry {
     action: string;
     confidence: KnowledgeEntryConfidence;
     severity?: KnowledgeEntrySeverity;
-    domain?: string | null;
     stage?: FlowStage | null;
     origin_stage?: FlowStage | null;
-    origin_run?: string | null;
     frequency?: number;
-    universality?: KnowledgeEntryUniversality;
-    maturity?: KnowledgeEntryMaturity;
     created?: string;
     first_seen_ts?: string;
     last_seen_ts?: string;
     project?: string | null;
     source?: KnowledgeEntrySource | null;
-    supersedes?: string[];
-    superseded_by?: string;
 }
 export interface AppendKnowledgeDefaults {
     stage?: FlowStage | null;
     originStage?: FlowStage | null;
-    originRun?: string | null;
     project?: string | null;
     source?: KnowledgeEntrySource | null;
     nowIso?: string;
@@ -98,8 +83,6 @@ export interface CompoundReadinessCluster {
     lastSeenTs: string;
     /** Entry types observed (rule/pattern/lesson/compound). */
     types: KnowledgeEntryType[];
-    /** Distinct maturity values observed across the cluster. */
-    maturity: KnowledgeEntryMaturity[];
 }
 export interface CompoundReadiness {
     schemaVersion: 2;
@@ -167,9 +150,8 @@ export declare function effectiveCompoundThreshold(baseThreshold: number, archiv
  *
  * 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 declare function computeCompoundReadiness(entries: KnowledgeEntry[], options?: ComputeCompoundReadinessOptions): CompoundReadiness;
 export declare function validateKnowledgeEntry(entry: unknown): {

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.d.ts

@@ -42,5 +42,5 @@ export declare function flowStateLockPathFor(projectRoot: string): string;
 interface EnsureRunSystemOptions {
     createIfMissing?: boolean;
 }
-export declare function ensureRunSystem(projectRoot: string, _options?: EnsureRunSystemOptions): Promise<FlowState>;
+export declare function ensureRunSystem(projectRoot: string, options?: EnsureRunSystemOptions): Promise<FlowState>;
 export {};