opencode-lore 0.2.8 → 0.3.0

package/README.md

@@ -24,31 +24,45 @@ A **gradient context manager** decides how much of each tier to include in each
 
 > Scores below are on Claude Sonnet 4 (claude-sonnet-4-6). Results may vary with other models.
 
-### General memory recall
+### Coding session recall
 
-500-question evaluation using the [LongMemEval](https://github.com/xiaowu0162/LongMemEval) benchmark (ICLR 2025), tested in oracle mode (full message history provided as conversation context).
+20 questions across 2 real coding sessions (113K and 353K tokens), targeting specific facts at varying depths. Default mode simulates OpenCode's actual behavior: compaction of early messages + 80K-token tail window. Lore mode uses on-the-fly distillation + the `recall` tool for searching raw message history.
 
-| Category                  | No plugin | Lore    |
-|---------------------------|-----------|---------|
-| Single-session (user)     | 71.9%     | 93.8%   |
-| Single-session (prefs)    | 46.7%     | 86.7%   |
-| Single-session (assistant)| 91.1%     | 96.4%   |
-| Multi-session             | 76.9%     | 85.1%   |
-| Knowledge updates         | 84.7%     | 93.1%   |
-| Temporal reasoning        | 64.6%     | 81.9%   |
-| Abstention                | 53.3%     | 86.7%   |
-| **Overall**               | **72.6%** | **88.0%** |
+**Accuracy:**
 
-### Coding session recall
+| Mode    | Score     | Accuracy   |
+|---------|-----------|------------|
+| Default | 10/20     | 50.0%      |
+| Lore    | **17/20** | **85.0%**  |
+
+**By question depth** (where in the session the answer lives):
+
+| Depth        | Default  | Lore        | Gap     |
+|--------------|----------|-------------|---------|
+| Early detail | 1/7      | **6/7**     | +71pp   |
+| Mid detail   | 3/5      | **5/5**     | +40pp   |
+| Late detail  | 6/7      | 6/7         | tied    |
+
+Early and mid details — specific numbers, file paths, design decisions, error messages — are what compaction loses and distillation preserves. Late details are in both modes' context windows, so they tie.
 
-15 questions across 3 real coding sessions, each asking about a specific fact from the conversation. Compared against OpenCode's default behavior (last ~80K tokens of context).
+**Cost:**
 
-| Metric         | Default | Lore         |
-|----------------|---------|--------------|
-| Score          | 10/15   | **14/15**    |
-| Accuracy       | 66.7%   | **93.3%**    |
+| Metric             | Default    | Lore       | Factor       |
+|--------------------|------------|------------|--------------|
+| Avg input/question | 126K tok   | 50K tok    | 2.5x less    |
+| Total cost         | $8.14      | $1.87      | 4.4x cheaper |
+| Cost/correct       | $0.81      | **$0.11**  | 7.4x cheaper |
 
-Lore's advantage is largest on early/mid-session details that fall outside the recent-context window — facts like which PR was being tested, why an endpoint was changed, how many rows were updated, or what a specific bug's root cause was. The `recall` tool covers gaps where the distilled observations lack fine-grained detail.
+Lore's distilled context is smaller and more cacheable than raw tail windows, making it both more accurate and cheaper per correct answer.
+
+**Distillation compression:**
+
+| Session            | Messages | Tokens | Distilled to     | Compression |
+|--------------------|----------|--------|------------------|-------------|
+| cli-sentry-issue   | 318      | 113K   | ~6K tokens       | 19x         |
+| cli-nightly        | 898      | 353K   | ~19K tokens      | 19x         |
+
+The eval is self-contained and reproducible: session transcripts are stored as JSON files with no database dependency. See [`eval/`](eval/) for the harness and data.
 
 ## How we got here
 
@@ -58,9 +72,11 @@ This plugin was built in a few intense sessions. Some highlights:
 
 **Markdown injection.** Property-based testing with fast-check revealed that user-generated content in facts (code fences, heading markers, thematic breaks) could break the markdown structure of the injected context, confusing the model.
 
-**v2 — observation logs.** Switching to Mastra's observer/reflector architecture with plain-text timestamped observation logs was the breakthrough — LongMemEval jumped from 73.8% to 88.0%. The key insight: dated event logs preserve temporal relationships that structured JSON destroys.
+**v2 — observation logs.** Switching to Mastra's observer/reflector architecture with plain-text timestamped observation logs was the breakthrough. The key insight: dated event logs preserve temporal relationships that structured JSON destroys.
+
+**Prompt refinements.** The push from 80% to 93.3% on the initial coding recall eval came from two observer prompt additions: "EXACT NUMBERS — NEVER APPROXIMATE" (the observer was rounding counts) and "BUG FIXES — ALWAYS RECORD" (early-session fixes were being compressed away during reflection).
 
-**Prompt refinements.** The final push from 80% to 93.3% on coding recall came from two observer prompt additions: "EXACT NUMBERS — NEVER APPROXIMATE" (the observer was rounding counts) and "BUG FIXES — ALWAYS RECORD" (early-session fixes were being compressed away during reflection).
+**v3 — gradient fixes, caching, and proper eval.** A month of fixes (per-session gradient state, current-turn protection, cache.write calibration, prefix caching, LTM relevance scoring) shipped alongside a new self-contained eval harness. The old coding eval used DB-resident sessions that degraded over time as temporal pruning deleted messages. The new eval extracts full session transcripts into portable JSON files, distills on the fly with the current production prompt, seeds the DB for recall tool access, and compares against OpenCode's actual compaction behavior. This moved the coding eval from 15 questions on degraded data to 20 questions on clean 113K-353K token sessions — and confirmed the +35pp accuracy gap and 7x cost efficiency advantage.
 
 ## Installation
 
@@ -126,7 +142,6 @@ The assistant gets a `recall` tool that searches across stored messages and know
 - [How we solved the agent memory problem](https://www.sanity.io/blog/how-we-solved-the-agent-memory-problem) — Simen Svale at Sanity on the Nuum memory architecture: three-tier storage, distillation not summarization, recursive compression. The foundation this plugin is built on.
 - [Mastra Observational Memory](https://mastra.ai/research/observational-memory) — the observer/reflector architecture and the switch from structured JSON to timestamped observation logs that made v2 work.
 - [Mastra Memory source](https://github.com/mastra-ai/mastra/tree/main/packages/memory) — reference implementation.
-- [LongMemEval](https://arxiv.org/abs/2410.10813) — the evaluation benchmark (ICLR 2025) we used to measure progress.
 - [OpenCode](https://opencode.ai) — the coding agent this plugin extends.
 
 ## License

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "opencode-lore",
-  "version": "0.2.8",
+  "version": "0.3.0",
   "type": "module",
   "license": "MIT",
-  "description": "Three-tier memory architecture for OpenCode — distillation, not summarization",
+  "description": "Three-tier memory architecture for OpenCode \u2014 distillation, not summarization",
   "main": "src/index.ts",
   "exports": {
     ".": "./src/index.ts"

package/src/agents-file.ts

@@ -175,7 +175,7 @@ function buildSection(projectPath: string): string {
   // Section heading
   out.push("## Long-term Knowledge");
 
-  for (const [category, items] of grouped) {
+  for (const [category, items] of [...grouped.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
     out.push("");
     out.push(`### ${category.charAt(0).toUpperCase() + category.slice(1)}`);
     out.push("");

package/src/gradient.ts

@@ -38,56 +38,68 @@ const FIRST_TURN_OVERHEAD = 15_000;
 
 // Calibrated overhead: actual tokens used minus our message estimate.
 // Null = not yet calibrated (first turn). Updated after every assistant response.
+// Shared across all sessions — this is model-level overhead (system prompt,
+// tool definitions, provider headers) that doesn't vary per session.
 let calibratedOverhead: number | null = null;
 
-// --- Exact token tracking ---
-// Stores the real input token count from the last successful API response.
-// Used for the layer 0 passthrough decision: instead of estimating the full
-// message array with chars/4, we take the exact count from the previous turn
-// and only estimate the small delta (new messages). 99%+ of the count is
-// exact from the API's own tokenizer, virtually eliminating overflow errors.
-let lastKnownInput = 0;
-let lastKnownLtm = 0;
-let lastKnownSessionID: string | null = null;
-let lastKnownMessageCount = 0;
-
-// Number of messages in the most recent transform() output — i.e. how many
-// messages were actually sent to the model. On layer 0 this equals the full
-// session length. On layers 1-4 it equals the compressed window size.
-// Calibration must use this count (not the total DB message count) so that
-// the delta on the next turn reflects only messages added since the last
-// compressed window, not since the last DB snapshot.
-let lastTransformedCount = 0;
-
-export function getLastTransformedCount(): number {
-  return lastTransformedCount;
-}
+// ---------------------------------------------------------------------------
+// Per-session state
+//
+// All calibration, layer-tracking, and window-ID state is scoped per session
+// using an in-memory Map. This prevents worker sessions (lore-distill,
+// lore-curator) from corrupting the main session's sticky-layer guard and
+// delta-estimation state when their transform() calls return layer 0.
+//
+// DB persistence is unnecessary: UNCALIBRATED_SAFETY=1.5 safely handles
+// the first turn of a resumed session. The Map is bounded — there are never
+// more than a handful of active sessions at once.
+// ---------------------------------------------------------------------------
+
+type SessionState = {
+  /** Exact input token count from the last successful API response */
+  lastKnownInput: number;
+  /** LTM tokens that were in-flight when lastKnownInput was recorded */
+  lastKnownLtm: number;
+  /** Total messages sent to the model in the last turn (compressed count on layers 1-4) */
+  lastKnownMessageCount: number;
+  /** Number of messages in the most recent transform() output */
+  lastTransformedCount: number;
+  /** Layer used by the most recent transform() call — sticky-layer guard */
+  lastLayer: SafetyLayer;
+  /** Message IDs in the most recent transform() output — ID-based delta estimation */
+  lastWindowMessageIDs: Set<string>;
+  /** One-shot force escalation: skip layers below this on the next transform() */
+  forceMinLayer: SafetyLayer;
+  /** Distilled prefix cache (Approach C) */
+  prefixCache: PrefixCache | null;
+  /** Raw window pin cache (Approach B) */
+  rawWindowCache: RawWindowCache | null;
+};
 
-/** Returns the layer used by the most recent transform() call. For testing. */
-export function getLastLayer(): SafetyLayer {
-  return lastLayer;
+function makeSessionState(): SessionState {
+  return {
+    lastKnownInput: 0,
+    lastKnownLtm: 0,
+    lastKnownMessageCount: 0,
+    lastTransformedCount: 0,
+    lastLayer: 0,
+    lastWindowMessageIDs: new Set(),
+    forceMinLayer: 0,
+    prefixCache: null,
+    rawWindowCache: null,
+  };
 }
 
-// The layer used by the most recent transform() call.
-// Used for the sticky-layer guard: once gradient mode activates (layer >= 1),
-// we don't allow fallback to layer 0 until the session genuinely shrinks
-// (e.g. after compaction). This prevents the calibration oscillation where a
-// compressed turn records 100K + 50-msg count, and the next turn's delta
-// estimation treats 250 evicted messages as "new", undercounts their tokens
-// via chars/4, and incorrectly concludes layer 0 passes.
-let lastLayer: SafetyLayer = 0;
-
-// The set of message IDs included in the most recent transform() output.
-// Used for accurate delta estimation: instead of counting messages by index
-// (which breaks after compression changes the window), we identify exactly
-// which messages are genuinely new since the last window.
-let lastWindowMessageIDs: Set<string> = new Set();
-
-// --- Force escalation ---
-// Set when the API returns "prompt is too long" — forces the transform to skip
-// layer 0 (and optionally layer 1) on the next call to ensure the context is
-// trimmed enough to fit. Cleared after one use (one-shot).
-let forceMinLayer: SafetyLayer = 0;
+const sessionStates = new Map<string, SessionState>();
+
+function getSessionState(sessionID: string): SessionState {
+  let state = sessionStates.get(sessionID);
+  if (!state) {
+    state = makeSessionState();
+    sessionStates.set(sessionID, state);
+  }
+  return state;
+}
 
 // LTM tokens injected via system transform hook this turn.
 // Set by setLtmTokens() after the system hook runs; consumed by transform().
@@ -137,18 +149,20 @@ export function calibrate(
   sessionID?: string,
   messageCount?: number,
 ) {
-  // Store exact counts for the proactive layer 0 decision.
-  lastKnownInput = actualInput;
-  lastKnownLtm = ltmTokens;
-  if (sessionID !== undefined) lastKnownSessionID = sessionID;
-  if (messageCount !== undefined) lastKnownMessageCount = messageCount;
-
+  // Update global overhead calibration (shared across sessions — model-level).
   const overhead = Math.max(0, actualInput - messageEstimate);
-  // Smooth with EMA (alpha=0.3) once calibrated, or set directly on first call
   calibratedOverhead =
     calibratedOverhead === null
       ? overhead
       : Math.round(calibratedOverhead * 0.7 + overhead * 0.3);
+
+  // Store per-session exact counts for the proactive layer 0 decision.
+  if (sessionID !== undefined) {
+    const state = getSessionState(sessionID);
+    state.lastKnownInput = actualInput;
+    state.lastKnownLtm = ltmTokens;
+    if (messageCount !== undefined) state.lastKnownMessageCount = messageCount;
+  }
 }
 
 export function getOverhead(): number {
@@ -156,25 +170,45 @@ export function getOverhead(): number {
 }
 
 /**
- * Force the next transform() call to use at least the given layer.
+ * Returns the number of messages in the most recent transform() output for
+ * the given session. Used by calibrate() to track the compressed window size.
+ */
+export function getLastTransformedCount(sessionID: string): number {
+  return sessionStates.get(sessionID)?.lastTransformedCount ?? 0;
+}
+
+/** Returns the layer used by the most recent transform() call. For testing. */
+export function getLastLayer(sessionID?: string): SafetyLayer {
+  if (sessionID) return sessionStates.get(sessionID)?.lastLayer ?? 0;
+  // Fallback for tests: return from the first (and usually only) session state
+  const first = sessionStates.values().next().value;
+  return first?.lastLayer ?? 0;
+}
+
+/**
+ * Force the next transform() call for this session to use at least the given layer.
  * Called when the API returns "prompt is too long" so the next attempt
  * trims the context enough to fit within the model's context window.
  */
-export function setForceMinLayer(layer: SafetyLayer) {
-  forceMinLayer = layer;
+export function setForceMinLayer(layer: SafetyLayer, sessionID?: string) {
+  if (sessionID) {
+    getSessionState(sessionID).forceMinLayer = layer;
+  } else {
+    // Fallback for tests / callers without session ID: set on all active sessions
+    for (const state of sessionStates.values()) {
+      state.forceMinLayer = layer;
+    }
+  }
 }
 
 // For testing only — reset all calibration and force-escalation state
-export function resetCalibration() {
+export function resetCalibration(sessionID?: string) {
   calibratedOverhead = null;
-  lastKnownInput = 0;
-  lastKnownLtm = 0;
-  lastKnownSessionID = null;
-  lastKnownMessageCount = 0;
-  lastTransformedCount = 0;
-  forceMinLayer = 0;
-  lastLayer = 0;
-  lastWindowMessageIDs = new Set();
+  if (sessionID) {
+    sessionStates.delete(sessionID);
+  } else {
+    sessionStates.clear();
+  }
 }
 
 type Distillation = {
@@ -496,28 +530,29 @@ type PrefixCache = {
   prefixTokens: number;
 };
 
-let prefixCache: PrefixCache | null = null;
-
 /**
  * Return the distilled prefix messages, reusing cached content when possible.
+ * Uses per-session state from sessState.prefixCache (no module-level cache).
  *
  * Cache hit  — no new rows: returns the exact same prefixMessages object
  *              (byte-identical content, prompt cache preserved).
  * Cache miss — new rows appended: renders only the delta, appends to cached
  *              text, updates cache.
- * Full reset — session changed, or rows were rewritten by meta-distillation:
+ * Full reset — first call, or rows were rewritten by meta-distillation:
  *              renders everything from scratch.
  */
 function distilledPrefixCached(
   distillations: Distillation[],
   sessionID: string,
+  sessState: SessionState,
 ): { messages: MessageWithParts[]; tokens: number } {
   if (!distillations.length) {
-    prefixCache = null;
+    sessState.prefixCache = null;
     return { messages: [], tokens: 0 };
   }
 
   const lastRow = distillations[distillations.length - 1];
+  const prefixCache = sessState.prefixCache;
 
   // Cache is valid when: same session, row count only grew (no rewrites),
   // and the last previously-cached row still exists at the same position.
@@ -551,7 +586,7 @@ function distilledPrefixCached(
       const fullText = prefixCache!.cachedText + "\n\n" + deltaText;
       const messages = buildPrefixMessages(fullText);
       const tokens = messages.reduce((sum, m) => sum + estimateMessage(m), 0);
-      prefixCache = {
+      sessState.prefixCache = {
         sessionID,
         lastDistillationID: lastRow.id,
         rowCount: distillations.length,
@@ -563,7 +598,7 @@ function distilledPrefixCached(
     }
   }
 
-  // Full re-render: first call, session change, or meta-distillation rewrote rows
+  // Full re-render: first call or meta-distillation rewrote rows
   const now = new Date();
   const annotated = distillations.map((d) => ({
     ...d,
@@ -571,13 +606,13 @@ function distilledPrefixCached(
   }));
   const fullText = formatDistillations(annotated);
   if (!fullText) {
-    prefixCache = null;
+    sessState.prefixCache = null;
     return { messages: [], tokens: 0 };
   }
 
   const messages = buildPrefixMessages(fullText);
   const tokens = messages.reduce((sum, m) => sum + estimateMessage(m), 0);
-  prefixCache = {
+  sessState.prefixCache = {
     sessionID,
     lastDistillationID: lastRow.id,
     rowCount: distillations.length,
@@ -588,9 +623,14 @@ function distilledPrefixCached(
   return { messages, tokens };
 }
 
-// For testing only — reset prefix cache state
-export function resetPrefixCache() {
-  prefixCache = null;
+// For testing only — reset prefix cache state for a specific session (or all)
+export function resetPrefixCache(sessionID?: string) {
+  if (sessionID) {
+    const state = sessionStates.get(sessionID);
+    if (state) state.prefixCache = null;
+  } else {
+    for (const state of sessionStates.values()) state.prefixCache = null;
+  }
 }
 
 // --- Approach B: Lazy raw window eviction ---
@@ -616,14 +656,19 @@ type RawWindowCache = {
   firstMessageID: string;
 };
 
-let rawWindowCache: RawWindowCache | null = null;
-
-export function resetRawWindowCache() {
-  rawWindowCache = null;
+// For testing only — reset raw window cache state for a specific session (or all)
+export function resetRawWindowCache(sessionID?: string) {
+  if (sessionID) {
+    const state = sessionStates.get(sessionID);
+    if (state) state.rawWindowCache = null;
+  } else {
+    for (const state of sessionStates.values()) state.rawWindowCache = null;
+  }
 }
 
 /**
  * Layer-1 tryFit with lazy eviction.
+ * Uses per-session rawWindowCache from sessState (no module-level cache).
  *
  * Attempts to reuse the previous raw window cutoff before falling back to a
  * full backward scan. If the pinned window fits, returns it unchanged (same
@@ -638,11 +683,13 @@ function tryFitStable(input: {
   distilledBudget: number;
   rawBudget: number;
   sessionID: string;
+  sessState: SessionState;
 }): Omit<TransformResult, "layer" | "usable" | "distilledBudget" | "rawBudget"> | null {
   // If the prefix already overflows its budget there's no point trying.
   if (input.prefixTokens > input.distilledBudget && input.prefix.length > 0)
     return null;
 
+  const rawWindowCache = input.sessState.rawWindowCache;
   const cacheValid =
     rawWindowCache !== null && rawWindowCache.sessionID === input.sessionID;
 
@@ -694,7 +741,7 @@ function tryFitStable(input: {
     // raw message in the new window. Pin to its ID for the next turn.
     const rawStart = result.messages[input.prefix.length];
     if (rawStart) {
-      rawWindowCache = {
+      input.sessState.rawWindowCache = {
         sessionID: input.sessionID,
         firstMessageID: rawStart.info.id,
       };
@@ -746,8 +793,10 @@ function transformInner(input: {
   // When the API previously rejected with "prompt is too long", skip layers
   // below the forced minimum to ensure enough trimming on the next attempt.
   // One-shot: consumed here and reset to 0.
-  let effectiveMinLayer = forceMinLayer;
-  forceMinLayer = 0;
+  const sid = input.sessionID ?? input.messages[0]?.info.sessionID;
+  const sessState = sid ? getSessionState(sid) : makeSessionState();
+  let effectiveMinLayer = sessState.forceMinLayer;
+  sessState.forceMinLayer = 0;
 
   // --- Approach A: Cache-preserving passthrough ---
   // Use exact token count from the previous API response when available.
@@ -755,13 +804,12 @@ function transformInner(input: {
   // making the layer-0 decision 99%+ accurate from the API's own tokenizer.
   // maxInput = absolute ceiling the API enforces: input_tokens + max_tokens <= context
   const maxInput = contextLimit - outputReserved;
-  const sid = input.sessionID ?? input.messages[0]?.info.sessionID;
 
   // True when we have real API token data from a previous turn in this session.
   // When false (first turn / session change), chars/4 estimates can undercount by
   // up to 1.8x — so tryFit output must be validated with a safety multiplier before
   // being used, to prevent sending an apparently-fitting window that actually overflows.
-  const calibrated = lastKnownInput > 0 && sid === lastKnownSessionID;
+  const calibrated = sessState.lastKnownInput > 0;
 
   // On uncalibrated turns, apply this multiplier to tryFit's estimated total to
   // approximate the real token count. 1.5 is conservative but not so aggressive
@@ -784,8 +832,9 @@ function transformInner(input: {
   // input.messages has 300 raw messages. The delta estimation treats the 250
   // evicted messages as "new" and undercounts them via chars/4, producing an
   // expectedInput that fits in layer 0 — but the actual tokens are ~190K.
-  // Only applied when calibrated (same session) to avoid affecting other sessions.
-  if (calibrated && lastLayer >= 1 && input.messages.length >= lastKnownMessageCount) {
+  // Only applied when calibrated (same session, per-session state) to avoid
+  // affecting other sessions including worker sessions.
+  if (calibrated && sessState.lastLayer >= 1 && input.messages.length >= sessState.lastKnownMessageCount) {
     effectiveMinLayer = Math.max(effectiveMinLayer, 1) as SafetyLayer;
   }
 
@@ -795,12 +844,12 @@ function transformInner(input: {
     // Use message ID tracking (Option B) to identify new messages accurately.
     // After compression, the "last window" is a subset of the full message array —
     // counting by index would treat evicted messages as new (off-by-250 error).
-    const newMessages = lastWindowMessageIDs.size > 0
-      ? input.messages.filter((m) => !lastWindowMessageIDs.has(m.info.id))
-      : input.messages.slice(-Math.max(0, input.messages.length - lastKnownMessageCount));
+    const newMessages = sessState.lastWindowMessageIDs.size > 0
+      ? input.messages.filter((m) => !sessState.lastWindowMessageIDs.has(m.info.id))
+      : input.messages.slice(-Math.max(0, input.messages.length - sessState.lastKnownMessageCount));
     const newMsgTokens = newMessages.reduce((s, m) => s + estimateMessage(m), 0);
-    const ltmDelta = ltmTokens - lastKnownLtm;
-    expectedInput = lastKnownInput + newMsgTokens + ltmDelta;
+    const ltmDelta = ltmTokens - sessState.lastKnownLtm;
+    expectedInput = sessState.lastKnownInput + newMsgTokens + ltmDelta;
   } else {
     // First turn or session change: fall back to chars/4 + overhead.
     const messageTokens = input.messages.reduce((s, m) => s + estimateMessage(m), 0);
@@ -810,8 +859,8 @@ function transformInner(input: {
   if (effectiveMinLayer === 0 && expectedInput <= maxInput) {
     // All messages fit — return unmodified to preserve append-only prompt-cache pattern.
     // Raw messages are strictly better context than lossy distilled summaries.
-    const messageTokens = lastKnownInput > 0 && sid === lastKnownSessionID
-      ? expectedInput - (ltmTokens - lastKnownLtm)  // approximate raw portion
+    const messageTokens = calibrated
+      ? expectedInput - (ltmTokens - sessState.lastKnownLtm)  // approximate raw portion
       : expectedInput - overhead - ltmTokens;
     return {
       messages: input.messages,
@@ -834,7 +883,7 @@ function transformInner(input: {
   // the prompt cache. Layers 2-4 already cause full cache invalidation via
   // tool stripping / message restructuring, so they use the non-cached path.
   const cached = sid
-    ? distilledPrefixCached(distillations, sid)
+    ? distilledPrefixCached(distillations, sid, sessState)
     : (() => {
         const msgs = distilledPrefix(distillations);
         return { messages: msgs, tokens: msgs.reduce((sum, m) => sum + estimateMessage(m), 0) };
@@ -854,6 +903,7 @@ function transformInner(input: {
           distilledBudget,
           rawBudget,
           sessionID: sid,
+          sessState,
         })
       : tryFit({
           messages: input.messages,
@@ -868,7 +918,7 @@ function transformInner(input: {
 
   // Layer 1 didn't fit (or was force-skipped) — reset the raw window cache.
   // Layers 2-4 use full scans and already break the prompt cache.
-  rawWindowCache = null;
+  sessState.rawWindowCache = null;
 
   // Layer 2: Strip tool outputs from older messages, keep last 2 turns
   // Skipped when force-escalated to layer 3+.
@@ -955,9 +1005,13 @@ export function transform(input: {
   sessionID?: string;
 }): TransformResult {
   const result = transformInner(input);
-  lastTransformedCount = result.messages.length;
-  lastLayer = result.layer;
-  lastWindowMessageIDs = new Set(result.messages.map((m) => m.info.id));
+  const sid = input.sessionID ?? input.messages[0]?.info.sessionID;
+  if (sid) {
+    const state = getSessionState(sid);
+    state.lastTransformedCount = result.messages.length;
+    state.lastLayer = result.layer;
+    state.lastWindowMessageIDs = new Set(result.messages.map((m) => m.info.id));
+  }
   return result;
 }
 

package/src/index.ts

@@ -224,7 +224,7 @@ export const LorePlugin: Plugin = async (ctx) => {
                 // not the total DB count. On layer 0 these are equal. On layers 1-4,
                 // the model only saw the compressed window — calibrate must track that
                 // count so the next turn's delta is computed correctly.
-                calibrate(actualInput, msgEstimate, msg.sessionID, getLastTransformedCount() || withParts.length);
+                calibrate(actualInput, msgEstimate, msg.sessionID, getLastTransformedCount(msg.sessionID) || withParts.length);
               }
             }
           }
@@ -234,6 +234,12 @@ export const LorePlugin: Plugin = async (ctx) => {
       }
 
       if (event.type === "session.error") {
+        // Skip eval/worker child sessions — only handle errors for real user sessions.
+        const errorSessionID = (event.properties as Record<string, unknown>).sessionID as
+          | string
+          | undefined;
+        if (errorSessionID && await shouldSkip(errorSessionID)) return;
+
         // Detect "prompt is too long" API errors and auto-recover:
         // 1. Force the gradient transform to escalate on the next call (skip layer 0/1)
         // 2. Force distillation to capture all temporal data before compaction
@@ -260,22 +266,19 @@ export const LorePlugin: Plugin = async (ctx) => {
         );
 
         if (isPromptTooLong) {
-          const sessionID = (event.properties as Record<string, unknown>).sessionID as
-            | string
-            | undefined;
           console.error(
-            `[lore] detected 'prompt too long' error — forcing distillation + layer escalation (session: ${sessionID?.substring(0, 16)})`,
+            `[lore] detected 'prompt too long' error — forcing distillation + layer escalation (session: ${errorSessionID?.substring(0, 16)})`,
           );
           // Force layer 2 on next transform — layers 0 and 1 were already too large.
           // The gradient at layers 2-4 will compress the context enough for the next turn.
           // Do NOT call session.summarize() here — it sends all messages to the model,
           // which would overflow again and create a stuck compaction loop.
-          setForceMinLayer(2);
+          setForceMinLayer(2, errorSessionID);
 
-          if (sessionID) {
+          if (errorSessionID) {
             // Force distillation to capture all undistilled messages into the temporal
             // store so they're preserved even if the session is later compacted manually.
-            await backgroundDistill(sessionID, true);
+            await backgroundDistill(errorSessionID, true);
           }
         }
       }
@@ -384,6 +387,16 @@ export const LorePlugin: Plugin = async (ctx) => {
 
       const sessionID = output.messages[0]?.info.sessionID;
 
+      // Skip gradient transform for lore worker sessions (lore-distill, lore-curator).
+      // Worker sessions are small (typically 5-15 messages) and don't need context
+      // management. More importantly, allowing them through would overwrite the
+      // per-session state for the MAIN session if they happen to share a session ID —
+      // and before per-session state was introduced, module-level variables were
+      // corrupted this way, causing calibration oscillation and layer 0 passthrough
+      // on the main session's next step. Belt-and-suspenders: even with per-session
+      // state, worker sessions waste CPU on transform() for no benefit.
+      if (sessionID && await shouldSkip(sessionID)) return;
+
       const result = transform({
         messages: output.messages,
         projectPath,