cclaw-cli 0.51.30 → 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,13 +137,13 @@ 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",
     "compound",
-    "ideate",
+    "idea",
     "manual"
 ]);
 const FLOW_STAGE_SET = new Set(FLOW_STAGES);
@@ -158,25 +152,49 @@ 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");
 KNOWLEDGE_ALLOWED_KEYS.add("superseded_by");
-function keyAllowedInKnowledgeEntry(key, options) {
-    return KNOWLEDGE_ALLOWED_KEYS.has(key) || (options.allowLegacyOriginFeature === true && key === "origin_feature");
+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() {
@@ -219,13 +232,6 @@ function emptyKnowledgeSnapshot() {
         entryByIndex: new Map()
     };
 }
-function normalizeLegacyKnowledgeEntry(entry) {
-    const { origin_feature: legacyOriginRun, ...rest } = entry;
-    return {
-        ...rest,
-        origin_run: entry.origin_run ?? legacyOriginRun ?? null
-    };
-}
 function parseKnowledgeSnapshot(raw) {
     const lines = stripBom(raw).split(/\r?\n/u);
     const entries = [];
@@ -238,12 +244,12 @@ function parseKnowledgeSnapshot(raw) {
             continue;
         try {
             const parsed = JSON.parse(trimmed);
-            const validated = validateKnowledgeEntry(parsed, { allowLegacyOriginFeature: true });
+            const validated = validateKnowledgeEntry(parsed);
             if (!validated.ok) {
                 malformedLines += 1;
                 continue;
             }
-            const entry = normalizeLegacyKnowledgeEntry(parsed);
+            const entry = normalizeParsedKnowledgeEntry(parsed);
             entries.push(entry);
             const key = dedupeKey(entry);
             if (!keyToIndex.has(key)) {
@@ -296,24 +302,20 @@ function isNullableString(value) {
 function isNullableStage(value) {
     return value === null || (typeof value === "string" && FLOW_STAGE_SET.has(value));
 }
-export function validateKnowledgeEntry(entry, options = {}) {
+export function validateKnowledgeEntry(entry) {
     const errors = [];
     if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
         return { ok: false, errors: ["Knowledge entry must be a JSON object."] };
     }
     const obj = entry;
     for (const key of Object.keys(obj)) {
-        if (!keyAllowedInKnowledgeEntry(key, options)) {
+        if (!keyAllowedInKnowledgeEntry(key)) {
             errors.push(`Unknown key "${key}" in knowledge entry.`);
         }
     }
     for (const key of KNOWLEDGE_REQUIRED_KEYS) {
         if (!Object.prototype.hasOwnProperty.call(obj, key)) {
-            if (key !== "origin_run" ||
-                options.allowLegacyOriginFeature !== true ||
-                !Object.prototype.hasOwnProperty.call(obj, "origin_feature")) {
-                errors.push(`Missing required key "${key}".`);
-            }
+            errors.push(`Missing required key "${key}".`);
         }
     }
     if (!KNOWLEDGE_TYPE_SET.has(obj.type)) {
@@ -332,7 +334,7 @@ export function validateKnowledgeEntry(entry, options = {}) {
         (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)) {
@@ -341,12 +343,8 @@ export function validateKnowledgeEntry(entry, options = {}) {
     if (!isNullableStage(obj.origin_stage)) {
         errors.push(`origin_stage must be one of ${FLOW_STAGES.join(", ")} or null.`);
     }
-    const originRun = Object.prototype.hasOwnProperty.call(obj, "origin_run")
-        ? obj.origin_run
-        : options.allowLegacyOriginFeature === true
-            ? obj.origin_feature
-            : undefined;
-    if (!isNullableString(originRun)) {
+    const originRun = obj.origin_run;
+    if (originRun !== undefined && !isNullableString(originRun)) {
         errors.push("origin_run must be string or null.");
     }
     if (typeof obj.frequency !== "number" ||
@@ -354,10 +352,12 @@ export function validateKnowledgeEntry(entry, options = {}) {
         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"]) {
@@ -380,10 +380,12 @@ export function validateKnowledgeEntry(entry, options = {}) {
         (typeof obj.superseded_by !== "string" || obj.superseded_by.trim().length === 0)) {
         errors.push("superseded_by must be a non-empty string when present.");
     }
-    if (obj.source !== undefined &&
-        obj.source !== null &&
-        (typeof obj.source !== "string" || !KNOWLEDGE_SOURCE_SET.has(obj.source))) {
-        errors.push("source must be one of: stage, retro, compound, ideate, manual, or null.");
+    const sourceAllowed = obj.source === undefined ||
+        obj.source === null ||
+        (typeof obj.source === "string" &&
+            KNOWLEDGE_SOURCE_SET.has(obj.source));
+    if (!sourceAllowed) {
+        errors.push("source must be one of: stage, retro, compound, idea, manual, or null.");
     }
     return { ok: errors.length === 0, errors };
 }
@@ -391,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 ?? seed.origin_feature ?? 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),
@@ -413,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;
     }
@@ -527,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 [];
@@ -560,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) {
@@ -580,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/managed-resources.js

@@ -60,7 +60,7 @@ export function isManagedGeneratedPath(relPath) {
         return false;
     if (relPath.startsWith(`${RUNTIME_ROOT}/artifacts/`))
         return false;
-    if (relPath.startsWith(`${RUNTIME_ROOT}/runs/`))
+    if (relPath.startsWith(`${RUNTIME_ROOT}/archive/`))
         return false;
     if (relPath === `${RUNTIME_ROOT}/state/flow-state.json`)
         return false;
@@ -209,7 +209,29 @@ export class ManagedResourceSession {
         }
     }
     static async create(options) {
-        const previous = await readManagedResourceManifest(options.projectRoot).catch(() => null);
+        const manifestPath = path.join(options.projectRoot, MANAGED_RESOURCE_MANIFEST_REL_PATH);
+        let previous = null;
+        if (await exists(manifestPath)) {
+            let raw;
+            try {
+                raw = JSON.parse(await fs.readFile(manifestPath, "utf8"));
+            }
+            catch (error) {
+                throw new Error(`[sync fail-fast] Managed resource manifest is corrupt JSON (${MANAGED_RESOURCE_MANIFEST_REL_PATH}): ${error instanceof Error ? error.message : String(error)}. Fix/remove the manifest and rerun \`npx cclaw-cli sync\`.`);
+            }
+            const issues = validateManagedResourceManifest(raw);
+            if (issues.length > 0) {
+                const detail = issues.slice(0, 12)
+                    .map((issue) => {
+                    const scope = issue.path ?? (issue.index !== undefined ? `resources[${issue.index}]` : "manifest");
+                    return `${scope}.${issue.field}: ${issue.message}`;
+                })
+                    .join("; ");
+                throw new Error(`[sync fail-fast] Managed resource manifest is malformed (${MANAGED_RESOURCE_MANIFEST_REL_PATH}): ${detail}. ` +
+                    `Fix/remove the manifest and rerun \`npx cclaw-cli sync\`.`);
+            }
+            previous = await readManagedResourceManifest(options.projectRoot).catch(() => null);
+        }
         return new ManagedResourceSession(options, previous);
     }
     shouldManage(filePath) {

package/dist/policy.js

@@ -58,22 +58,20 @@ 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" },
-        { file: runtimeFile("commands/next.md"), needle: "## Algorithm", name: "utility_command:next:algorithm" },
-        { file: runtimeFile("commands/next.md"), needle: "closeout.shipSubstate", name: "utility_command:next:closeout_chain" },
-        { file: runtimeFile("commands/ideate.md"), needle: "## Algorithm", name: "utility_command:ideate:algorithm" },
-        { file: runtimeFile("skills/flow-ideate/SKILL.md"), needle: "## Protocol", name: "utility_skill:ideate:protocol" },
-        { file: runtimeFile("skills/flow-ideate/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:ideate:hard_gate" },
+        { file: runtimeFile("commands/idea.md"), needle: "## Algorithm", name: "utility_command:idea:algorithm" },
+        { file: runtimeFile("skills/flow-idea/SKILL.md"), needle: "## Protocol", name: "utility_skill:idea:protocol" },
+        { file: runtimeFile("skills/flow-idea/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:idea:hard_gate" },
         { file: runtimeFile("commands/view.md"), needle: "## Routing", name: "utility_command:view:routing" },
         { file: runtimeFile("skills/flow-view/SKILL.md"), needle: "## Status Subcommand", name: "utility_skill:view:status_section" },
         { file: runtimeFile("skills/flow-view/SKILL.md"), needle: "## Tree Subcommand", name: "utility_skill:view:tree_section" },
         { 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" },
@@ -91,12 +89,12 @@ 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" },
         { file: runtimeFile("skills/session/SKILL.md"), needle: "## Session Resume Protocol", name: "utility_skill:session:resume" },
-        { file: runtimeFile("skills/brainstorming/SKILL.md"), needle: "## Shared Stage Guidance", name: "stage_skill:shared_guidance_inline" },
+        { file: runtimeFile("skills/brainstorm/SKILL.md"), needle: "## Shared Stage Guidance", name: "stage_skill:shared_guidance_inline" },
         { file: runtimeFile("hooks/run-hook.mjs"), needle: "activeRunId", name: "hooks:session_start:active_run" },
         { file: runtimeFile("hooks/run-hook.mjs"), needle: "write_to_cclaw_runtime", name: "hooks:guard:risky_write_advisory" },
         { file: runtimeFile("hooks/run-hook.mjs"), needle: "stage_invocation_without_recent_flow_read", name: "hooks:workflow_guard:flow_read_reason" },

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

@@ -56,6 +56,6 @@ export declare function archiveRun(projectRoot: string, runName?: string, option
  * Counts entries in the canonical JSONL knowledge store. An "active" entry is one
  * non-empty line that parses as JSON with the required `type` field belonging to the
  * allowed set. Malformed lines are ignored (not counted) but do not throw so that a
- * hand-edited file cannot break doctor/archive flows.
+ * hand-edited file cannot break sync/archive flows.
  */
 export declare function countActiveKnowledgeEntries(text: string): number;

package/dist/run-archive.js

@@ -7,7 +7,7 @@ import { readKnowledgeSafely } from "./knowledge-store.js";
 import { evaluateRetroGate } from "./retro-gate.js";
 import { ensureRunSystem, flowStateLockPathFor, readFlowState, writeFlowState } from "./run-persistence.js";
 export const ARCHIVE_DISPOSITIONS = ["completed", "cancelled", "abandoned"];
-const RUNS_DIR_REL_PATH = `${RUNTIME_ROOT}/runs`;
+const ARCHIVE_DIR_REL_PATH = `${RUNTIME_ROOT}/archive`;
 const ACTIVE_ARTIFACTS_REL_PATH = `${RUNTIME_ROOT}/artifacts`;
 const STATE_DIR_REL_PATH = `${RUNTIME_ROOT}/state`;
 /** State filenames explicitly excluded from the archive snapshot. */
@@ -17,15 +17,13 @@ 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 runsRoot(projectRoot) {
-    return path.join(projectRoot, RUNS_DIR_REL_PATH);
+function archiveRoot(projectRoot) {
+    return path.join(projectRoot, ARCHIVE_DIR_REL_PATH);
 }
 function activeArtifactsPath(projectRoot) {
     return path.join(projectRoot, ACTIVE_ARTIFACTS_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)))
@@ -150,14 +147,14 @@ async function inferRunNameFromArtifacts(projectRoot) {
 async function uniqueArchiveId(projectRoot, baseId) {
     let index = 1;
     let candidate = baseId;
-    while (await exists(path.join(runsRoot(projectRoot), candidate))) {
+    while (await exists(path.join(archiveRoot(projectRoot), candidate))) {
         index += 1;
         candidate = `${baseId}-${index}`;
     }
     return candidate;
 }
 export async function listRuns(projectRoot) {
-    const root = runsRoot(projectRoot);
+    const root = archiveRoot(projectRoot);
     if (!(await exists(root))) {
         return [];
     }
@@ -194,15 +191,15 @@ export async function archiveRun(projectRoot, runName, options = {}) {
     return withDirectoryLock(archiveLockPath(projectRoot), async () => {
         return withDirectoryLock(flowStateLockPathFor(projectRoot), async () => {
             const artifactsDir = activeArtifactsPath(projectRoot);
-            const runsDir = runsRoot(projectRoot);
-            await ensureDir(runsDir);
+            const archiveDir = archiveRoot(projectRoot);
+            await ensureDir(archiveDir);
             await ensureDir(artifactsDir);
             const archiveRunName = (runName?.trim() && runName.trim().length > 0)
                 ? runName.trim()
                 : await inferRunNameFromArtifacts(projectRoot);
             const archiveBaseId = `${toArchiveDate()}-${slugifyRunName(archiveRunName)}`;
             const archiveId = await uniqueArchiveId(projectRoot, archiveBaseId);
-            const archivePath = path.join(runsDir, archiveId);
+            const archivePath = path.join(archiveDir, archiveId);
             const archiveArtifactsPath = path.join(archivePath, "artifacts");
             let sourceState = await readFlowState(projectRoot);
             const retroGate = await evaluateRetroGate(projectRoot, sourceState);
@@ -273,7 +270,7 @@ export async function archiveRun(projectRoot, runName, options = {}) {
             await ensureDir(archivePath);
             // Drop an `.archive-in-progress` sentinel immediately so that a crash
             // between the artifact rename and the final manifest write leaves a
-            // recoverable marker (doctor surfaces these; re-running archive on an
+            // recoverable marker (sync reports these; re-running archive on an
             // orphan attempts to complete or roll back). The sentinel is removed
             // only after the manifest lands successfully.
             const sentinelPath = path.join(archivePath, ".archive-in-progress");
@@ -326,7 +323,7 @@ export async function archiveRun(projectRoot, runName, options = {}) {
                 // Best-effort rollback: if artifacts were moved but the subsequent
                 // steps failed, put artifacts back so the user is not left without
                 // a working run. The sentinel is intentionally left behind for
-                // inspection; doctor surfaces it.
+                // inspection; sync reports it.
                 if (artifactsMoved) {
                     try {
                         await fs.rm(artifactsDir, { recursive: true, force: true });
@@ -334,7 +331,7 @@ export async function archiveRun(projectRoot, runName, options = {}) {
                     }
                     catch {
                         // Rollback failed — sentinel + orphaned archive dir will be
-                        // surfaced by doctor and can be reconciled manually.
+                        // surfaced by sync and can be reconciled manually.
                     }
                 }
                 if (stateReset) {
@@ -371,7 +368,7 @@ async function readKnowledgeStats(projectRoot) {
  * Counts entries in the canonical JSONL knowledge store. An "active" entry is one
  * non-empty line that parses as JSON with the required `type` field belonging to the
  * allowed set. Malformed lines are ignored (not counted) but do not throw so that a
- * hand-edited file cannot break doctor/archive flows.
+ * hand-edited file cannot break sync/archive flows.
  */
 export function countActiveKnowledgeEntries(text) {
     const allowed = new Set(["rule", "pattern", "lesson", "compound"]);