@remnic/bench 9.6.9 → 9.6.11

package/dist/index.d.ts

@@ -131,6 +131,17 @@ interface BenchMemoryAdapter {
     store(sessionId: string, messages: Message[], control?: BenchPhaseControl): Promise<void>;
     recall(sessionId: string, query: string, budgetChars?: number, options?: BenchRecallOptions, control?: BenchPhaseControl): Promise<string>;
     search(query: string, limit: number, sessionId?: string, control?: BenchPhaseControl): Promise<SearchResult[]>;
+    /**
+     * Optional explicit-correction surface (issue #1584 plan item 2a). Routes a
+     * natural-language correction through the system's correction contract
+     * (plan + confirmed apply) instead of a plain turn store. Resolves
+     * `{ applied: false }` when the planner produced no applicable actions so
+     * the caller can fall back to the turn path. Adapters without an explicit
+     * correction surface omit this method entirely.
+     */
+    correct?(sessionId: string, text: string, at?: string, control?: BenchPhaseControl): Promise<{
+        applied: boolean;
+    }>;
     reset(sessionId?: string, control?: BenchPhaseControl): Promise<void>;
     getStats(sessionId?: string, control?: BenchPhaseControl): Promise<MemoryStats>;
     /** Wait for background summarization (e.g. LCM) to finish after store(). */

package/dist/index.js

@@ -620,6 +620,7 @@ import {
   buildExplicitCueRecallSection,
   buildTrajectoryAnalysisRecallSection,
   collectExplicitTurnReferences,
+  EngramAccessService,
   expandTildePath,
   normalizeTurnExpansionEnd,
   Orchestrator,
@@ -1131,6 +1132,27 @@ function benchCoreMemoryTier(memory) {
 function benchCoreMemorySource(sessionId) {
   return `bench-replay-${createHash("sha256").update(sessionId).digest("hex").slice(0, 16)}`;
 }
+function resolveSessionScopedCorrectionDecision(plan, ownedIds, phase) {
+  const actionTargets = [];
+  for (const action of plan.actions) {
+    if (action.kind === "supersede") actionTargets.push(action.loserId);
+    else if (action.kind !== "redaction_rule") actionTargets.push(action.memoryId);
+  }
+  const foreignIds = actionTargets.filter((id) => !ownedIds.has(id));
+  if (phase === "initial") {
+    const ownedAffected = plan.affected.filter((entry) => ownedIds.has(entry.memoryId));
+    if (plan.affected.length > 0 && ownedAffected.length === 0) {
+      return { kind: "no-owned-target" };
+    }
+    if (ownedAffected.length < plan.affected.length) {
+      return { kind: "replan", targetIds: ownedAffected.map((entry) => entry.memoryId) };
+    }
+  }
+  if (foreignIds.length > 0) {
+    return { kind: "foreign-actions", foreignIds };
+  }
+  return { kind: "proceed" };
+}
 function benchEntityStructuredFactSourceDir(memoryDir) {
   return path.join(memoryDir, "state", "bench-entity-structured-facts");
 }
@@ -1837,6 +1859,16 @@ function createAdapterFactory(mode) {
       coreReplayChain = coreReplayChain.catch(() => void 0).then(() => trackedCleanup).catch(() => void 0);
       void trackedCleanup;
     };
+    let correctionAccess;
+    const getCorrectionAccess = () => {
+      if (!correctionAccess || correctionAccess.orchestrator !== state.orchestrator) {
+        correctionAccess = {
+          service: new EngramAccessService(state.orchestrator),
+          orchestrator: state.orchestrator
+        };
+      }
+      return correctionAccess.service;
+    };
     return {
       async store(sessionId, messages, control) {
         throwIfBenchPhaseAborted(control, "store");
@@ -2381,6 +2413,71 @@ ${expanded.map((message) => `[${message.role}]: ${message.content}`).join("\n")}
         });
         sessionTurnCounters.clear();
       },
+      async correct(sessionId, text, _at, control) {
+        throwIfBenchPhaseAborted(control, "correct");
+        sessionId = normalizeBenchSessionId(sessionId);
+        const access2 = getCorrectionAccess();
+        const discardPlan = async (planId) => {
+          await access2.correctionDiscard(planId, { sessionKey: sessionId }).catch(() => void 0);
+        };
+        let plan = await withBenchPhaseAbort(
+          access2.correctionPlan({ text, sessionKey: sessionId }),
+          control,
+          "correct"
+        );
+        const sessionSource = benchCoreMemorySource(sessionId);
+        const owned = new Set(
+          (await readBenchCoreMemories(state.orchestrator)).filter((memory) => memory.frontmatter.source === sessionSource).map((memory) => memory.frontmatter.id)
+        );
+        let replanned = false;
+        const decision = resolveSessionScopedCorrectionDecision(plan, owned, "initial");
+        if (decision.kind === "no-owned-target") {
+          await discardPlan(plan.planId);
+          return { applied: false };
+        }
+        if (decision.kind === "replan") {
+          await discardPlan(plan.planId);
+          replanned = true;
+          plan = await withBenchPhaseAbort(
+            access2.correctionPlan({
+              text,
+              sessionKey: sessionId,
+              targetIds: decision.targetIds
+            }),
+            control,
+            "correct"
+          );
+        }
+        const finalDecision = resolveSessionScopedCorrectionDecision(
+          plan,
+          owned,
+          replanned ? "replanned" : "initial"
+        );
+        if (finalDecision.kind === "foreign-actions") {
+          await discardPlan(plan.planId);
+          throw new Error(
+            `correction plan drafts actions against ${finalDecision.foreignIds.length} foreign-session memory(ies) (${finalDecision.foreignIds.join(", ")}) \u2014 the bench harness cannot scope this correction; refusing to apply or mismeasure`
+          );
+        }
+        if (plan.actions.length === 0) {
+          await discardPlan(plan.planId);
+          if (replanned || plan.affected.length > 0) {
+            throw new Error(
+              `correction planner drafted no applicable action (${replanned ? "re-planned with explicit session-owned targets" : `${plan.affected.length} candidate(s) located`}; warnings: ${plan.warnings.join("; ") || "none"}) \u2014 refusing to measure the turn path as contract behavior`
+            );
+          }
+          return { applied: false };
+        }
+        const outcome = await withBenchPhaseAbort(
+          access2.correctionApply(plan.planId, {
+            confirm: true,
+            sessionKey: sessionId
+          }),
+          control,
+          "correct"
+        );
+        return { applied: outcome.status === "applied" };
+      },
       async drain(control) {
         throwIfBenchPhaseAborted(control, "drain");
         const engine = getEngine();
@@ -3328,6 +3425,16 @@ function createTimeoutGuardedAdapter(adapter, options) {
       drainTimeoutMs
     );
   }
+  if (adapter.correct) {
+    wrapped.correct = (sessionId, text, at, control) => phaseTimeoutMs === void 0 ? adapter.correct(sessionId, text, at, control) : run(`correct session=${sessionId}`, async (signal) => {
+      const merged = mergeBenchPhaseControl(signal, control);
+      try {
+        return await adapter.correct(sessionId, text, at, merged.control);
+      } finally {
+        merged.cleanup();
+      }
+    });
+  }
   if (adapter.responder) {
     wrapped.responder = phaseTimeoutMs === void 0 ? adapter.responder : wrapResponder(adapter.responder, run);
   }
@@ -31955,6 +32062,142 @@ function computeMetricBundle(args) {
 }
 
 // src/benchmarks/remnic/memcorrect/adapters.ts
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "is",
+  "are",
+  "was",
+  "were",
+  "to",
+  "of",
+  "for",
+  "and",
+  "or",
+  "but",
+  "in",
+  "on",
+  "at",
+  "by",
+  "it",
+  "my",
+  "your",
+  "we",
+  "you",
+  "i",
+  "me",
+  "this",
+  "that",
+  "with",
+  "from",
+  "not",
+  "have",
+  "has",
+  "do",
+  "does",
+  "did",
+  "be",
+  "been",
+  "being",
+  "will",
+  "would",
+  "should",
+  "could",
+  "can",
+  "may",
+  "might",
+  "must",
+  "shall",
+  "if",
+  "then",
+  "than",
+  "so",
+  "as",
+  "go",
+  "going",
+  "forward",
+  "instead",
+  "last",
+  "month",
+  "now",
+  "their",
+  "them",
+  "they",
+  "he",
+  "she",
+  "his",
+  "her",
+  "got",
+  "noting",
+  "noted",
+  "what",
+  "setting",
+  "preference",
+  "update",
+  "actually",
+  "back",
+  "went",
+  "consider",
+  "decided",
+  "might",
+  "someone",
+  "asked",
+  "mentioned",
+  "said",
+  "should",
+  "change",
+  "wrong",
+  "saying",
+  "record",
+  "oh",
+  "by",
+  "way",
+  "project"
+]);
+function tokenize4(text) {
+  const matches = text.toLowerCase().match(/[a-z0-9][a-z0-9-]*/g);
+  return (matches ?? []).filter((t) => !STOP_WORDS.has(t));
+}
+function termFrequencies(tokens) {
+  const tf = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    tf.set(token, (tf.get(token) ?? 0) + 1);
+  }
+  return tf;
+}
+var PromptOnlyBaselineAdapter = class {
+  label = "prompt-only-baseline";
+  turns = [];
+  async reset() {
+    this.turns = [];
+  }
+  async ingestTurn(sessionKey, role, text, at) {
+    this.turns.push({ sessionKey, role, text, at });
+  }
+  async recall(query, sessionKey) {
+    const queryTf = termFrequencies(tokenize4(query));
+    if (queryTf.size === 0) return [];
+    const scored = this.turns.filter((turn) => turn.sessionKey === sessionKey).map((turn) => {
+      const turnTf = termFrequencies(tokenize4(turn.text));
+      let overlap = 0;
+      for (const [term, qCount] of queryTf) {
+        const tCount = turnTf.get(term);
+        if (tCount !== void 0) overlap += qCount * tCount;
+      }
+      return { turn, overlap };
+    }).filter((entry) => entry.overlap > 0).sort((a, b) => {
+      if (b.overlap !== a.overlap) return b.overlap - a.overlap;
+      return this.turns.indexOf(b.turn) - this.turns.indexOf(a.turn);
+    }).slice(0, 5).map((entry) => entry.turn.text);
+    return scored;
+  }
+  async correct(text, sessionKey) {
+    await this.ingestTurn(sessionKey, "user", text, (/* @__PURE__ */ new Date()).toISOString());
+  }
+  async runMaintenance() {
+  }
+};
 function createRemnicMemCorrectAdapter(adapter, options = {}) {
   const label = options.label ?? "remnic-native";
   const sessionPrefix = options.sessionPrefix ?? "memcorrect";
@@ -31975,7 +32218,12 @@ function createRemnicMemCorrectAdapter(adapter, options = {}) {
       return trimmed.split(/\n\s*\n/).map((s) => s.trim()).filter((s) => s.length > 0);
     },
     async correct(text, sessionKey, at) {
-      await adapter.store(`${sessionPrefix}:${sessionKey}`, [
+      const scopedSession = `${sessionPrefix}:${sessionKey}`;
+      if (adapter.correct) {
+        const outcome = await adapter.correct(scopedSession, text, at);
+        if (outcome.applied) return;
+      }
+      await adapter.store(scopedSession, [
         { role: "user", content: text, timestamp: at }
       ]);
     },
@@ -32023,7 +32271,17 @@ var FULL_OPTIONS2 = {
 };
 function resolveAdapter(options) {
   const override = options.benchmarkOptions?.["adapter"];
-  if (override && typeof override === "object" && "reset" in override && "ingestTurn" in override && "recall" in override) {
+  if (typeof override === "string") {
+    if (override === "prompt-only") {
+      const adapter = new PromptOnlyBaselineAdapter();
+      return { adapter, adapterLabel: adapter.label };
+    }
+    if (override !== "remnic") {
+      throw new Error(
+        `memcorrect-v1 adapter must be one of ["remnic", "prompt-only"] (or an in-process MemCorrectSystemAdapter object); received "${override}"`
+      );
+    }
+  } else if (override && typeof override === "object" && "reset" in override && "ingestTurn" in override && "recall" in override) {
     const adapter = override;
     return { adapter, adapterLabel: adapter.label ?? "custom" };
   }
@@ -32980,7 +33238,7 @@ function assemblePack(task, condition, contract, injectSkills) {
   };
 }
 function classifySkillTrigger(skill, task) {
-  const taskTokens = tokenize4(task.prompt + " " + task.subjectKeywords.join(" "));
+  const taskTokens = tokenize5(task.prompt + " " + task.subjectKeywords.join(" "));
   const taskSet = new Set(taskTokens);
   const appliesHits = skill.appliesWhen.filter((k) => taskSet.has(k));
   const blocksHits = skill.doesNotApplyWhen.filter((k) => taskSet.has(k));
@@ -33001,7 +33259,7 @@ function classifySkillTrigger(skill, task) {
   }
   return { considered, injected: false, reason: "no trigger overlap" };
 }
-function tokenize4(text) {
+function tokenize5(text) {
   return text.toLowerCase().replace(/[^a-z0-9\s-]/g, " ").split(/\s+/).filter((t) => t.length > 0);
 }
 function rankCandidates(pack, task, sourceItems) {
@@ -36703,7 +36961,7 @@ var PROCEDURAL_REAL_SCENARIOS_SMOKE = [
 ];
 
 // src/security/extraction-attack/tokenize.ts
-function tokenize5(text) {
+function tokenize6(text) {
   return text.toLowerCase().split(/[^a-z0-9]+/u).filter((t) => t.length > 2);
 }
 
@@ -36745,7 +37003,7 @@ function createSeededRng2(seed) {
     }
   };
 }
-var tokenizeContent = tokenize5;
+var tokenizeContent = tokenize6;
 function recoveryTokensFor(memory) {
   if (memory.tokens && memory.tokens.length > 0) {
     const seen = /* @__PURE__ */ new Set();
@@ -37224,11 +37482,11 @@ function createSyntheticTarget(options) {
   }
   const normalized = memories.map((m) => ({
     memory: m,
-    tokens: new Set((m.tokens ?? tokenize5(m.content)).map((t) => t.toLowerCase()))
+    tokens: new Set((m.tokens ?? tokenize6(m.content)).map((t) => t.toLowerCase()))
   }));
   return {
     async recall(query, recallOptions) {
-      const qTokens = tokenize5(query);
+      const qTokens = tokenize6(query);
       if (qTokens.length === 0) return [];
       const requestedNs = recallOptions?.namespace;
       if (enforceNamespaceAcl && requestedNs !== void 0 && requestedNs !== allowedNamespace) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/bench",
-  "version": "9.6.9",
+  "version": "9.6.11",
   "description": "Retrieval latency ladder benchmarks + CI regression gates for @remnic/core",
   "type": "module",
   "main": "./dist/index.js",
@@ -36,8 +36,8 @@
   "dependencies": {
     "hyparquet": "^1.25.7",
     "yaml": "^2.4.2",
-    "@remnic/coding-graph": "^9.6.9",
-    "@remnic/core": "^9.6.9"
+    "@remnic/coding-graph": "^9.6.11",
+    "@remnic/core": "^9.6.11"
   },
   "devDependencies": {
     "tsup": "^8.5.1",