@fonlan/dsh-gitmemo 0.4.1 → 0.5.1

package/lib/systemone.js

@@ -52,6 +52,8 @@ export const NOUL_CRITERIA = {
 };
 /** The judgement asked of the model in `score` mode. */
 export const SCORE_INSTRUCTION = "How relevant is the `candidate` memory record to the `task`? Rate how reusable its conclusions, decisions, constraints, or findings are for this exact task.";
+/** Accepted `policy` values, for config validation and tool schemas. */
+export const GATE_POLICIES = ["rerank", "filter"];
 /** Trim a candidate summary before it is sent to the model. */
 function clamp(text, limit) {
     const collapsed = text.replace(/\s+/g, " ").trim();
@@ -153,7 +155,29 @@ export function parseUsage(payload) {
  * @returns kept/dropped hash lists and per-candidate verdicts.
  */
 export function decide(candidates, values, options) {
+    // `decide` is the low-level primitive: with no explicit policy it applies the
+    // literal threshold semantics, and with no explicit bound it applies none. The
+    // product policy (rerank by default, 25 % drop cap) lives in the config layer,
+    // which passes both in explicitly — the same split as `minKeep`.
+    const policy = options.policy ?? "filter";
     const cutoff = options.mode === "noul" ? options.threshold : options.scoreMin;
+    if (policy === "rerank") {
+        // Reordering cannot lose a memory: report every judged candidate as kept and
+        // let `ordered` carry the ranking. The threshold verdict is still visible in
+        // each verdict's `value`.
+        const all = candidates.map((candidate, index) => ({
+            hash: candidate.hash,
+            value: values[index] ?? null,
+            keep: true
+        }));
+        return {
+            kept: candidates.map((c) => c.hash),
+            dropped: [],
+            verdicts: all,
+            floored: false,
+            bounded: false
+        };
+    }
     const verdicts = candidates.map((candidate, index) => {
         const value = values[index];
         if (value === undefined)
@@ -179,12 +203,40 @@ export function decide(candidates, values, options) {
         kept = verdicts.filter((v) => v.keep).map((v) => v.hash);
         floored = true;
     }
+    // Bound the damage: a threshold that rejects most of a page is far more
+    // likely to be mis-calibrated than the page is to be mostly irrelevant, and
+    // the cost of the two errors is not symmetric — a dropped memory is gone,
+    // a kept one only costs context. Restore the best-scoring rejects until the
+    // drop share is within `maxDropFraction`.
+    let bounded = false;
+    const maxDropFraction = options.maxDropFraction ?? 1;
+    if (candidates.length > 0 && maxDropFraction < 1) {
+        const allowedDrops = Math.max(0, Math.floor(candidates.length * Math.max(0, maxDropFraction)));
+        const dropCount = candidates.length - kept.length;
+        if (dropCount > allowedDrops) {
+            const restoreCount = dropCount - allowedDrops;
+            const rejects = verdicts
+                .map((verdict, index) => ({ verdict, index }))
+                .filter((entry) => !entry.verdict.keep)
+                .sort((a, b) => {
+                const av = a.verdict.value ?? Number.NEGATIVE_INFINITY;
+                const bv = b.verdict.value ?? Number.NEGATIVE_INFINITY;
+                return bv - av || a.index - b.index;
+            })
+                .slice(0, restoreCount);
+            for (const entry of rejects)
+                entry.verdict.keep = true;
+            kept = verdicts.filter((v) => v.keep).map((v) => v.hash);
+            bounded = true;
+        }
+    }
     const keptSet = new Set(kept);
     return {
         kept,
         dropped: candidates.map((c) => c.hash).filter((hash) => !keptSet.has(hash)),
         verdicts,
-        floored
+        floored,
+        bounded
     };
 }
 /** Combine a caller signal with a timeout, keeping both cancellation sources. */
@@ -206,12 +258,15 @@ function withTimeout(signal, timeoutMs) {
  */
 export async function evaluateGate(task, candidates, options, signal) {
     const mode = options.mode;
+    const policy = options.policy ?? "rerank";
     const base = {
         mode,
-        model: options.model
+        model: options.model,
+        policy,
+        bounded: false
     };
     if (candidates.length === 0) {
-        return { ...base, kept: [], dropped: [], verdicts: [], judged: 0, untouched: 0, degraded: false };
+        return { ...base, kept: [], dropped: [], verdicts: [], ordered: [], judged: 0, untouched: 0, degraded: false };
     }
     const judged = candidates.slice(0, Math.max(1, options.maxCandidates));
     const untouched = candidates.slice(judged.length);
@@ -220,6 +275,7 @@ export async function evaluateGate(task, candidates, options, signal) {
         kept: candidates.map((c) => c.hash),
         dropped: [],
         verdicts: candidates.map((c) => ({ hash: c.hash, value: null, keep: true })),
+        ordered: candidates.map((c) => c.hash),
         judged: judged.length,
         untouched: untouched.length,
         degraded: true,
@@ -260,24 +316,44 @@ export async function evaluateGate(task, candidates, options, signal) {
         return keepAll("system-one request failed: " + detail);
     }
     const values = parseAnswers(payload, mode, judged.length);
-    const decision = decide(judged, values, options);
+    const decision = decide(judged, values, { ...options, policy });
     // Candidates past `maxCandidates` were never evaluated, so they are never
     // removed: the gate may only drop what it actually judged. Leaving them out
     // of the kept set would silently truncate every page larger than the cap.
     const keptSet = new Set([...decision.kept, ...untouched.map((c) => c.hash)]);
+    const verdicts = [
+        ...decision.verdicts,
+        ...untouched.map((c) => ({ hash: c.hash, value: null, keep: true }))
+    ];
+    // Best value first; nulls (unjudged / unreadable) keep page order at the end.
+    const ordered = candidates
+        .map((candidate, index) => ({ candidate, index, value: verdicts[index]?.value ?? null }))
+        .sort((a, b) => {
+        if (a.value === b.value)
+            return a.index - b.index;
+        if (a.value === null)
+            return 1;
+        if (b.value === null)
+            return -1;
+        return b.value - a.value;
+    })
+        .map((entry) => entry.candidate.hash);
     const usage = parseUsage(payload);
     return {
         ...base,
+        ordered,
+        bounded: decision.bounded,
         kept: [...candidates.map((c) => c.hash).filter((hash) => keptSet.has(hash))],
         dropped: decision.dropped,
-        verdicts: [
-            ...decision.verdicts,
-            ...untouched.map((c) => ({ hash: c.hash, value: null, keep: true }))
-        ],
+        verdicts,
         judged: judged.length,
         untouched: untouched.length,
         degraded: false,
         ...(usage === undefined ? {} : { usage }),
-        ...(decision.floored ? { reason: "no candidate scored above the threshold; retained top " + decision.kept.length } : {})
+        ...(decision.floored
+            ? { reason: "no candidate scored above the threshold; retained top " + decision.kept.length }
+            : decision.bounded
+                ? { reason: "threshold would have dropped more than maxDropFraction; restored the best-scoring rejects" }
+                : {})
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fonlan/dsh-gitmemo",
-  "version": "0.4.1",
+  "version": "0.5.1",
   "description": "Git-backed long-term memory for DeepSeek Harness: a local .mem git repo (single main branch, immutable entries, structured commit messages) with mem_search / mem_read / mem_write / mem_delete / mem_replace tools and fully automatic legacy migration (no CLI needed; the CLI remains for explicit control), auto-managed by the root agent with zero manual steps.",
   "author": "fonlan",
   "publishConfig": {
@@ -48,6 +48,10 @@
     "bundle": "tsdown",
     "watch": "tsdown --watch",
     "test": "npm run build && node --test",
+    "eval:lme": "node evals/longmemeval/run_retrieval.mjs",
+    "eval:lme:oracle": "node evals/longmemeval/run_retrieval.mjs --split oracle",
+    "eval:lme:s": "node --max-old-space-size=8192 evals/longmemeval/run_retrieval.mjs --split s --concurrency 8",
+    "eval:omni:setup": "node evals/omnimemeval/setup.mjs",
     "prepublishOnly": "npm run build",
     "release:patch": "npm version patch && git push && git push --tags",
     "release:minor": "npm version minor && git push && git push --tags",