greprag 5.74.18 → 5.74.19

package/dist/opencode-plugin-crush.js

@@ -59,6 +59,7 @@ exports.classifyContent = classifyContent;
 exports.crushField = crushField;
 exports.crushMessages = crushMessages;
 const crush_1 = require("./crush");
+const crypto_1 = require("crypto");
 // ---------- CCR marker (inlined — see header: ccr-store.ts drags sql.js) ------
 /** First 16 hex of sha256 — must match ccr-store.ts CCR_MARKER_HASH_LEN. */
 const CCR_MARKER_HASH_LEN = 16;
@@ -157,13 +158,19 @@ function runEngine(type, content) {
  *  passthrough, and token-validate-or-revert. The stash side effect fires ONLY
  *  on a real crush (after validation passes), so a reverted/skipped field is
  *  never persisted. */
-function crushField(content, stash, thresholdBytes = exports.DEFAULT_THRESHOLD_BYTES) {
+function crushField(content, stash, thresholdBytes = exports.DEFAULT_THRESHOLD_BYTES, seenHashes) {
     if (typeof content !== 'string')
         return null;
     if (CCR_MARKER_RE.test(content))
         return null; // idempotent
     if (Buffer.byteLength(content, 'utf8') < thresholdBytes)
         return null; // below floor
+    // Compute the stash hash first — if we've already stashed this exact
+    // content (e.g. it was retrieved via greprag retrieve), skip re-crushing
+    // to break the infinite marker→retrieve→same-marker loop.
+    const contentHash = (0, crypto_1.createHash)('sha256').update(content, 'utf8').digest('hex').slice(0, CCR_MARKER_HASH_LEN);
+    if (seenHashes?.has(contentHash))
+        return null;
     const type = classifyContent(content);
     const result = runEngine(type, content);
     if (result.stats.passthrough)
@@ -177,6 +184,7 @@ function crushField(content, stash, thresholdBytes = exports.DEFAULT_THRESHOLD_B
     if (finalTokens >= (0, crush_1.estimateTokens)(content))
         return null;
     const hash = stash(content, type);
+    seenHashes?.add(hash);
     return `${crushed}\n${ccrMarker(hash)}`;
 }
 // ---------- Message-array walker ----------------------------------------------
@@ -203,7 +211,7 @@ function resolveRetrieveCommand(p) {
  *  ORIGINAL content, and crush is deterministic, so the reused value is exactly
  *  what crushField would recompute; the original was already stashed on the
  *  first (miss) crush, so skipping re-stash is safe for retrieve. */
-function crushAndApply(obj, key, stash, thresholdBytes, stats, memo) {
+function crushAndApply(obj, key, stash, thresholdBytes, stats, memo, seenHashes) {
     const content = obj[key];
     if (typeof content !== 'string')
         return;
@@ -225,13 +233,13 @@ function crushAndApply(obj, key, stash, thresholdBytes, stats, memo) {
             stats.memoHits++;
         }
         else {
-            replacement = crushField(content, stash, thresholdBytes);
+            replacement = crushField(content, stash, thresholdBytes, seenHashes);
             stats.crushFieldCalls++;
             memo.set(k, replacement);
         }
     }
     else {
-        replacement = crushField(content, stash, thresholdBytes);
+        replacement = crushField(content, stash, thresholdBytes, seenHashes);
         stats.crushFieldCalls++;
     }
     if (replacement === null) {
@@ -247,30 +255,18 @@ function crushAndApply(obj, key, stash, thresholdBytes, stats, memo) {
  *   - text part  → `.text`
  *   - tool part  → `.state.output` (only when state.status === 'completed';
  *                  an 'error' state's `.error` is precious — left alone). */
-function processPart(part, stash, thresholdBytes, stats, memo) {
+function processPart(part, stash, thresholdBytes, stats, memo, seenHashes) {
     if (!part || typeof part !== 'object')
         return;
     const p = part;
     if (p.type === 'text' && typeof p.text === 'string') {
-        crushAndApply(p, 'text', stash, thresholdBytes, stats, memo);
+        crushAndApply(p, 'text', stash, thresholdBytes, stats, memo, seenHashes);
         return;
     }
     if (p.type === 'tool' && p.state && typeof p.state === 'object') {
         const state = p.state;
         if (state.status === 'completed' && typeof state.output === 'string') {
-            // Skip re-crushing output of greprag retrieve — the original was
-            // already stashed once; crushing it again creates an infinite
-            // marker→retrieve→same marker loop.
-            // The tool name / command may live on p.input.command (tool_use
-            // part) or on p.name / p.tool (tool_result part) depending on
-            // the opencode message format version.
-            const cmd = resolveRetrieveCommand(p);
-            if (cmd && cmd.includes('greprag retrieve')) {
-                stats.partsSkipped++;
-            }
-            else {
-                crushAndApply(state, 'output', stash, thresholdBytes, stats, memo);
-            }
+            crushAndApply(state, 'output', stash, thresholdBytes, stats, memo, seenHashes);
         }
     }
 }
@@ -285,6 +281,7 @@ function crushMessages(messages, opts) {
         crushFieldCalls: 0, memoHits: 0,
     };
     const thresholdBytes = opts.thresholdBytes ?? exports.DEFAULT_THRESHOLD_BYTES;
+    const seenHashes = opts.seenHashes ?? new Set();
     if (!Array.isArray(messages))
         return stats;
     for (const msg of messages) {
@@ -293,7 +290,7 @@ function crushMessages(messages, opts) {
             continue;
         for (const part of parts) {
             try {
-                processPart(part, opts.stash, thresholdBytes, stats, opts.memo);
+                processPart(part, opts.stash, thresholdBytes, stats, opts.memo, seenHashes);
             }
             catch {
                 // per-part swallow — a crush/stash failure must never break the turn

package/dist/opencode-plugin.bundle.js

@@ -1600,6 +1600,7 @@ function crushCode(content, config = {}) {
 }
 
 // ../greprag/packages/cli/src/opencode-plugin-crush.ts
+var import_crypto = require("crypto");
 var CCR_MARKER_HASH_LEN = 16;
 function ccrMarker(hash) {
   return `<<ccr:${hash.slice(0, CCR_MARKER_HASH_LEN)}>>`;
@@ -1645,13 +1646,16 @@ function runEngine(type, content) {
       return crushLog(content);
   }
 }
-function crushField(content, stash, thresholdBytes = DEFAULT_THRESHOLD_BYTES) {
+function crushField(content, stash, thresholdBytes = DEFAULT_THRESHOLD_BYTES, seenHashes) {
   if (typeof content !== "string")
     return null;
   if (CCR_MARKER_RE.test(content))
     return null;
   if (Buffer.byteLength(content, "utf8") < thresholdBytes)
     return null;
+  const contentHash = (0, import_crypto.createHash)("sha256").update(content, "utf8").digest("hex").slice(0, CCR_MARKER_HASH_LEN);
+  if (seenHashes?.has(contentHash))
+    return null;
   const type = classifyContent(content);
   const result = runEngine(type, content);
   if (result.stats.passthrough)
@@ -1661,19 +1665,11 @@ function crushField(content, stash, thresholdBytes = DEFAULT_THRESHOLD_BYTES) {
   if (finalTokens >= estimateTokens(content))
     return null;
   const hash = stash(content, type);
+  seenHashes?.add(hash);
   return `${crushed}
 ${ccrMarker(hash)}`;
 }
-function resolveRetrieveCommand(p) {
-  const input = p.input;
-  if (input && typeof input.command === "string")
-    return input.command;
-  const toolName = typeof p.name === "string" && p.name || typeof p.tool === "string" && p.tool || typeof p.toolName === "string" && p.toolName;
-  if (toolName)
-    return toolName;
-  return "";
-}
-function crushAndApply(obj, key, stash, thresholdBytes, stats, memo) {
+function crushAndApply(obj, key, stash, thresholdBytes, stats, memo, seenHashes) {
   const content = obj[key];
   if (typeof content !== "string")
     return;
@@ -1694,12 +1690,12 @@ function crushAndApply(obj, key, stash, thresholdBytes, stats, memo) {
       replacement = memo.get(k) ?? null;
       stats.memoHits++;
     } else {
-      replacement = crushField(content, stash, thresholdBytes);
+      replacement = crushField(content, stash, thresholdBytes, seenHashes);
       stats.crushFieldCalls++;
       memo.set(k, replacement);
     }
   } else {
-    replacement = crushField(content, stash, thresholdBytes);
+    replacement = crushField(content, stash, thresholdBytes, seenHashes);
     stats.crushFieldCalls++;
   }
   if (replacement === null) {
@@ -1711,23 +1707,18 @@ function crushAndApply(obj, key, stash, thresholdBytes, stats, memo) {
   stats.partsCrushed++;
   stats.bytesAfter += Buffer.byteLength(replacement, "utf8");
 }
-function processPart(part, stash, thresholdBytes, stats, memo) {
+function processPart(part, stash, thresholdBytes, stats, memo, seenHashes) {
   if (!part || typeof part !== "object")
     return;
   const p = part;
   if (p.type === "text" && typeof p.text === "string") {
-    crushAndApply(p, "text", stash, thresholdBytes, stats, memo);
+    crushAndApply(p, "text", stash, thresholdBytes, stats, memo, seenHashes);
     return;
   }
   if (p.type === "tool" && p.state && typeof p.state === "object") {
     const state = p.state;
     if (state.status === "completed" && typeof state.output === "string") {
-      const cmd = resolveRetrieveCommand(p);
-      if (cmd && cmd.includes("greprag retrieve")) {
-        stats.partsSkipped++;
-      } else {
-        crushAndApply(state, "output", stash, thresholdBytes, stats, memo);
-      }
+      crushAndApply(state, "output", stash, thresholdBytes, stats, memo, seenHashes);
     }
   }
 }
@@ -1742,6 +1733,7 @@ function crushMessages(messages, opts) {
     memoHits: 0
   };
   const thresholdBytes = opts.thresholdBytes ?? DEFAULT_THRESHOLD_BYTES;
+  const seenHashes = opts.seenHashes ?? /* @__PURE__ */ new Set();
   if (!Array.isArray(messages))
     return stats;
   for (const msg of messages) {
@@ -1750,7 +1742,7 @@ function crushMessages(messages, opts) {
       continue;
     for (const part of parts) {
       try {
-        processPart(part, opts.stash, thresholdBytes, stats, opts.memo);
+        processPart(part, opts.stash, thresholdBytes, stats, opts.memo, seenHashes);
       } catch {
         stats.partsSkipped++;
       }
@@ -4498,6 +4490,7 @@ function grepragBinCached() {
   return _cachedGrepragBin;
 }
 var _crushShapeLogged = false;
+var _crushSeenHashes;
 function inlineCrushEnabled() {
   const v = process.env.GREPRAG_OPENCODE_CRUSH;
   return v === "true" || v === "1";
@@ -4740,7 +4733,8 @@ ALWAYS pass \`--from-session ${sid82}\` when you run \`greprag send\`, so recipi
         const thresholdEnv = parseInt(process.env.GREPRAG_OPENCODE_CRUSH_MIN_BYTES || "", 10);
         const stats = crushMessages(msgs, {
           stash: makeCcrStash(),
-          thresholdBytes: Number.isFinite(thresholdEnv) && thresholdEnv > 0 ? thresholdEnv : void 0
+          thresholdBytes: Number.isFinite(thresholdEnv) && thresholdEnv > 0 ? thresholdEnv : void 0,
+          seenHashes: _crushSeenHashes ?? (_crushSeenHashes = /* @__PURE__ */ new Set())
         });
         if (stats.partsCrushed > 0 || stats.partsReverted > 0) {
           dlog(

package/dist/opencode-plugin.js

@@ -792,6 +792,9 @@ function grepragBinCached() {
  *  crusher's assumptions. See the chip report: live propagation + shape are
  *  the two things only a real opencode restart can verify. */
 let _crushShapeLogged = false;
+/** Per-session set of hashes already stashed — prevents re-crushing content
+ *  that was already compressed once (e.g. retrieved via greprag retrieve). */
+let _crushSeenHashes;
 /** GREPRAG_OPENCODE_CRUSH gate — opt-in, default OFF for safe rollout. */
 function inlineCrushEnabled() {
     const v = process.env.GREPRAG_OPENCODE_CRUSH;
@@ -1115,6 +1118,7 @@ const GrepRAGMemoryPlugin = async (ctx) => {
                 const stats = (0, opencode_plugin_crush_1.crushMessages)(msgs, {
                     stash: makeCcrStash(),
                     thresholdBytes: Number.isFinite(thresholdEnv) && thresholdEnv > 0 ? thresholdEnv : undefined,
+                    seenHashes: _crushSeenHashes ?? (_crushSeenHashes = new Set()),
                 });
                 if (stats.partsCrushed > 0 || stats.partsReverted > 0) {
                     dlog(`messages.transform: crushed=${stats.partsCrushed} reverted=${stats.partsReverted} ` +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "greprag",
-  "version": "5.74.18",
+  "version": "5.74.19",
   "description": "GrepRAG — agent memory for Claude Code, Codex, and OpenCode.",
   "main": "dist/index.js",
   "bin": {