0xray 4.0.22 → 4.0.23

package/.grok-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "0xray",
-  "version": "4.0.22",
+  "version": "4.0.23",
   "description": "0xRay suit for Grok, Hermes, OpenClaw, OpenCode: mill+inspect, Codex, 7 MCP servers. Costume 45/42 is opt-in foundry, not the default wear.",
   "author": {
     "name": "0xRay AI",

package/.opencode/skills/orchestrator/SKILL.md

@@ -7,15 +7,15 @@ version: 1.0.0
 schema_version: "1.0"
 tags: [orchestration, orchestrator, lead-dev]
 capabilities:
-  - coordinate_agents
-  - delegate_tasks
-  - manage_workflow
+ - coordinate_agents
+ - delegate_tasks
+ - manage_workflow
 dependencies: []
 
 mcp:
-  orchestrator:
-    command: node
-    args: [node_modules/0xray/dist/mcps/orchestrator.server.js]
+ orchestrator:
+ command: node
+ args: [node_modules/0xray/dist/mcps/orchestrator.server.js]
 ---
 
 # Orchestrator Skill — includes lead-dev operating model
@@ -77,7 +77,7 @@ Jargon is not the job. Review and cadence ask whether the change works. Do not s
 - **Live tick, not pacer:** `/loop` runs work now. Keep workstreams moving. Do not idle-wait 12 minutes. **Clean ticks every cycle** — unsubscribe then resubscribe so the prompt matches metal. Name-dedupe does not rewrite. A stale prompt (waiting URL after live, Hold after strip) is dirty: rewrite, do not act. **If the card and WAVEBOARD are idle, unsubscribe and do not resubscribe.**
 - **Board clock:** PR events + resume the same critic. Not two idle pacers. Merge after PASS+CI (gate A). Publish only after mill-gate D + `foundry gate`.
 - **Dispatch:** ticket + PR URLs + “Wear, then review.” The critic Reads `SEATS.md` Reviewer. Do not paste a command novel. When a law is spoken twice, encode it this wake.
-- **Cascade:** Chat is not the brain. A cascade that must survive compaction is a named repertoire signal on the stack overlay, hydrated onto the project law list. NOTES holds the same cascade for the second Read. Station stays the ticket. A reflection is not this capture. Capture priority: a law is an invariant you would otherwise re-read the source to relearn. One law per subsystem bone. Heat touches last_seen and does not append a confidence sample, so more hits do not raise conviction. Heat touches last_seen only when the diary contains that signal's name; two definition words are not a hit; a weak session score is not lifted to 0.55 and a sample below 0.55 is not recorded. Constructing the organ does not append workspace samples. Hero names: `heat-is-not-conviction`, `inference-cycle-invariant`, `governance-vote-invariant`, `thin-dispatch-invariant`. Repertoire mergeStackOverlay refreshes a changed stack definition and keeps observation stats.
+- **Cascade:** Chat is not the brain. A cascade that must survive compaction is a named repertoire signal on the stack overlay, hydrated onto the project law list. NOTES holds the same cascade for the second Read. Station stays the ticket. A reflection is not this capture. Capture priority: a law is an invariant you would otherwise re-read the source to relearn. One law per subsystem bone. Heat touches last_seen and does not append a confidence sample, so more hits do not raise conviction. Heat touches last_seen when the diary contains that signal's name or a local clause of four definition content words; two definition words are not a hit; the same words scattered through a long diary are not a hit; a weak session score is not lifted to 0.55 and a sample below 0.55 is not recorded. Constructing the organ does not append workspace samples. Hero names: `heat-is-not-conviction`, `inference-cycle-invariant`, `governance-vote-invariant`, `thin-dispatch-invariant`. Repertoire mergeStackOverlay refreshes a changed stack definition and keeps observation stats. A floor observation count does not change a route. Feedback moves conviction by a tenth, and a failure can leave 0.55. learned-conviction.json beside dest restores that average when a wake flattens it to 0.55. It does not store the observation count.
 - **Cold brief:** a new critic or any new subagent that does not already have this thread gets the latest commit SHA on the branch under review (fetch it; do not reuse an earlier SHA from a previous pass) and the Station card (`.xray/state/STATION.md`: intent, plan, git). If the card is missing, give branch + HEAD + what just changed. If the branch moves after you brief them, send the new SHA before they verdict.
 - **Control:** The lead keeps control. Do not assume the subagent has the context. Give the duty, the latest SHA, the Station card, and the laws that apply. The subagent wears the applicable 0xRay suit before it works: the tree under review, built and installed. An older published package is not that suit. The lead checks the result.
 

package/.xray/features.json

@@ -1,6 +1,6 @@
 {
   "$schema": "./features.schema.json",
-  "version": "4.0.22",
+  "version": "4.0.23",
   "description": "0xRay Framework - Unified Feature Configuration",
   "suit_temperament": {
     "profile": "auto",

package/dist/CHANGELOG.md

@@ -10,11 +10,19 @@ The format is based on [Conventional Commits](https://www.conventionalcommits.or
 - **Feat rebase.** When the mandated work turns into mantra, or the job has split across planes that no longer share one present, stop and answer the original message again from this seat. On `LEAD-CADENCE.md`, the orchestrator skill, and the ship-ready mill gate. Project dest grows the name `feat-rebase` from the stack overlay. Not a new skill.
 
 ### Fixed
+- **A governed proposal teaches.** A route lookup does not write a lesson. When a vote finishes, the cycle grades the signals that proposal's sessions already named. A session that names a stored signal is graded even when that name appears once. Landed approaches and no wrong turn clear the solid band. A wrong turn stays below the cutoff. Earlier rejects of other codify proposals do not pull that grade down. Approve steps those signals up by a tenth. Reject steps them down by a tenth. Needs-revision, an abstain, a governance error, and a proposal whose sessions named nothing do not write. Proposal ids stay on the signal and the sessions not yet graded, so a later cycle does not teach those sessions again. A new session is a new id. Those ids remain after the history window of 50 fills, including with empty cycles. A proposal that carries an empty name list does not fall through to matching its text. A grade that passes appends one line — the task, the decision, and the approaches, solutions, or wrong turn from the sessions that named the law — on that signal and beside the average. The same task does not append again. The route for a law above 0.55 includes the law text and those lines, and Station's lessons section is refreshed from dest. Not a new skill.
+- **Dynamo client on a required external call.** `govern_proposals` with external governance required starts `InferenceGovernanceIntegration` even when `inference_governance.enabled` is false. Boot still skips that client while the flag is off, and the inference cycle still uses the local matrix unless the flag is on or `XRAY_FORCE_MCP_GOVERNANCE=true`. An unreadable MCP payload is stored as the error text, not an abstain at 0.5. The MCP wait matches the governance budget (90s). Not a new skill.
+- **Subsystem pass.** A session file with no `metrics.commits` is not a session, and a captured pattern with no `evidence` array is empty evidence, so the inference cycle no longer dies before it writes state. `scoreAndRoute` loads the memory organ on the first call with a synchronous require, before any dynamic import of that module. A cached null provider does not block that load, and a late null load does not replace an organ already in hand. Not a new skill.
+- **Local governance pass.** When `inference_governance.enabled` is false, the inference cycle scores each proposal with the local decision matrix. That miss is not stored as a reject at confidence 0, and Dynamo is not called. The governance MCP path stays in place when the flag is on. Not a new skill.
+- **Learned conviction.** A floor observation count does not change a route. Feedback moves conviction by a tenth, and a failure can leave 0.55. Retrieval hits a local clause of four definition content words. Two definition words are not a hit. The same words scattered through a long diary are not a hit. x402 prose alone is not a hit. `learned-conviction.json` beside dest restores the average when a wake flattens it to 0.55 and does not store the observation count. The vendored organ dist matches that behavior. Not a new skill.
+- **Seeded conviction.** Load writes `learned-conviction.json` for dest averages already above 0.55, including historical averages with no evidence count. Evidence is the existing positive count, otherwise 1. Floor averages, including float dust at 0.55, stay out of the file. A later load restores those averages after a flatten. The vendored organ dist matches that behavior. Not a new skill.
+- **Lock matches the cut.** `package-lock.json` root version and `packages[""].version` follow `package.json` on stamp. The 4.0.22 release left the lock at 4.0.21. Not a new skill.
+- **Bumper writes the lock.** `reconcile --apply` updates `package.json` and the lock version fields together. `reconcile --check` (the docs mill in CI) fails when they differ. Not a new skill.
 - **Cursor gate root.** The suit mill already has synthesis off. Cursor tools follow that mill when it is in the heat set, so a sibling repo's leftover synthesis checkpoint does not deny the host. Not a new skill.
 - **Engine cadence.** Change the engine, ship it local (build and install the tree; a live cut stays live), test, review the diff, monitor dest and Station, then ship the PR. Missing moral fusion is not an isotopic reject; vote confidence is a clamped weighted mean; thinDispatch strategy follows the adjusted level; an empty inference cycle saves state and later getInstance options apply. On `LEAD-CADENCE.md`, the orchestrator skill, and the ship-ready mill gate. Not a new skill.
 - **Operating planes.** Code, OP-PROC, model, suit, mill, host, and test/ship. Test then ship is the hero; ship without that proof is the catastrophe. Project long-term memory refreshes a changed stack definition and keeps observation stats. Heat writes the matched names onto Station. Name `operating-planes` on the stack overlay. Not a new skill.
 - **Wake cascade.** Chat is not the brain. A cascade that must survive compaction is the repertoire name `wake-cascade` on the stack overlay, with the same text in NOTES for the second Read. A reflection is not this capture. Not a new skill.
-- **Hero invariants.** Capture priority is an invariant you would otherwise re-read the source to relearn. Names: `heat-is-not-conviction`, `inference-cycle-invariant`, `governance-vote-invariant`, `thin-dispatch-invariant`. Heat touches last_seen and does not append a confidence sample. Heat touches last_seen only when the diary contains that signal's name; two definition words are not a hit; a weak session score is not lifted to 0.55 and a sample below 0.55 is not recorded. Constructing the organ does not append workspace samples. Repertoire `mergeStackOverlay` refreshes a changed stack definition and keeps observation stats. Not a new skill.
+- **Hero invariants.** Capture priority is an invariant you would otherwise re-read the source to relearn. Names: `heat-is-not-conviction`, `inference-cycle-invariant`, `governance-vote-invariant`, `thin-dispatch-invariant`. Heat touches last_seen and does not append a confidence sample. Heat touches last_seen when the diary contains that signal's name or a local clause of four definition content words; two definition words are not a hit; the same words scattered through a long diary are not a hit; a weak session score is not lifted to 0.55 and a sample below 0.55 is not recorded. Constructing the organ does not append workspace samples. Repertoire `mergeStackOverlay` refreshes a changed stack definition and keeps observation stats. Not a new skill.
 - **Stamper strip set.** Once a version is live, the stamper strips every present-tense patch pin from shipped guides and shipped OP-PROC, or reconcile advances the next cut. The stamper does not edit Station, NOTES, dest, or node_modules. It does not publish. The release docs check uses that same strip set, including `grok-bot/skills/ship-ready-mill-gate/SKILL.md`. Proposal text stays a keyword map over session problem strings, and `generateProposals` also emits recurring-pattern titles. Not a new skill.
 - **Heat + capture leftover** — module-missing resume is `Repertoire: module unresolved`, not “memory_routing stays off”. Session capture writes `matched_primitives` from existing dest laws in git. Grow receipt is post-prune dest count + heated length. Leftover `provider: null` still migrates old tarballs; explicit opt-out stays `enabled: false` + `provider: repertoire`. Does not republish.
 
@@ -29,6 +37,21 @@ The format is based on [Conventional Commits](https://www.conventionalcommits.or
 - Archive root `integrations/` costume SKILL dump → `docs/archive/integrations-costume/`. Live wear is `src/integrations`.
 - Archive root `commands/` stale copy → `docs/archive/commands-copy/`. Live wear is `src/opencode/commands`.
 
+## [4.0.23] - 2026-09-23
+
+### 🔄 Changes
+
+### 🐛 Bug Fixes
+- fix: start the Dynamo client when external governance is required (d17b9cf19)
+- fix: score proposals locally when inference governance is off (ae8075116)
+- fix: finish the inference cycle and load the organ before routing (69522e6c3)
+- fix: vendor the organ that seeds conviction above the floor (103961128)
+- fix: vendor the organ that routes on conviction, not a floor count (24d215a5a)
+- fix: reconcile writes the lock version when it bumps (434ddafef)
+- fix: package-lock version follows package.json on stamp (026c36d55)
+
+---
+
 ## [4.0.22] - 2026-09-23
 
 ### 🔄 Changes

package/dist/inference/inference-accumulator.js

@@ -26,11 +26,12 @@ export function accumulateCorpus(inferenceDir) {
     for (const session of sessions) {
         for (const p of session.patterns) {
             const existing = patternMap.get(p.name);
+            const evidence = patternEvidence(p);
             if (existing) {
                 existing.count++;
                 existing.confidence.push(p.confidence);
                 existing.sessions.push(session.sessionId);
-                for (const e of p.evidence) {
+                for (const e of evidence) {
                     if (!existing.evidence.includes(e))
                         existing.evidence.push(e);
                 }
@@ -40,7 +41,7 @@ export function accumulateCorpus(inferenceDir) {
                     count: 1,
                     confidence: [p.confidence],
                     sessions: [session.sessionId],
-                    evidence: [...p.evidence],
+                    evidence: [...evidence],
                     description: p.description,
                 });
             }
@@ -95,13 +96,44 @@ export function loadSessionInferences(dir) {
         .filter((f) => f.startsWith("session-") && f.endsWith(".json"))
         .map((f) => {
         try {
-            return JSON.parse(fs.readFileSync(path.join(dir, f), "utf-8"));
+            const parsed = JSON.parse(fs.readFileSync(path.join(dir, f), "utf-8"));
+            const named = readMatchedPrimitives(parsed);
+            parsed.matched_primitives = named;
+            parsed.matchedPrimitives = named;
+            return parsed;
         }
         catch {
             return null;
         }
     })
-        .filter((s) => s !== null);
+        .filter((s) => isSessionInference(s));
+}
+/** Captured patterns sometimes omit evidence. That is an empty list, not a throw. */
+function readMatchedPrimitives(value) {
+    if (!value || typeof value !== "object")
+        return [];
+    const raw = value.matched_primitives
+        ?? value.matchedPrimitives;
+    if (!Array.isArray(raw))
+        return [];
+    return [...new Set(raw.filter((item) => typeof item === "string" && item.length > 0))];
+}
+function patternEvidence(pattern) {
+    if (!Array.isArray(pattern.evidence))
+        return [];
+    return pattern.evidence.filter((item) => typeof item === "string");
+}
+/** Notes and partial JSON under docs/inference are not sessions. */
+function isSessionInference(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const session = value;
+    return typeof session.sessionId === "string"
+        && Array.isArray(session.patterns)
+        && Array.isArray(session.problems)
+        && Array.isArray(session.approaches)
+        && Array.isArray(session.wrongTurns)
+        && typeof session.metrics?.commits === "number";
 }
 function loadLastCycleDate(filePath) {
     if (!fs.existsSync(filePath))

package/dist/inference/inference-cycle.d.ts

@@ -8,6 +8,10 @@ export interface InferenceProposal {
     confidence: number;
     source: "recurring_problem" | "recurring_pattern" | "wrong_turn";
     status: "pending" | "approved" | "rejected" | "applied" | "failed";
+    /** Repertoire signals the sessions behind this proposal already named. */
+    namedSignals?: string[];
+    /** Approaches, solutions, or the wrong turn from those sessions. */
+    lesson?: string;
 }
 export interface InferenceCycleResult {
     cycleId: string;
@@ -55,7 +59,11 @@ export declare class InferenceCycle {
     constructor(projectRoot?: string, agentInvoker?: AgentInvoker, options?: InferenceCycleOptions);
     governExternalProposals(proposals: InferenceProposal[]): Promise<InferenceCycleResult>;
     maybeRunCycle(): Promise<InferenceCycleResult>;
+    /** Approve or reject grades the signals that proposal's sessions already named. needs-revision does not write. */
+    private recordGovernedLessons;
     private governProposals;
+    /** Flag off: the local matrix is the pass. Dynamo is not called and the miss is not stored as a reject. */
+    private governWithLocalMatrix;
     private isGovernanceMcpPreferred;
     private parseGovernanceMcpResponse;
     private extractTextFromNdjson;
@@ -64,6 +72,10 @@ export declare class InferenceCycle {
     getPhase(): CyclePhase;
     private saveCycleState;
     private appendHistory;
+    /** Lesson ids that leave the 50-entry window stay covered. Empty cycles do not erase them. */
+    private retainDroppedLessonIds;
+    private readRetainedLessonIds;
+    private retainedLessonCycle;
     private loadHistory;
     private buildBlockedResult;
     private buildResult;

package/dist/inference/inference-cycle.js

@@ -8,8 +8,27 @@ import { mcpClientManager } from "../mcps/mcp-client.js";
 import { getConfigDir } from "../core/config-paths.js";
 import { generateProposals } from "./inference-proposal-generator.js";
 import { applyProposals as applyProposalsEx } from "./inference-applier.js";
+import { applyDecisionMatrix } from "../governance/governance-core.js";
+import { recordLesson } from "../memory-routing/record-lesson.js";
+import { writeLessonPickup } from "../memory-routing/lesson-pickup.js";
 const CYCLE_STATE_FILE = "inference-cycle-state.json";
 const CYCLE_HISTORY_FILE = "inference-cycle-history.json";
+const GRADED_LESSON_IDS_FILE = "inference-cycle-graded-ids.json";
+const HISTORY_CAP = 50;
+const LESSON_ID_PREFIXES = ["named:", "pattern:", "problem:", "wrong:"];
+function isLessonProposalId(id) {
+    return LESSON_ID_PREFIXES.some((prefix) => id.startsWith(prefix));
+}
+function lessonIdsFromUnknown(parsed) {
+    if (!Array.isArray(parsed))
+        return [];
+    const ids = [];
+    for (const item of parsed) {
+        if (typeof item === "string" && isLessonProposalId(item))
+            ids.push(item);
+    }
+    return ids;
+}
 function governanceToolText(result) {
     if (typeof result !== "object" || result === null || !("content" in result)) {
         return "";
@@ -18,6 +37,12 @@ function governanceToolText(result) {
     const text = content?.[0]?.text;
     return typeof text === "string" ? text : "";
 }
+function governanceToolIsError(result) {
+    if (typeof result !== "object" || result === null || !("isError" in result)) {
+        return false;
+    }
+    return result.isError === true;
+}
 export class InferenceCycle {
     static instances = new Map();
     static reEntryLock = false;
@@ -169,6 +194,7 @@ export class InferenceCycle {
             for (const p of proposals.filter((p) => p.status !== "approved")) {
                 p.status = "rejected";
             }
+            this.recordGovernedLessons(cycleId, proposals, votes);
             if (approved.length > 0) {
                 if (!this.options.skipApply) {
                     this.setPhase("applying");
@@ -215,6 +241,39 @@ export class InferenceCycle {
             InferenceCycle.reEntryLock = false;
         }
     }
+    /** Approve or reject grades the signals that proposal's sessions already named. needs-revision does not write. */
+    recordGovernedLessons(cycleId, proposals, votes) {
+        const alreadyGraded = new Set(this.loadHistory().flatMap((cycle) => (cycle.proposals ?? []).map((proposal) => proposal.id)));
+        for (const proposal of proposals) {
+            if (alreadyGraded.has(proposal.id))
+                continue;
+            const vote = votes.find((item) => item.proposalId === proposal.id);
+            if (!vote)
+                continue;
+            if (vote.decision !== "approve" && vote.decision !== "reject")
+                continue;
+            if (vote.details.some((line) => line.includes("governance error")))
+                continue;
+            const named = proposal.namedSignals ?? [];
+            const taught = recordLesson({
+                operation: [proposal.title, proposal.description, ...proposal.evidence].join("\n"),
+                success: vote.decision === "approve",
+                taskId: proposal.id,
+                assignedAgent: "inference-cycle",
+                sessionId: cycleId,
+                signals: named,
+                lesson: proposal.lesson ?? "",
+            });
+            if (taught.length > 0) {
+                frameworkLogger.log("inference-cycle", "lesson-recorded", "info", {
+                    proposalId: proposal.id,
+                    decision: vote.decision,
+                    signals: taught,
+                });
+            }
+        }
+        writeLessonPickup(this.projectRoot);
+    }
     async governProposals(proposals) {
         // Governance MCP is the sole governance path (governance.server.ts + GovernanceService).
         // It calls individual skill MCPs (code-review, security-audit, researcher) internally
@@ -222,8 +281,9 @@ export class InferenceCycle {
         const useGovernanceMcp = process.env.XRAY_FORCE_MCP_GOVERNANCE === 'true' ||
             this.isGovernanceMcpPreferred();
         if (!useGovernanceMcp) {
-            throw new Error("Governance MCP is required but not available");
+            return this.governWithLocalMatrix(proposals);
         }
+        const governanceMcpTimeoutMs = 90_000;
         const result = await Promise.race([
             mcpClientManager.callServerTool("governance", "govern_proposals", {
                 proposals: proposals.map(p => ({
@@ -238,9 +298,12 @@ export class InferenceCycle {
                 context: { source: "inference-cycle" },
                 options: { require_external: true },
             }),
-            new Promise((_, reject) => setTimeout(() => reject(new Error("Governance MCP timed out after 8s")), 8000)),
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`Governance MCP timed out after ${governanceMcpTimeoutMs / 1000}s`)), governanceMcpTimeoutMs)),
         ]);
         const text = governanceToolText(result);
+        if (governanceToolIsError(result)) {
+            throw new Error(text || "Governance MCP returned an error");
+        }
         const parsed = this.parseGovernanceMcpResponse(text, proposals);
         frameworkLogger.log("inference-cycle", "governance-mcp-primary-path", "info", {
             proposalCount: proposals.length,
@@ -248,6 +311,24 @@ export class InferenceCycle {
         });
         return parsed.votes;
     }
+    /** Flag off: the local matrix is the pass. Dynamo is not called and the miss is not stored as a reject. */
+    governWithLocalMatrix(proposals) {
+        return proposals.map((proposal) => {
+            const resonance = Number.isFinite(proposal.confidence) ? proposal.confidence : 0.8;
+            const matrix = applyDecisionMatrix({ resonance });
+            const decision = matrix.recommendation === "PASS"
+                ? "approve"
+                : matrix.recommendation === "REJECT"
+                    ? "reject"
+                    : "needs_revision";
+            return {
+                proposalId: proposal.id,
+                decision,
+                confidence: matrix.confidence,
+                details: ["local-matrix: inference_governance disabled", ...matrix.reasons],
+            };
+        });
+    }
     isGovernanceMcpPreferred() {
         try {
             const config = featuresConfigLoader.loadConfig();
@@ -275,17 +356,12 @@ export class InferenceCycle {
             return { votes, overallDecision: data.overallDecision || "needs_revision" };
         }
         catch {
+            const preview = text.substring(0, 300);
             frameworkLogger.log('inference-cycle', 'governance-mcp-parse-failed', 'warning', {
-                textPreview: text.substring(0, 200),
+                textPreview: preview,
                 proposalCount: proposals.length,
             });
-            const votes = proposals.map(p => ({
-                proposalId: p.id,
-                decision: "abstain",
-                confidence: 0.5,
-                details: ["governance-mcp: parse-failed"],
-            }));
-            return { votes, overallDecision: "needs_revision" };
+            throw new Error(`governance-mcp: unreadable vote: ${preview || "empty governance response"}`);
         }
     }
     extractTextFromNdjson(output) {
@@ -357,21 +433,87 @@ export class InferenceCycle {
             }
         }
         history.push(result);
-        if (history.length > 50)
-            history = history.slice(-50);
+        const dropped = history.length > HISTORY_CAP ? history.slice(0, history.length - HISTORY_CAP) : [];
+        if (history.length > HISTORY_CAP)
+            history = history.slice(-HISTORY_CAP);
+        this.retainDroppedLessonIds(dropped, history);
         fs.writeFileSync(historyPath, JSON.stringify(history, null, 2));
     }
-    loadHistory() {
-        const historyPath = path.join(this.stateDir, CYCLE_HISTORY_FILE);
-        if (!fs.existsSync(historyPath))
+    /** Lesson ids that leave the 50-entry window stay covered. Empty cycles do not erase them. */
+    retainDroppedLessonIds(dropped, kept) {
+        if (dropped.length === 0)
+            return;
+        const keptIds = new Set(kept.flatMap((cycle) => (cycle.proposals ?? []).map((proposal) => proposal.id)));
+        const retained = new Set(this.readRetainedLessonIds());
+        let changed = false;
+        for (const cycle of dropped) {
+            for (const proposal of cycle.proposals ?? []) {
+                if (!isLessonProposalId(proposal.id))
+                    continue;
+                if (keptIds.has(proposal.id) || retained.has(proposal.id))
+                    continue;
+                retained.add(proposal.id);
+                changed = true;
+            }
+        }
+        if (!changed)
+            return;
+        if (!fs.existsSync(this.stateDir)) {
+            fs.mkdirSync(this.stateDir, { recursive: true });
+        }
+        fs.writeFileSync(path.join(this.stateDir, GRADED_LESSON_IDS_FILE), JSON.stringify([...retained].sort(), null, 2));
+    }
+    readRetainedLessonIds() {
+        const file = path.join(this.stateDir, GRADED_LESSON_IDS_FILE);
+        if (!fs.existsSync(file))
             return [];
         try {
-            return JSON.parse(fs.readFileSync(historyPath, "utf-8"));
+            return lessonIdsFromUnknown(JSON.parse(fs.readFileSync(file, "utf-8")));
         }
         catch {
             return [];
         }
     }
+    retainedLessonCycle(ids) {
+        return {
+            cycleId: "retained-lessons",
+            triggered: false,
+            triggerReason: "lesson ids kept past the history cap",
+            corpusSummary: { sessions: 0, totalCommits: 0, recurringPatterns: 0, recurringProblems: 0 },
+            proposals: ids.map((id) => ({
+                id,
+                type: "codify",
+                title: id,
+                description: "",
+                evidence: [],
+                confidence: 0,
+                source: "recurring_pattern",
+                status: "pending",
+            })),
+            votes: [],
+            phase: "complete",
+            completedAt: "1970-01-01T00:00:00.000Z",
+            duration: 0,
+        };
+    }
+    loadHistory() {
+        const historyPath = path.join(this.stateDir, CYCLE_HISTORY_FILE);
+        let history = [];
+        if (fs.existsSync(historyPath)) {
+            try {
+                const parsed = JSON.parse(fs.readFileSync(historyPath, "utf-8"));
+                history = Array.isArray(parsed) ? parsed : [];
+            }
+            catch {
+                history = [];
+            }
+        }
+        const present = new Set(history.flatMap((cycle) => (cycle.proposals ?? []).map((proposal) => proposal.id)));
+        const missing = this.readRetainedLessonIds().filter((id) => !present.has(id));
+        if (missing.length === 0)
+            return history;
+        return [this.retainedLessonCycle(missing), ...history];
+    }
     buildBlockedResult(cycleId, reason) {
         return {
             cycleId,