claude-mem-lite 6.26.0 → 6.26.1

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "6.26.0",
+      "version": "6.26.1",
       "source": "./",
       "homepage": "https://github.com/sdsrss/claude-mem-lite",
       "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. FTS5 BM25 keyword search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark)."

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "6.26.0",
+  "version": "6.26.1",
   "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. FTS5 BM25 keyword search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark).",
   "author": {
     "name": "sdsrss"

package/haiku-client.mjs

@@ -69,16 +69,37 @@ const MODEL_MAP = {
 
 // Models that get the STRICT body. Claude Haiku 5.5 answers any non-default `temperature`
 // with a 400 and thinks unless told not to, so a reply can open with a thinking block, and
-// thinking spends the max_tokens these short fixed-schema extractions are sized for. Every
-// leg runs it with thinking off: the CLI sets MAX_THINKING_TOKENS=0, OpenRouter gets
-// `reasoning: {enabled: false}` (STRICT_BODY_SLUGS), and the direct leg sends no sampling
-// field and thinking disabled. With thinking off it can answer a bare one-word query with a
+// thinking spends the max_tokens these short fixed-schema extractions are sized for. The
+// keyed legs run it with thinking off: OpenRouter gets `reasoning: {enabled: false}`
+// (STRICT_BODY_SLUGS), and the direct leg sends no sampling field and thinking disabled.
+// The CLI leg does NOT: Claude Code 2.1.301 sends `thinking: {type: "adaptive"}` and effort
+// medium for `--model haiku` whether or not MAX_THINKING_TOKENS=0 is set (request bodies
+// captured at a stub base URL, 2026-10-15; D#334). Its max_tokens is Claude Code's own, so
+// nothing is cut off there. With thinking off it can answer a bare one-word query with a
 // prose question instead of JSON, so a caller's `jsonSchema` becomes a structured output on
 // these models (rewrite replays 2026-10-15: 7/72 below two variants without it, 0/72 with
-// it; docs/audits/20261015-v6.26.0-replays.md). Keyed by the ID actually sent, so an
-// override naming another model keeps the old body.
+// it; docs/audits/20261015-v6.26.0-replays.md). Keyed by the ID actually sent, read through
+// strictBodyKey, so an override naming another model keeps the old body.
 const STRICT_BODY_MODELS = new Set(['claude-haiku-5-5']);
 
+/**
+ * The model's own name inside the routing decoration around it, for the STRICT_BODY_*
+ * lookups: an OpenRouter variant suffix (`anthropic/claude-haiku-5.5:nitro`, `:floor`) and
+ * the Bedrock form a gateway may take (`anthropic.claude-haiku-5-5`, with or without a
+ * cross-region prefix such as `us.`, `global.` or GovCloud's `us-gov.`). Haiku 5.5 named
+ * either way was sent the old body: thinking on, no structured output and, on the direct
+ * leg, temperature 0, which it answers with a 400 (OpenRouter drops the field in transit).
+ * A gateway deployment name says nothing about the model behind it and is not guessed at.
+ * (D#321)
+ * @param {string} id model ID or OpenRouter slug as sent
+ * @returns {string}
+ */
+function strictBodyKey(id) {
+  return String(id)
+    .replace(/:[a-z0-9-]+$/, '')
+    .replace(/^(?:[a-z]{2,6}(?:-[a-z]+)?\.)?anthropic\./, '');
+}
+
 // Claude Code's tier-alias override vars, honored on the direct-API leg too:
 // gateway deployments route on the DEPLOYMENT name (Azure Foundry rejects the
 // Anthropic model ID when it differs), and one env set then covers both the
@@ -582,7 +603,7 @@ async function callModelAPI(
     // "`temperature` is deprecated for this model."). Keep sending it until a
     // model refuses, then drop it for that model only - the retry at the bottom
     // pays for itself once. A model known to refuse it never gets it.
-    if (STRICT_BODY_MODELS.has(modelId)) {
+    if (STRICT_BODY_MODELS.has(strictBodyKey(modelId))) {
       body.thinking = { type: 'disabled' };
       if (jsonSchema) body.output_config = { format: { type: 'json_schema', schema: jsonSchema.schema } };
     } else if (!_temperatureDeprecated.has(modelId)) body.temperature = temperature;
@@ -680,10 +701,22 @@ async function callModelAPI(
       debugLog('WARN', `${model}-api`, `refusal (${data.stop_details?.category ?? 'no category'})`);
       return null;
     }
-    // By content, not position: a thinking block (no `text`) can come first.
+    // The callers parse a fixed-schema JSON answer out of this text (the opt-in lesson bridge
+    // keeps its first line), so a reply cut off at max_tokens is a failed call too: the CLI
+    // fallback has no such cap. A whole JSON answer followed by cut-off prose is discarded with
+    // it, although parseJsonFromLLM would have recovered it (D#322; D#338).
+    if (data.stop_reason === 'max_tokens') {
+      debugLog('WARN', `${model}-api`, 'reply cut off at max_tokens');
+      return null;
+    }
+    // By content, not position: a thinking block (no `text`) can come first. Every text
+    // block, joined, so an empty one cannot hide the answer after it (D#324).
     const text = Array.isArray(data.content)
-      ? data.content.find((b) => typeof b?.text === 'string')?.text
-      : undefined;
+      ? data.content
+          .filter((b) => typeof b?.text === 'string')
+          .map((b) => b.text)
+          .join('')
+      : '';
     return text ? { text } : null;
   } finally {
     clearTimeout(timer);
@@ -757,7 +790,10 @@ function claudeArgs(modelName) {
 /**
  * The environment every headless spawn runs with. MAX_THINKING_TOKENS=0: these are
  * structured extraction calls, and the thinking the CLI enables by default was most of
- * their output tokens and latency (measured above).
+ * their output tokens and latency (measured above, 2026-09-29; the model the CLI ran then was
+ * not recorded). Claude Code 2.1.301 does not change its request for Claude Haiku 5.5 on this
+ * variable: the body carries adaptive thinking either way (D#334). Earlier versions were not
+ * checked.
  */
 function cliSpawnEnv() {
   return {
@@ -1095,8 +1131,15 @@ async function callOpenRouterAPI(
       // Optional OpenRouter attribution headers (ignored by the API if absent).
       'X-Title': 'claude-mem-lite',
     };
-    const payload = { model, max_tokens: maxTokens, temperature, messages };
-    if (STRICT_BODY_SLUGS.has(model)) {
+    // A strict slug gets no temperature, as on the direct leg. No OpenRouter endpoint serving
+    // Claude Haiku 5.5 lists it (endpoints API, 2026-10-15), so it was dropped in transit,
+    // and it made `provider.require_parameters` match no endpoint at all (72/72 HTTP 404 on
+    // the rewrite prompts, 0/72 without it; docs/audits/20261015-d330-openrouter-routing.md).
+    const strict = STRICT_BODY_SLUGS.has(strictBodyKey(model));
+    const payload = strict
+      ? { model, max_tokens: maxTokens, messages }
+      : { model, max_tokens: maxTokens, temperature, messages };
+    if (strict) {
       payload.reasoning = { enabled: false };
       if (jsonSchema) {
         payload.response_format = {
@@ -1119,7 +1162,27 @@ async function callOpenRouterAPI(
     }
 
     const data = await res.json();
-    const text = data.choices?.[0]?.message?.content;
+    const choice = data.choices?.[0];
+    // OpenRouter normalises finish_reason to stop / length / content_filter / tool_calls /
+    // error and passes the provider's own value as native_finish_reason. A cut-off, filtered
+    // or refused reply can still carry part of an answer; none is one. (D#322, D#323)
+    const finish = choice?.finish_reason;
+    const native = choice?.native_finish_reason;
+    if (
+      finish === 'length' ||
+      finish === 'content_filter' ||
+      finish === 'error' ||
+      native === 'refusal' ||
+      choice?.error
+    ) {
+      debugLog(
+        'WARN',
+        `${tier}-openrouter`,
+        `no answer (finish_reason ${finish}, native ${native ?? 'none'})`,
+      );
+      return null;
+    }
+    const text = choice?.message?.content;
     return text ? { text } : null;
   } finally {
     clearTimeout(timer);

package/hook.mjs

@@ -128,8 +128,7 @@ import {
 import { writePlainHookText, resetPlainHookText, idsShownWhole } from './lib/hook-text-cap.mjs';
 import { shouldRecallOnFailure } from './lib/tool-refusal.mjs';
 import {
-  entryInputTags,
-  extractDiagnosis,
+  workerEntryFields,
   filterSummaryInput,
   episodeInputFilterEnabled,
 } from './lib/episode-input-filter.mjs';
@@ -781,28 +780,16 @@ async function handlePostToolUse() {
   // Tier 1 B: Detect significant Bash commands
   const bashSig = tool_name === 'Bash' ? detectBashSignificance(toolInput, resp) : null;
 
-  // D#69: tags and diagnosis lines need the FULL command and output, which the entry
-  // does not keep, so they are computed here once. The output is windowed head + tail:
-  // a runner prints its failures at the END, and a multi-megabyte stdout should not be
-  // regex-scanned on every PostToolUse.
-  const respWindow = resp.length > 65536 ? resp.slice(0, 32768) + '\n' + resp.slice(-32768) : resp;
-
-  // `diagOut` = the diagnosis lines read from tool OUTPUT: a lesson quoting one stays
-  // under every injection floor (D#100(3)). Always present on a Bash entry, [] included, so
-  // the worker can tell a new entry with no output lines from one buffered before the field.
-  const diagnosis = extractDiagnosis(tool_name, toolInput, respWindow, {
-    isError: bashSig?.isError || false,
-    writesFiles: tool_name === 'Bash' && bashWrites.length > 0,
-    scrub: scrubSecrets,
-  });
-
-  // Build episode entry
+  // Build episode entry. The worker fields (input tags, DIAGNOSIS lines, Bash's diagOut)
+  // need the full command and output, which the entry does not keep (D#69).
   const entry = {
     tool: tool_name,
     desc: scrubSecrets(makeEntryDesc(tool_name, toolInput, resp, bashSig)),
-    inputTags: entryInputTags(tool_name, toolInput, respWindow),
-    diag: diagnosis.lines,
-    ...(tool_name === 'Bash' ? { diagOut: diagnosis.output } : {}),
+    ...workerEntryFields(tool_name, toolInput, resp, {
+      isError: bashSig?.isError || false,
+      writesFiles: tool_name === 'Bash' && bashWrites.length > 0,
+      scrub: scrubSecrets,
+    }),
     files,
     ...(tool_name === 'Bash' && bashWrites.length ? { bashWrites } : {}),
     ts: Date.now(),

package/lib/episode-input-filter.mjs

@@ -386,6 +386,33 @@ export function extractDiagnosis(
   return { lines: [...clean(lines), ...out], output: out };
 }
 
+/**
+ * The fields an episode entry carries for the llm-episode worker: the input filter's tags,
+ * the prompt's DIAGNOSIS lines and, on Bash, `diagOut`, the lines read from tool OUTPUT (a
+ * lesson quoting one stays under every injection floor, D#100(3); always present on a Bash
+ * entry, [] included, so the worker can tell a new entry with no output lines from one
+ * buffered before the field). They need the FULL command and output, which the entry does
+ * not keep, so hook.mjs computes them once per PostToolUse. The output is windowed head +
+ * tail: a runner prints its failures at the END, and a multi-megabyte stdout should not be
+ * regex-scanned on every call (D#69). benchmark/episode-flush-replay.mjs calls this too, so
+ * the model A/B it feeds sees the entries production builds (D#326).
+ * @param {string} tool
+ * @param {object} input tool_input
+ * @param {string} resp normalized tool response
+ * @param {{isError?: boolean, writesFiles?: boolean, scrub?: (s: string) => string}} [opts]
+ *   as extractDiagnosis
+ * @returns {{inputTags: string[], diag: string[], diagOut?: string[]}}
+ */
+export function workerEntryFields(tool, input, resp, opts) {
+  const respWindow = resp.length > 65536 ? resp.slice(0, 32768) + '\n' + resp.slice(-32768) : resp;
+  const diagnosis = extractDiagnosis(tool, input, respWindow, opts);
+  return {
+    inputTags: entryInputTags(tool, input, respWindow),
+    diag: diagnosis.lines,
+    ...(tool === 'Bash' ? { diagOut: diagnosis.output } : {}),
+  };
+}
+
 // ─── Grounding check ────────────────────────────────────────────────────────
 
 const GROUND_NGRAM = 4;

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "claude-mem-lite",
-  "version": "6.26.0",
+  "version": "6.26.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "claude-mem-lite",
-      "version": "6.26.0",
+      "version": "6.26.1",
       "os": [
         "darwin",
         "linux",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "6.26.0",
+  "version": "6.26.1",
   "description": "Persistent long-term memory for Claude Code via MCP — captures coding decisions, bugfixes, and context across sessions. FTS5 BM25 keyword search with episode batching. Single SQLite DB, no external services. A lighter, lower-cost alternative to claude-mem (episode batching + a smaller model; cost savings are an internal estimate, not a measured benchmark).",
   "type": "module",
   "packageManager": "npm@10.9.2",