@remnic/bench 9.6.10 → 9.6.12

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);
   }
@@ -7041,7 +7148,9 @@ var ClaudeCliProvider = class {
       try {
         const request = this.buildRunRequest(prompt, opts, tempDir);
         const result = await this.runClaudeCli(request);
-        if (result.status !== 0) {
+        const payload = parseClaudeCliJsonResult(result.stdout);
+        const salvageableDespiteExit = !result.stderr.includes("Claude CLI timed out") && !result.stderr.includes("Claude CLI aborted by benchmark timeout") && result.signal === null && !isClaudeCliErrorFlagSet(payload.is_error) && typeof payload.result === "string" && payload.result.trim().length > 0;
+        if (result.status !== 0 && !salvageableDespiteExit) {
           if (isClaudeUsageLimitSignal(`${result.stderr}
 ${result.stdout}`)) {
             await sleepBeforeUsageLimitRetry({
@@ -7055,8 +7164,9 @@ ${result.stdout}`)) {
             continue;
           }
           const exitLabel = result.signal ? `signal ${result.signal}` : `exit ${result.status ?? "unknown"}`;
+          const stdoutHead = result.stdout.trim().slice(0, 300);
           const error = new Error(
-            `Claude CLI completion failed (${exitLabel}): ${summarizeProcessOutput(result.stderr, result.stdout)}`
+            `Claude CLI completion failed (${exitLabel}): ${stdoutHead.length > 0 ? `head=${JSON.stringify(stdoutHead)} tail=` : ""}${summarizeProcessOutput(result.stderr, result.stdout)}`
           );
           if (transientAttempt < maxAttempts && isRetryableClaudeCliResult(result)) {
             await sleepBeforeClaudeCliRetry({
@@ -7071,7 +7181,11 @@ ${result.stdout}`)) {
           }
           throw error;
         }
-        const payload = parseClaudeCliJsonResult(result.stdout);
+        if (result.stderr.includes("Claude CLI timed out") || result.stderr.includes("Claude CLI aborted by benchmark timeout")) {
+          throw new Error(
+            `Claude CLI completion was killed (timeout/abort): ${summarizeProcessOutput(result.stderr, result.stdout)}`
+          );
+        }
         if (isClaudeCliErrorFlagSet(payload.is_error)) {
           if (isClaudeUsageLimitSignal(
             `${result.stderr}
@@ -7208,6 +7322,7 @@ function buildClaudeCompletionPrompt(userPrompt) {
   ].join("\n");
 }
 var CLAUDE_CLI_MAX_OUTPUT_TOKENS_ENV = "CLAUDE_CODE_MAX_OUTPUT_TOKENS";
+var CLAUDE_CLI_OUTPUT_TOKENS_ENV_FLOOR = 4096;
 function buildIsolatedClaudeEnv(config, maxTokens) {
   const env = {};
   for (const [key, value] of Object.entries(process.env)) {
@@ -7222,7 +7337,9 @@ function buildIsolatedClaudeEnv(config, maxTokens) {
     env.ANTHROPIC_BASE_URL = config.baseUrl.trim();
   }
   if (typeof maxTokens === "number" && Number.isFinite(maxTokens) && maxTokens > 0) {
-    env[CLAUDE_CLI_MAX_OUTPUT_TOKENS_ENV] = String(Math.floor(maxTokens));
+    env[CLAUDE_CLI_MAX_OUTPUT_TOKENS_ENV] = String(
+      Math.max(Math.floor(maxTokens), CLAUDE_CLI_OUTPUT_TOKENS_ENV_FLOOR)
+    );
   }
   return env;
 }
@@ -7262,6 +7379,18 @@ function parseClaudeCliJsonResult(stdout) {
     }
     return parsed;
   } catch {
+    const lines = trimmed.split(/\r?\n/);
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+      const line = lines[index].trim();
+      if (!line.startsWith("{") || !line.endsWith("}")) continue;
+      try {
+        const parsed = JSON.parse(line);
+        if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+          return parsed;
+        }
+      } catch {
+      }
+    }
     return { is_error: true, error: trimmed.slice(-1e3) };
   }
 }
@@ -31955,6 +32084,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 +32240,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 +32293,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 +33260,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 +33281,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 +36983,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 +37025,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 +37504,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.10",
+  "version": "9.6.12",
   "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.10",
-    "@remnic/core": "^9.6.10"
+    "@remnic/coding-graph": "^9.6.12",
+    "@remnic/core": "^9.6.12"
   },
   "devDependencies": {
     "tsup": "^8.5.1",