opencode-lore 0.2.1 → 0.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-lore",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "type": "module",
   "license": "MIT",
   "description": "Three-tier memory architecture for OpenCode — distillation, not summarization",

package/src/gradient.ts

@@ -51,6 +51,18 @@ 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;
+}
+
 // --- 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
@@ -139,6 +151,7 @@ export function resetCalibration() {
   lastKnownLtm = 0;
   lastKnownSessionID = null;
   lastKnownMessageCount = 0;
+  lastTransformedCount = 0;
   forceMinLayer = 0;
 }
 
@@ -691,7 +704,7 @@ export function needsUrgentDistillation(): boolean {
   return v;
 }
 
-export function transform(input: {
+function transformInner(input: {
   messages: MessageWithParts[];
   projectPath: string;
   sessionID?: string;
@@ -722,8 +735,27 @@ export function transform(input: {
   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;
+
+  // 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
+  // that it forces layer 4 on modestly-sized sessions.
+  const UNCALIBRATED_SAFETY = 1.5;
+
+  // Returns true if the tryFit result is safe to use: either we have calibrated
+  // data (exact) or the estimated total * safety factor fits within maxInput.
+  function fitsWithSafetyMargin(result: { totalTokens: number } | null): boolean {
+    if (!result) return false;
+    if (calibrated) return true;
+    return result.totalTokens * UNCALIBRATED_SAFETY <= maxInput;
+  }
+
   let expectedInput: number;
-  if (lastKnownInput > 0 && sid === lastKnownSessionID) {
+  if (calibrated) {
     // Exact approach: prior API count + estimate of only the new messages.
     const newMsgCount = Math.max(0, input.messages.length - lastKnownMessageCount);
     const newMsgTokens = newMsgCount > 0
@@ -793,7 +825,7 @@ export function transform(input: {
           rawBudget,
           strip: "none",
         });
-    if (layer1) return { ...layer1, layer: 1, usable, distilledBudget, rawBudget };
+    if (fitsWithSafetyMargin(layer1)) return { ...layer1!, layer: 1, usable, distilledBudget, rawBudget };
   }
 
   // Layer 1 didn't fit (or was force-skipped) — reset the raw window cache.
@@ -812,9 +844,9 @@ export function transform(input: {
       strip: "old-tools",
       protectedTurns: 2,
     });
-    if (layer2) {
+    if (fitsWithSafetyMargin(layer2)) {
       urgentDistillation = true;
-      return { ...layer2, layer: 2, usable, distilledBudget, rawBudget };
+      return { ...layer2!, layer: 2, usable, distilledBudget, rawBudget };
     }
   }
 
@@ -833,9 +865,9 @@ export function transform(input: {
     rawBudget: Math.floor(usable * 0.55),
     strip: "all-tools",
   });
-  if (layer3) {
+  if (fitsWithSafetyMargin(layer3)) {
     urgentDistillation = true;
-    return { ...layer3, layer: 3, usable, distilledBudget, rawBudget };
+    return { ...layer3!, layer: 3, usable, distilledBudget, rawBudget };
   }
 
   // Layer 4: Emergency — last 2 distillations, last 3 raw messages with tool parts intact.
@@ -871,6 +903,24 @@ export function transform(input: {
   };
 }
 
+// Public wrapper: records the compressed message count for calibration.
+// Calibration needs to know how many messages were SENT to the model (the
+// compressed window), not the total DB count. On layer 0 these are equal;
+// on layers 1-4 the compressed window is smaller, and the delta on the next
+// turn must be computed relative to the compressed count — otherwise the
+// expected input on the next turn is anchored to the compressed input token
+// count but the "new messages" delta is computed against the full DB count,
+// making newMsgCount ≈ 0 and causing layer 0 passthrough on an overflowing session.
+export function transform(input: {
+  messages: MessageWithParts[];
+  projectPath: string;
+  sessionID?: string;
+}): TransformResult {
+  const result = transformInner(input);
+  lastTransformedCount = result.messages.length;
+  return result;
+}
+
 // Compute our message-only estimate for a set of messages (for calibration use)
 export function estimateMessages(messages: MessageWithParts[]): number {
   return messages.reduce((sum, m) => sum + estimateMessage(m), 0);

package/src/index.ts

@@ -14,6 +14,7 @@ import {
   setLtmTokens,
   getLtmBudget,
   setForceMinLayer,
+  getLastTransformedCount,
 } from "./gradient";
 import { formatKnowledge } from "./prompt";
 import { createRecallTool } from "./reflect";
@@ -219,7 +220,11 @@ export const LorePlugin: Plugin = async (ctx) => {
                 const msgEstimate = estimateMessages(withParts);
                 const actualInput =
                   msg.tokens.input + msg.tokens.cache.read + msg.tokens.cache.write;
-                calibrate(actualInput, msgEstimate, msg.sessionID, withParts.length);
+                // Use the compressed message count (from the last transform output),
+                // 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);
               }
             }
           }
@@ -389,12 +394,13 @@ export const LorePlugin: Plugin = async (ctx) => {
       // Layer 0 means all messages fit within the context budget — leave them alone
       // so the append-only sequence stays intact for prompt caching.
       if (result.layer > 0) {
+        // The API requires the conversation to end with a user message.
+        // Always drop trailing non-user messages — even assistant messages with
+        // tool parts. A hard API error is worse than the model re-invoking a tool.
         while (
           result.messages.length > 0 &&
           result.messages.at(-1)!.info.role !== "user"
         ) {
-          const last = result.messages.at(-1)!;
-          if (last.parts.some((p) => p.type === "tool")) break;
           const dropped = result.messages.pop()!;
           console.error(
             "[lore] WARN: dropping trailing",