@eleboucher/pi-memini 0.7.7 → 0.7.8

package/README.md

@@ -155,7 +155,7 @@ authority is restored.
 | `MEMINI_CAPTURE`                     | on               | Settled-turn capture.                                                                         |
 | `MEMINI_RECALL_LIMIT`                | `3`              | Maximum automatic recall hits.                                                                |
 | `MEMINI_INJECT_RECALL_MAX_TOK`       | `250`            | Recall injection token ceiling; `0` is unbounded.                                             |
-| `MEMINI_INJECT_RECALL_MIN_SCORE`     | `0`              | Minimum automatic recall score.                                                               |
+| `MEMINI_INJECT_RECALL_MIN_SCORE`     | `0.5`            | Minimum automatic recall score (composite post-rerank scale); `0` disables the floor.         |
 | `MEMINI_INJECT_DEDUPE`               | on               | Shared cross-surface suppression state.                                                       |
 | `MEMINI_INJECT_COOLDOWN_MS`          | `1800000`        | Time cooldown for repeated injection; `0` disables this dimension.                            |
 | `MEMINI_INJECT_COOLDOWN_PROMPTS`     | `3`              | Prompt cooldown; `0` disables this dimension. Both cooldowns at `0` suppress for the session. |

package/dist/index.js

@@ -2,7 +2,6 @@
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { readFileSync } from "node:fs";
-import { createHash } from "node:crypto";
 
 // ../../../packages/memini-client/src/redact.ts
 function redactValue(value) {
@@ -111,12 +110,16 @@ var BEHAVIOR_KNOBS = [
   { envName: "MEMINI_INJECT_BRIEFING_MAX_TOK", wireKey: "inject_briefing_max_tok", kind: "int", default: 600 },
   { envName: "MEMINI_INJECT_PRETOOL_ITEMS", wireKey: "inject_pretool_items", kind: "int", default: 3 },
   { envName: "MEMINI_INJECT_PRETOOL_MAX_TOK", wireKey: "inject_pretool_max_tok", kind: "int", default: 200 },
-  { envName: "MEMINI_INJECT_PRETOOL_MIN_SCORE", wireKey: "inject_pretool_min_score", kind: "float", default: 0 },
+  { envName: "MEMINI_INJECT_PRETOOL_MIN_SCORE", wireKey: "inject_pretool_min_score", kind: "float", default: 0.5 },
+  // Glob and Grep are deliberately not in the default allowlist:
+  // pattern-derived queries ("Grep on <pattern>") are near-zero-signal and
+  // each ungated call costs a server embed+rerank — list them to restore the
+  // old behavior.
   {
     envName: "MEMINI_INJECT_PRETOOL_TOOLS",
     wireKey: "inject_pretool_tools",
     kind: "list",
-    default: ["Read", "Write", "Edit", "MultiEdit", "Glob", "Grep"]
+    default: ["Read", "Write", "Edit", "MultiEdit"]
   },
   { envName: "MEMINI_INJECT_PRETOOL_GATE_MS", wireKey: "inject_pretool_gate_ms", kind: "int", default: 9e4 },
   { envName: "MEMINI_INJECT_DEDUPE", wireKey: "inject_dedupe", kind: "bool", default: true },
@@ -128,7 +131,7 @@ var BEHAVIOR_KNOBS = [
   { envName: "MEMINI_CAPTURE", wireKey: "capture", kind: "bool", default: true },
   { envName: "MEMINI_RECALL_LIMIT", wireKey: "recall_limit", kind: "int", default: 3 },
   { envName: "MEMINI_INJECT_RECALL_MAX_TOK", wireKey: "inject_recall_max_tok", kind: "int", default: 250 },
-  { envName: "MEMINI_INJECT_RECALL_MIN_SCORE", wireKey: "inject_recall_min_score", kind: "float", default: 0 },
+  { envName: "MEMINI_INJECT_RECALL_MIN_SCORE", wireKey: "inject_recall_min_score", kind: "float", default: 0.5 },
   { envName: "MEMINI_MIN_CAPTURE_CHARS", wireKey: "min_capture_chars", kind: "int", default: 0 },
   { envName: "MEMINI_CAPTURE_USER_MAX_CHARS", wireKey: "capture_user_max_chars", kind: "int", default: 1e3 },
   {
@@ -322,6 +325,88 @@ async function performHandshake(boot, facts, opts = {}) {
   }
 }
 
+// ../../../packages/memini-client/src/enforce/identity.ts
+import crypto from "node:crypto";
+function isContentHash(s) {
+  return typeof s === "string" && /^[0-9a-f]{16}$/.test(s);
+}
+function injectedIdentity(m) {
+  const ch = m?.content_hash ?? m?.memory?.content_hash;
+  if (isContentHash(ch)) return ch;
+  const text = m?.content || m?.summary || "";
+  return crypto.createHash("sha256").update(text).digest("hex").slice(0, 16);
+}
+
+// ../../../packages/memini-client/src/enforce/seen.ts
+function injectedSuppressed(entry, identity, { now, counter, cooldownMs, cooldownPrompts }) {
+  if (!entry || typeof entry !== "object") return false;
+  if (entry.h === "") return true;
+  if (identity && entry.h !== identity) return false;
+  if (cooldownMs === 0 && cooldownPrompts === 0) return true;
+  const promptDim = cooldownPrompts > 0 && counter > 0 && counter - entry.n < cooldownPrompts;
+  const timeDim = cooldownMs > 0 && now - entry.at < cooldownMs;
+  return promptDim || timeDim;
+}
+
+// ../../../packages/memini-client/src/enforce/budget.ts
+function approxTokens(text) {
+  if (!text) return 0;
+  const words = String(text).trim().split(/\s+/).filter(Boolean).length;
+  return Math.max(1, Math.ceil(words * 4 / 3));
+}
+function fitByTokens(items, maxTokens) {
+  if (!Array.isArray(items) || items.length === 0) return { items: [], tokens: 0, dropped: 0 };
+  if (!Number.isFinite(maxTokens) || maxTokens <= 0) {
+    const tokens = items.reduce((sum, s) => sum + approxTokens(s), 0);
+    return { items: items.slice(), tokens, dropped: 0 };
+  }
+  const out = [];
+  let used = 0;
+  let dropped = 0;
+  for (const s of items) {
+    const t = approxTokens(s);
+    if (used + t > maxTokens) {
+      const charBudget = (maxTokens - used) * 4;
+      if (charBudget > 20) {
+        let cut = s.slice(0, charBudget);
+        const lastNL = cut.lastIndexOf("\n");
+        if (lastNL > 20) cut = cut.slice(0, lastNL);
+        if (cut.length > 20) {
+          out.push(cut + "\n[...truncated]");
+          used += approxTokens(cut);
+          continue;
+        }
+      }
+      dropped++;
+      continue;
+    }
+    out.push(s);
+    used += t;
+  }
+  return { items: out, tokens: used, dropped };
+}
+
+// ../../../packages/memini-client/src/enforce/render.ts
+function escapeMeminiTags(content) {
+  if (typeof content !== "string") return content;
+  return content.replace(/<(\/?)memini/gi, "&lt;$1memini");
+}
+function truncate(value, max) {
+  if (typeof value === "string") {
+    return value.length > max ? value.slice(0, max) + "\n[...truncated]" : value;
+  }
+  if (value && typeof value === "object") {
+    let str;
+    try {
+      str = JSON.stringify(value);
+    } catch {
+      return value;
+    }
+    return str.length > max ? str.slice(0, max) + "...[truncated]" : str;
+  }
+  return value;
+}
+
 // src/index.ts
 var DEFAULT_TIMEOUT_MS2 = 3e4;
 var DEFAULT_RECALL_LIMIT = 3;
@@ -460,45 +545,12 @@ async function sessionLive(ctx, env = process.env) {
   const hs = await ctx.memo.get();
   return resolveLiveConfig(ctx.boot, ctx.facts, hs, env);
 }
-function approxTokens(text) {
-  if (!text) return 0;
-  const words = String(text).trim().split(/\s+/).filter(Boolean).length;
-  return Math.max(1, Math.ceil(words * 4 / 3));
-}
-function fitByTokens(items, maxTokens) {
-  if (!Array.isArray(items) || items.length === 0) return { items: [], tokens: 0, dropped: 0 };
-  if (!Number.isFinite(maxTokens) || maxTokens <= 0) {
-    const tokens = items.reduce((sum, s) => sum + approxTokens(s), 0);
-    return { items: items.slice(), tokens, dropped: 0 };
-  }
-  const out = [];
-  let used = 0;
-  let dropped = 0;
-  for (const s of items) {
-    const t = approxTokens(s);
-    if (used + t > maxTokens) {
-      dropped++;
-      continue;
-    }
-    out.push(s);
-    used += t;
-  }
-  return { items: out, tokens: used, dropped };
-}
-function truncate(value, max) {
-  return value.length > max ? value.slice(0, max) + "\n[...truncated]" : value;
-}
-function escapeMeminiTags(value) {
-  return String(value ?? "").replace(/<(\/?)memini/gi, (_match, slash) => `&lt;${slash}memini`);
-}
 function boundedInjectedText(value, max) {
-  const escaped = escapeMeminiTags(value).replace(/\s+/g, " ").trim();
+  const escaped = escapeMeminiTags(String(value ?? "")).replace(/\s+/g, " ").trim();
   return unicodePrefix(escaped, max);
 }
-function injectedIdentity(raw) {
-  const memory = raw?.memory ?? raw ?? {};
-  const content = String(memory?.content || memory?.summary || "");
-  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+function injectedIdentity2(raw) {
+  return injectedIdentity(raw?.memory ?? raw);
 }
 function formatResults(results, limit, labels) {
   if (!Array.isArray(results) || results.length === 0) return [];
@@ -1213,6 +1265,10 @@ function isExplicitExcludeIdsRejection(result) {
   if (result.status !== 400 || !result.error || !/exclude_ids/i.test(result.error)) return false;
   return /(unknown|unsupported|unrecognized|unexpected|not allowed|additional propert)/i.test(result.error);
 }
+function isExplicitMinRankScoreRejection(result) {
+  if (result.status !== 400 || !result.error || !/min_rank_score/i.test(result.error)) return false;
+  return /(unknown|unsupported|unrecognized|unexpected|not allowed|additional propert)/i.test(result.error);
+}
 function extractSettledTurn(entries) {
   if (!Array.isArray(entries)) return null;
   let userIndex = -1;
@@ -1412,7 +1468,7 @@ function meminiExtension(pi) {
       if (!id) continue;
       changed = true;
       injected.delete(id);
-      injected.set(id, { h: explicitRead ? "" : injectedIdentity(raw), at: now, n: promptCount });
+      injected.set(id, { h: explicitRead ? "" : injectedIdentity2(raw), at: now, n: promptCount });
     }
     while (injected.size > MAX_INJECTED) injected.delete(injected.keys().next().value);
     if (changed) persistState();
@@ -1445,14 +1501,7 @@ function meminiExtension(pi) {
     });
     rememberInjected(eligible, transition.explicit);
   };
-  const suppressed = (entry, now, cooldownMs, cooldownPrompts, identity) => {
-    if (entry.h === "") return true;
-    if (identity && entry.h !== identity) return false;
-    if (cooldownMs === 0 && cooldownPrompts === 0) return true;
-    const promptDim = cooldownPrompts > 0 && promptCount > 0 && promptCount - entry.n < cooldownPrompts;
-    const timeDim = cooldownMs > 0 && now - entry.at < cooldownMs;
-    return promptDim || timeDim;
-  };
+  const suppressed = (entry, now, cooldownMs, cooldownPrompts, identity) => injectedSuppressed(entry, identity ?? null, { now, counter: promptCount, cooldownMs, cooldownPrompts });
   const injectedInWindow = (live) => {
     const inWindow = /* @__PURE__ */ new Map();
     if (!live.inject_dedupe) return inWindow;
@@ -1582,18 +1631,27 @@ function meminiExtension(pi) {
     return null;
   };
   const searchExcluding = async (body, excludeIds, namespace) => {
+    const rankFloorInBody = body.min_rank_score !== void 0;
     const capped = excludeIds.slice(0, MAX_SERVER_EXCLUDE_IDS);
-    if (!serverExcludeIds || capped.length === 0) return client.postJson("/v1/search", body, namespace);
-    const first = await client.postJsonResult("/v1/search", { ...body, exclude_ids: capped }, namespace);
-    if (first.ok) return first.data;
-    if (!isExplicitExcludeIdsRejection(first)) return searchFailure(first);
-    const retry = await client.postJsonResult("/v1/search", body, namespace);
-    if (retry.ok) {
+    const withExcludeIds = serverExcludeIds && capped.length > 0;
+    const first = await client.postJsonResult(
+      "/v1/search",
+      withExcludeIds ? { ...body, exclude_ids: capped } : body,
+      namespace
+    );
+    if (first.ok) return { data: first.data, rankFloorStripped: false };
+    const excludeIdsRejected = withExcludeIds && isExplicitExcludeIdsRejection(first);
+    const rankFloorRejected = rankFloorInBody && isExplicitMinRankScoreRejection(first);
+    if (!excludeIdsRejected && !rankFloorRejected) return { data: searchFailure(first), rankFloorStripped: false };
+    if (excludeIdsRejected) {
       serverExcludeIds = false;
       warn("memini: server does not accept exclude_ids; using client-side dedupe only");
-      return retry.data;
     }
-    return searchFailure(retry);
+    const stripped = { ...body };
+    delete stripped.min_rank_score;
+    const retry = await client.postJsonResult("/v1/search", stripped, namespace);
+    if (retry.ok) return { data: retry.data, rankFloorStripped: rankFloorInBody };
+    return { data: searchFailure(retry), rankFloorStripped: false };
   };
   pi.on("before_agent_start", async (event, ctx) => {
     const sid = sessionIdOf(ctx);
@@ -1612,12 +1670,16 @@ function meminiExtension(pi) {
       limit: live.recall_limit
     };
     if (live.inject_dedupe && sid) body.exclude_metadata = { session_id: sid };
-    if (live.recall_min_score > 0) body.min_score = live.recall_min_score;
+    const rankFloor = live.recall_min_score;
+    const rankFloorInRange = rankFloor > 0 && rankFloor < 1;
+    if (rankFloorInRange) body.min_rank_score = rankFloor;
     const inWindow = injectedInWindow(live);
     const readVersion = mutationClock;
     const readEpoch = stateEpoch;
-    const result = await searchExcluding(body, live.inject_dedupe ? [...inWindow.keys()] : [], live.namespace);
-    const floor = live.recall_min_score > 0 ? live.recall_min_score : 0;
+    const searchResult = await searchExcluding(body, live.inject_dedupe ? [...inWindow.keys()] : [], live.namespace);
+    const result = searchResult.data;
+    const serverEnforcedFloor = rankFloorInRange && !searchResult.rankFloorStripped;
+    const floor = rankFloor > 0 && !serverEnforcedFloor ? rankFloor : 0;
     let rawHits = Array.isArray(result?.results) ? result.results : [];
     if (live.inject_dedupe && inWindow.size) {
       rawHits = rawHits.filter((raw) => {
@@ -1628,7 +1690,7 @@ function meminiExtension(pi) {
           Date.now(),
           live.inject_cooldown_ms,
           live.inject_cooldown_prompts,
-          injectedIdentity(raw)
+          injectedIdentity2(raw)
         );
       });
     }
@@ -1729,6 +1791,9 @@ function meminiExtension(pi) {
         maxItems: MAX_SERVER_EXCLUDE_IDS,
         description: "Drop these memory ids before ranking and limit."
       })),
+      min_rank_score: Type.Optional(Type.Number({
+        description: "drop results whose final ranked score is below this ([0,1)); rarely needed \u2014 the server already gates relevance"
+      })),
       include_fresh_turns: Type.Optional(Type.Boolean({
         description: "Include just-captured turns normally hidden by the temporal echo guard."
       })),
@@ -1757,6 +1822,7 @@ function meminiExtension(pi) {
         "metadata",
         "exclude_metadata",
         "exclude_ids",
+        "min_rank_score",
         "include_fresh_turns",
         "query_rewrite",
         "as_of"
@@ -2123,9 +2189,10 @@ export {
   fitByTokens,
   floatEnv,
   formatResults,
-  injectedIdentity,
+  injectedIdentity2 as injectedIdentity,
   intEnv,
   isExplicitExcludeIdsRejection,
+  isExplicitMinRankScoreRejection,
   meminiListPath,
   memoizeAsync,
   memoryResultDetails,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleboucher/pi-memini",
-  "version": "0.7.7",
+  "version": "0.7.8",
   "description": "Shared cross-session memory for the Pi coding agent, backed by a memini service.",
   "keywords": [
     "memini",