claude-mem-lite 6.25.3 → 6.26.1

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "6.25.3",
+      "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.25.3",
+  "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/README.md

@@ -1134,10 +1134,10 @@ claude-mem-lite.
 | `CLAUDE_MEM_MODEL` | LLM model for background calls (episode extraction, session summaries). Accepts `haiku` or `sonnet`. | `haiku` |
 | `ANTHROPIC_API_KEY` | Anthropic API key. When set, all background LLM calls go directly to the Anthropic Messages API (with prompt caching) - or to the `ANTHROPIC_BASE_URL` gateway when that is set. Highest priority. | _(unset → CLI)_ |
 | `ANTHROPIC_BASE_URL` | Base URL for the direct Messages API when an Anthropic-compatible gateway serves the models (Azure AI Foundry, LiteLLM, Bedrock/Vertex proxies). No `/v1` suffix — the endpoint path is appended. The `claude -p` fallback reads the same variable, so one value covers both transports. Plain `http://` is accepted only for a loopback host; anything else would send the API key unencrypted. That request always goes straight to the loopback host, even when `NODE_USE_ENV_PROXY=1` sends other requests through `HTTP_PROXY`. A value that is set but unusable skips the direct API leg, so background calls fall back to the `claude -p` CLI, and doctor warns. | `https://api.anthropic.com` |
-| `ANTHROPIC_DEFAULT_HAIKU_MODEL` | Model ID or gateway deployment name for the `haiku` tier, honored on the direct API **only when `ANTHROPIC_BASE_URL` is set**. Without a base URL it stays CLI-only, so the Bedrock/Vertex form of this alias is never sent to `api.anthropic.com`. Use it when the gateway routes on deployment names rather than Anthropic model IDs (Azure Foundry deployments). The `claude -p` fallback resolves its `--model haiku` alias through it too. | built-in `claude-haiku-4-5-…` |
+| `ANTHROPIC_DEFAULT_HAIKU_MODEL` | Model ID or gateway deployment name for the `haiku` tier, honored on the direct API **only when `ANTHROPIC_BASE_URL` is set**. Without a base URL it stays CLI-only, so the Bedrock/Vertex form of this alias is never sent to `api.anthropic.com`. Use it when the gateway routes on deployment names rather than Anthropic model IDs (Azure Foundry deployments). The `claude -p` fallback resolves its `--model haiku` alias through it too. | built-in `claude-haiku-5-5` |
 | `ANTHROPIC_DEFAULT_SONNET_MODEL` | Same as above for the `sonnet` tier. | built-in `claude-sonnet-4-5-…` |
 | `OPENROUTER_API_KEY` | OpenRouter API key (OpenAI-compatible). Used for background LLM calls when `ANTHROPIC_API_KEY` is **not** set. If neither key is set, calls fall back to the `claude -p` CLI. | _(unset)_ |
-| `OPENROUTER_MODEL` | Overrides the OpenRouter model slug for **all** background calls (e.g. `openai/gpt-4o-mini`, `qwen/qwen-2.5-72b-instruct`). When unset, the `CLAUDE_MEM_MODEL` tier maps to `anthropic/claude-haiku-4.5` (haiku) or `anthropic/claude-sonnet-4.5` (sonnet). | _(tier default)_ |
+| `OPENROUTER_MODEL` | Overrides the OpenRouter model slug for **all** background calls (e.g. `openai/gpt-4o-mini`, `qwen/qwen-2.5-72b-instruct`). When unset, the `CLAUDE_MEM_MODEL` tier maps to `anthropic/claude-haiku-5.5` (haiku) or `anthropic/claude-sonnet-4.5` (sonnet). | _(tier default)_ |
 | `CLAUDE_MEM_DEBUG` | Enable debug logging (`1` to enable). | _(disabled)_ |
 | `MEM_QUIET_HOOKS` | Low-noise hooks. `1` drops the `File Lessons` / `Key Context` sections from SessionStart injection, the lesson suffix from `[mem] Related memories`, and the `WHEN TO USE` / `Decision rules` blocks from MCP server instructions. IDs and the `Recent` table still surface so `mem_get(ids=[…])` remains reachable. Intended for users running the invited-memory adopt path or who otherwise want minimal auto-injection. **Since v2.82.0 this env no longer gates auto-adopt — use `MEM_NO_AUTO_ADOPT=1` for that.** | _(disabled)_ |
 | `CLAUDE_MEM_SESSION_EVENTS` | `1`/`on` restores the SessionStart `### Key Events` section (recent high-importance rows from the `events` table). **Off by default since v6.13.0**: an audit of 30 events read 2 accurate and 16 wrong. The UserPromptSubmit events block and PreToolUse recall are query-matched and stay on; `mem_search` still reaches every event. | _(off)_ |

package/README.zh-CN.md

@@ -863,10 +863,10 @@ npm run benchmark:gate    # CI 门控：指标回退超过 5% 容差时失败
 | `CLAUDE_MEM_MODEL` | 后台 LLM 调用模型（Episode 提取、会话总结、调度）。可选 `haiku` 或 `sonnet`。 | `haiku` |
 | `ANTHROPIC_API_KEY` | Anthropic API key。设置后所有后台 LLM 调用直连 Anthropic Messages API（带 prompt caching）；设了 `ANTHROPIC_BASE_URL` 时改发往那个网关。优先级最高。 | _(未设 → CLI)_ |
 | `ANTHROPIC_BASE_URL` | 由兼容 Anthropic 的网关（Azure AI Foundry、LiteLLM、Bedrock/Vertex 代理）提供模型时，直连 Messages API 使用的基础 URL。不要带 `/v1` 后缀，端点路径会自动拼上。`claude -p` 兜底读取同一个变量，所以一个值同时作用于两条路径。明文 `http://` 只接受回环主机，否则 API key 会以明文发送。这个请求总是直连回环主机，即使 `NODE_USE_ENV_PROXY=1` 让其他请求走 `HTTP_PROXY`。设了但不可用的值会跳过直连这一路，后台调用改走 `claude -p`，doctor 会提示。 | `https://api.anthropic.com` |
-| `ANTHROPIC_DEFAULT_HAIKU_MODEL` | `haiku` 档的模型 ID 或网关部署名，**仅在设了 `ANTHROPIC_BASE_URL` 时**用于直连 API。没有基础 URL 时只给 CLI 用，所以这个别名的 Bedrock/Vertex 写法不会被发往 `api.anthropic.com`。网关按部署名而不是 Anthropic 模型 ID 路由时（Azure Foundry 部署）使用。`claude -p` 兜底的 `--model haiku` 别名也经由它解析。 | 内置 `claude-haiku-4-5-…` |
+| `ANTHROPIC_DEFAULT_HAIKU_MODEL` | `haiku` 档的模型 ID 或网关部署名，**仅在设了 `ANTHROPIC_BASE_URL` 时**用于直连 API。没有基础 URL 时只给 CLI 用，所以这个别名的 Bedrock/Vertex 写法不会被发往 `api.anthropic.com`。网关按部署名而不是 Anthropic 模型 ID 路由时（Azure Foundry 部署）使用。`claude -p` 兜底的 `--model haiku` 别名也经由它解析。 | 内置 `claude-haiku-5-5` |
 | `ANTHROPIC_DEFAULT_SONNET_MODEL` | 同上，用于 `sonnet` 档。 | 内置 `claude-sonnet-4-5-…` |
 | `OPENROUTER_API_KEY` | OpenRouter API key（OpenAI 兼容）。当**未设** `ANTHROPIC_API_KEY` 时用于后台 LLM 调用；两者都未设则回退到 `claude -p` CLI。 | _(未设)_ |
-| `OPENROUTER_MODEL` | 覆盖**所有**后台调用的 OpenRouter 模型 slug（如 `openai/gpt-4o-mini`、`qwen/qwen-2.5-72b-instruct`）。未设时按 `CLAUDE_MEM_MODEL` 分层映射到 `anthropic/claude-haiku-4.5`（haiku）或 `anthropic/claude-sonnet-4.5`（sonnet）。 | _(分层默认)_ |
+| `OPENROUTER_MODEL` | 覆盖**所有**后台调用的 OpenRouter 模型 slug（如 `openai/gpt-4o-mini`、`qwen/qwen-2.5-72b-instruct`）。未设时按 `CLAUDE_MEM_MODEL` 分层映射到 `anthropic/claude-haiku-5.5`（haiku）或 `anthropic/claude-sonnet-4.5`（sonnet）。 | _(分层默认)_ |
 | `CLAUDE_MEM_DEBUG` | 启用调试日志（设为 `1` 启用）。 | _(禁用)_ |
 | `MEM_QUIET_HOOKS` | 低噪声 hook。设为 `1` 时，SessionStart 注入去掉 `File Lessons` / `Key Context` 两节，`[mem] Related memories` 去掉 lesson 后缀，MCP server instructions 去掉 `WHEN TO USE` / `Decision rules` 两段。ID 与 `Recent` 表仍保留，`mem_get(ids=[…])` 可继续展开细节。适用于启用了 invited-memory adopt 流程或偏好最小化自动注入的用户。**v2.82.0 起此 env 不再阻挡 auto-adopt——如需关闭 auto-adopt 用 `MEM_NO_AUTO_ADOPT=1`。** | _(禁用)_ |
 | `CLAUDE_MEM_SESSION_EVENTS` | 设为 `1`/`on` 时恢复 SessionStart 的 `### Key Events` 一节（`events` 表中最近的高重要度条目）。**v6.13.0 起默认关闭**：对 30 条 event 的核验只有 2 条属实、16 条错误。UserPromptSubmit 的 events 块与 PreToolUse 召回按查询匹配，保持开启；`mem_search` 仍可检索全部 event。 | _(关闭)_ |

package/deep-search.mjs

@@ -269,6 +269,23 @@ export const REWRITE_SYSTEM =
   'Emit exactly 3 non-empty variants. If unsure, still emit at least the keyword form as v1.\n' +
   INJECTION_GUARD;
 
+/**
+ * The rewrite's output as a structured-output schema. Sent only to models that get the
+ * strict body (haiku-client's STRICT_BODY_MODELS / _SLUGS): with thinking off, Claude
+ * Haiku 5.5's answer gave fewer than two variants on 7 of 72 replays (the ones printed were
+ * prose questions about a bare one-word query, "React"), and on 0 of 72 with this schema
+ * (2026-10-15, docs/audits/20261015-v6.26.0-replays.md).
+ */
+export const REWRITE_JSON_SCHEMA = {
+  name: 'rewrite_variants',
+  schema: {
+    type: 'object',
+    properties: { variants: { type: 'array', items: { type: 'string' } } },
+    required: ['variants'],
+    additionalProperties: false,
+  },
+};
+
 /**
  * Build the split-form rewrite prompt. The constant instructions live in the
  * system slot; the untrusted query goes verbatim into the user/data slot so an
@@ -372,7 +389,7 @@ export function makeThrottled(llm, { intervalMs = AUTO_DEEP_THROTTLE_MS } = {})
 // never load the LLM client.
 async function callRewriteLLM(prompt, { timeout }) {
   const { callModelJSONAsync } = await import('./haiku-client.mjs');
-  return callModelJSONAsync(prompt, 'haiku', { timeout, maxTokens: 400 });
+  return callModelJSONAsync(prompt, 'haiku', { timeout, maxTokens: 400, jsonSchema: REWRITE_JSON_SCHEMA });
 }
 
 // Default (explicit deep=true) provider: patient timeout, no throttle/cache.

package/haiku-client.mjs

@@ -55,11 +55,51 @@ function cliSpawnCwd() {
 // ─── Model Resolution ────────────────────────────────────────────────────────
 
 // CLI name → API model ID mapping
+// haiku moved from claude-haiku-4-5-20251001 on 2026-10-15, after
+// benchmark/haiku-model-ab.mjs read usability parity on the three haiku-tier sites it
+// samples (episode, rewrite, rerank) and a blind read of the kept lessons put 5.5 ahead
+// (docs/measurement/rulers.md, "haiku-tier model A/B"). It is also what
+// `claude -p --model haiku` resolves to on the Anthropic API since Claude Code 2.1.293
+// (Bedrock, Vertex, Foundry and Claude Platform on AWS still resolve it to 4.5), so there
+// all three legs run the same model.
 const MODEL_MAP = {
-  haiku: 'claude-haiku-4-5-20251001',
+  haiku: 'claude-haiku-5-5',
   sonnet: 'claude-sonnet-4-5-20250929',
 };
 
+// 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. 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, 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
@@ -94,6 +134,9 @@ function apiModelId(tier, base = resolveAnthropicBaseUrl()) {
 // to 0 so the provider default (~1.0) doesn't inject wording variance that breaks
 // JSON parsing or defeats the wording-sensitive MinHash near-duplicate detector.
 // A call that genuinely needs sampling can pass opts.temperature to override.
+// The pin holds only where the model takes it: Claude Haiku 5.5 accepts no temperature
+// but its default (the direct leg omits the field, OpenRouter drops it, the CLI never sent
+// one), so on that model the extraction runs at its default sampling.
 const DEFAULT_LLM_TEMPERATURE = 0;
 
 /**
@@ -134,13 +177,21 @@ export function resolveModel() {
 // OpenRouter uses its own slug namespace (OpenAI-compatible API). Map the
 // project's haiku/sonnet tiers to the matching anthropic/* slugs so the quality
 // tiering is preserved when routing through OpenRouter. Slugs verified against
-// openrouter.ai (2026-06): claude-haiku-4.5 / claude-sonnet-4.5 mirror the
-// native MODEL_MAP IDs above.
+// openrouter.ai: claude-sonnet-4.5 (2026-06) and claude-haiku-5.5 (2026-10-15) mirror
+// the native MODEL_MAP IDs above.
 const OPENROUTER_MODEL_MAP = {
-  haiku: 'anthropic/claude-haiku-4.5',
+  haiku: 'anthropic/claude-haiku-5.5',
   sonnet: 'anthropic/claude-sonnet-4.5',
 };
 
+// STRICT_BODY_MODELS on OpenRouter's slug namespace. Measured 2026-10-15 on six rerank
+// prompts, three of them picked because they had failed, three calls each (300-token
+// budget): the JSON came back cut off (finish_reason "length"; the two printed spent 259 and
+// 275 tokens thinking) on 8 of 18 calls, 0 of 18 with reasoning off
+// (docs/audits/20261015-v6.26.0-replays.md). A one-line extraction did not think at all, so
+// a single easy probe reads this as fine.
+const STRICT_BODY_SLUGS = new Set(['anthropic/claude-haiku-5.5']);
+
 /**
  * Resolve the OpenRouter model slug for a given tier.
  * OPENROUTER_MODEL (if set, non-blank) overrides every tier with an explicit
@@ -242,11 +293,13 @@ export function flattenForCLI(input) {
  * @param {object} [opts] Options
  * @param {number} [opts.timeout=10000] Timeout in milliseconds
  * @param {number} [opts.maxTokens=500] Max tokens in response
+ * @param {{name: string, schema: object}|null} [opts.jsonSchema] structured output for the
+ *   models that get the strict body (STRICT_BODY_MODELS / _SLUGS); ignored elsewhere and on the CLI
  * @returns {Promise<{text: string}|null>} Response or null on failure
  */
 export async function callHaiku(
   prompt,
-  { timeout = 10000, maxTokens = 500, temperature = DEFAULT_LLM_TEMPERATURE } = {},
+  { timeout = 10000, maxTokens = 500, temperature = DEFAULT_LLM_TEMPERATURE, jsonSchema = null } = {},
 ) {
   if (!prompt) return null;
 
@@ -275,8 +328,13 @@ export async function callHaiku(
     // the difference between 1.4s and 13.5s.
     primary =
       mode === 'api'
-        ? await callModelAPI(prompt, resolveModel().cli, { timeout, maxTokens, temperature })
-        : await callOpenRouterAPI(prompt, resolveModel().cli, { timeout, maxTokens, temperature });
+        ? await callModelAPI(prompt, resolveModel().cli, { timeout, maxTokens, temperature, jsonSchema })
+        : await callOpenRouterAPI(prompt, resolveModel().cli, {
+            timeout,
+            maxTokens,
+            temperature,
+            jsonSchema,
+          });
   } catch (e) {
     debugCatch(e, `callHaiku:${mode}`);
   }
@@ -323,14 +381,15 @@ export async function callHaikuJSON(prompt, opts) {
  * Defaults also mirror callHaiku (10s / 500 tokens), not callModelJSONAsync's
  * 15s / 1000: a caller that omits opts must get the sync twin's budget.
  * @param {string|{system?:string,user:string}} prompt
- * @param {{timeout?:number,maxTokens?:number,temperature?:number}} [opts]
+ * @param {{timeout?:number,maxTokens?:number,temperature?:number,jsonSchema?:{name:string,schema:object}|null}} [opts]
+ *   jsonSchema: structured output for strict-body models (see callLLMWithModel)
  * @returns {Promise<object|null>} Parsed JSON or null
  */
 export async function callHaikuJSONAsync(
   prompt,
-  { timeout = 10000, maxTokens = 500, temperature = DEFAULT_LLM_TEMPERATURE } = {},
+  { timeout = 10000, maxTokens = 500, temperature = DEFAULT_LLM_TEMPERATURE, jsonSchema = null } = {},
 ) {
-  return callModelJSONAsync(prompt, resolveModel().cli, { timeout, maxTokens, temperature });
+  return callModelJSONAsync(prompt, resolveModel().cli, { timeout, maxTokens, temperature, jsonSchema });
 }
 
 // ─── Model-Selectable API ────────────────────────────────────────────────────
@@ -345,12 +404,14 @@ export async function callHaikuJSONAsync(
  * @param {object} [opts] Options
  * @param {number} [opts.timeout=15000] Timeout in milliseconds
  * @param {number} [opts.maxTokens=1000] Max tokens in response
+ * @param {{name: string, schema: object}|null} [opts.jsonSchema] structured output for the
+ *   models that get the strict body (STRICT_BODY_MODELS / _SLUGS); ignored elsewhere and on the CLI
  * @returns {Promise<{text: string}|null>} Response or null on failure
  */
 export async function callLLMWithModel(
   prompt,
   model = 'haiku',
-  { timeout = 15000, maxTokens = 1000, temperature = DEFAULT_LLM_TEMPERATURE } = {},
+  { timeout = 15000, maxTokens = 1000, temperature = DEFAULT_LLM_TEMPERATURE, jsonSchema = null } = {},
 ) {
   if (!prompt) return null;
   const resolvedModel = MODEL_MAP[model] ? model : 'haiku';
@@ -372,8 +433,8 @@ export async function callLLMWithModel(
   try {
     primary =
       mode === 'api'
-        ? await callModelAPI(prompt, resolvedModel, { timeout, maxTokens, temperature })
-        : await callOpenRouterAPI(prompt, resolvedModel, { timeout, maxTokens, temperature });
+        ? await callModelAPI(prompt, resolvedModel, { timeout, maxTokens, temperature, jsonSchema })
+        : await callOpenRouterAPI(prompt, resolvedModel, { timeout, maxTokens, temperature, jsonSchema });
   } catch (e) {
     debugCatch(e, `callLLMWithModel:${mode}:${resolvedModel}`);
   }
@@ -401,13 +462,14 @@ export async function callLLMWithModel(
  * salvage. Only the CLI transport differs.
  * @param {string|{system?:string,user:string}} prompt
  * @param {'haiku'|'sonnet'} model
- * @param {{timeout?:number,maxTokens?:number,temperature?:number}} [opts]
+ * @param {{timeout?:number,maxTokens?:number,temperature?:number,jsonSchema?:{name:string,schema:object}|null}} [opts]
+ *   jsonSchema: structured output for strict-body models (see callLLMWithModel)
  * @returns {Promise<{text: string}|null>} Response or null on failure
  */
 export async function callLLMWithModelAsync(
   prompt,
   model = 'haiku',
-  { timeout = 15000, maxTokens = 1000, temperature = DEFAULT_LLM_TEMPERATURE } = {},
+  { timeout = 15000, maxTokens = 1000, temperature = DEFAULT_LLM_TEMPERATURE, jsonSchema = null } = {},
 ) {
   if (!prompt) return null;
   const resolvedModel = MODEL_MAP[model] ? model : 'haiku';
@@ -420,8 +482,8 @@ export async function callLLMWithModelAsync(
   try {
     primary =
       mode === 'api'
-        ? await callModelAPI(prompt, resolvedModel, { timeout, maxTokens, temperature })
-        : await callOpenRouterAPI(prompt, resolvedModel, { timeout, maxTokens, temperature });
+        ? await callModelAPI(prompt, resolvedModel, { timeout, maxTokens, temperature, jsonSchema })
+        : await callOpenRouterAPI(prompt, resolvedModel, { timeout, maxTokens, temperature, jsonSchema });
   } catch (e) {
     debugCatch(e, `callLLMWithModelAsync:${mode}:${resolvedModel}`);
   }
@@ -457,13 +519,14 @@ export async function callModelJSON(prompt, model = 'haiku', opts) {
  * throws; returns parsed JSON or null.
  * @param {string|{system?:string,user:string}} prompt
  * @param {'haiku'|'sonnet'} model
- * @param {{timeout?:number,maxTokens?:number,temperature?:number}} [opts]
+ * @param {{timeout?:number,maxTokens?:number,temperature?:number,jsonSchema?:{name:string,schema:object}|null}} [opts]
+ *   jsonSchema: structured output for strict-body models (see callLLMWithModel)
  * @returns {Promise<object|null>}
  */
 export async function callModelJSONAsync(
   prompt,
   model = 'haiku',
-  { timeout = 15000, maxTokens = 1000, temperature = DEFAULT_LLM_TEMPERATURE } = {},
+  { timeout = 15000, maxTokens = 1000, temperature = DEFAULT_LLM_TEMPERATURE, jsonSchema = null } = {},
 ) {
   if (!prompt) return null;
   const resolvedModel = MODEL_MAP[model] ? model : 'haiku';
@@ -480,8 +543,8 @@ export async function callModelJSONAsync(
   try {
     primary =
       mode === 'api'
-        ? await callModelAPI(prompt, resolvedModel, { timeout, maxTokens, temperature })
-        : await callOpenRouterAPI(prompt, resolvedModel, { timeout, maxTokens, temperature });
+        ? await callModelAPI(prompt, resolvedModel, { timeout, maxTokens, temperature, jsonSchema })
+        : await callOpenRouterAPI(prompt, resolvedModel, { timeout, maxTokens, temperature, jsonSchema });
   } catch (e) {
     debugCatch(e, `callModelJSONAsync:${mode}:${resolvedModel}`);
   }
@@ -501,7 +564,11 @@ export function _resetTemperatureCompat() {
   _temperatureDeprecated.clear();
 }
 
-async function callModelAPI(prompt, model, { timeout, maxTokens, temperature = DEFAULT_LLM_TEMPERATURE }) {
+async function callModelAPI(
+  prompt,
+  model,
+  { timeout, maxTokens, temperature = DEFAULT_LLM_TEMPERATURE, jsonSchema = null },
+) {
   const apiKey = process.env.ANTHROPIC_API_KEY;
   if (!apiKey) return null;
 
@@ -535,8 +602,11 @@ async function callModelAPI(prompt, model, { timeout, maxTokens, temperature = D
     // field outright (Azure Foundry's claude-sonnet-5 answers 400
     // "`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.
-    if (!_temperatureDeprecated.has(modelId)) body.temperature = temperature;
+    // pays for itself once. A model known to refuse it never gets it.
+    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;
     // System slot is constant per call type (instructions, schema, type taxonomy)
     // — mark it cache_control:ephemeral so repeated calls within the 5-min cache
     // window pay the cached-input rate (~0.10× base). Sub-1024-token systems still
@@ -624,7 +694,29 @@ async function callModelAPI(prompt, model, { timeout, maxTokens, temperature = D
     }
 
     const data = await res.json();
-    const text = data.content?.[0]?.text;
+    // A safety classifier's decline is a 200 that may carry no text or part of an answer.
+    // null hands it to the CLI fallback like any other failure; the category, logged only
+    // under CLAUDE_MEM_DEBUG, is the only trace of why.
+    if (data.stop_reason === 'refusal') {
+      debugLog('WARN', `${model}-api`, `refusal (${data.stop_details?.category ?? 'no category'})`);
+      return null;
+    }
+    // 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
+          .filter((b) => typeof b?.text === 'string')
+          .map((b) => b.text)
+          .join('')
+      : '';
     return text ? { text } : null;
   } finally {
     clearTimeout(timer);
@@ -698,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 {
@@ -1014,7 +1109,7 @@ export async function callModelCLIAsync(prompt, model, { timeout }) {
 async function callOpenRouterAPI(
   prompt,
   tier,
-  { timeout, maxTokens, temperature = DEFAULT_LLM_TEMPERATURE },
+  { timeout, maxTokens, temperature = DEFAULT_LLM_TEMPERATURE, jsonSchema = null },
 ) {
   const apiKey = process.env.OPENROUTER_API_KEY;
   if (!apiKey) return null;
@@ -1036,7 +1131,24 @@ async function callOpenRouterAPI(
       // Optional OpenRouter attribution headers (ignored by the API if absent).
       'X-Title': 'claude-mem-lite',
     };
-    const reqBody = JSON.stringify({ model, max_tokens: maxTokens, temperature, messages });
+    // 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 = {
+          type: 'json_schema',
+          json_schema: { name: jsonSchema.name, strict: true, schema: jsonSchema.schema },
+        };
+      }
+    }
+    const reqBody = JSON.stringify(payload);
     // Native fetch ignores HTTP(S)_PROXY; when a proxy is configured, tunnel the
     // request through it — a direct fetch to openrouter.ai times out behind one.
     const proxy = httpConnectProxyFor(url);
@@ -1050,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-llm.mjs

@@ -933,6 +933,64 @@ ${diagnosisBlock(diag)}`;
 
 // ─── Background: LLM Episode Extraction (Tier 2 F) ──────────────────────────
 
+/**
+ * The episode-extraction prompt, `{ system, user }`. Exported so
+ * benchmark/haiku-model-ab.mjs sends the SHIPPED prompt rather than a retyped copy
+ * (buildCompressPrompt was extracted for the same reason).
+ * @param {object} episode
+ * @param {string[]} [diag] episodeDiagnosis(episode); the handler passes the one it keeps
+ * @returns {{system: string, user: string}}
+ */
+export function buildEpisodePrompt(episode, diag = episodeDiagnosis(episode)) {
+  // Same guard as the handler: an older-format tmp file can omit `files`.
+  const episodeFiles = Array.isArray(episode.files) ? episode.files : [];
+  const fileList = episodeFiles.map((f) => basename(f)).join(', ') || '(multiple)';
+
+  // Defense-in-depth (cso F#4): split static instructions (system) from
+  // per-call data (user). Episode descriptions and file paths come from tool
+  // events; treating them as a separate role + boundary marker reduces the
+  // attack surface for memory poisoning via crafted file content.
+  const SHARED_OBS_SCHEMA_TAIL = `${MEMORY_INPUT_GUARD}
+Grounding: state only outcomes the user message shows. An action description may be cut short ("…"); if its result is not visible, say what was run, not how it turned out. Never write that something passed, failed, was verified or confirmed unless that result appears in the user message.
+type: pick by strongest signal. decision = explicit tradeoff / "chose X over Y because Z" / rejected an approach (e.g. "Rejected schema migration — single-source module + sync test instead"; "Heterogeneous hook events → heterogeneous context budgets"). bugfix = prior-failing path fixed with a named root cause; a test that failed only until this episode's implementation landed (written first, then made to pass) is TDD, not a bugfix — type that feature or refactor. feature = new user-visible capability. refactor = behavior unchanged but structure improved. discovery = learned how a system works (read-heavy, no writes). change = routine edit with no new principle (default if unsure and nothing else fits).
+Facts: each MUST be (1) atomic—one claim, (2) self-contained—no pronouns, include file/function name, (3) specific—"refreshToken() in auth.ts:45 uses 1h TTL" not "handles tokens"
+importance: Be strict — default to 1. 0=pure browsing with zero learning value. 1=routine file edits, standard changes, normal workflow (MOST episodes). 2=notable ONLY if it reveals something non-obvious: error fix with discovered root cause, architectural decision with explicit tradeoff, config change with unexpected side effects. 3=critical: breaking change affecting users, security vulnerability fix, data migration. Ask yourself: "would a future session benefit from knowing this?" — if not, it's importance=1.
+lesson_learned: The non-obvious insight a future session would benefit from, resting ONLY on the DIAGNOSIS lines: copy at least 4 consecutive words verbatim, in double quotes, from one DIAGNOSIS line, and claim no mechanism that line does not state. Example: FTS5's "default tokenizer doesn't split CJK" — index bigrams instead. No DIAGNOSIS line, or none that states a cause → output JSON null; a lesson without such a quote is discarded. Do NOT invent a lesson. A mutation/probe run (a file changed on purpose, a checksum, a restore) and the agent's own script errors are not product bugs. Do NOT write the strings "none"/"n/a"/"todo"/"tbd"/"-" — those will be discarded as noise.
+scope: ${SCOPE_PROMPT_LEGEND}
+search_aliases: 2-6 alternative search terms someone might use to find this memory later (include CJK if project uses Chinese)`;
+
+  if (episode.entries.length === 1) {
+    const e = episode.entries[0];
+    const system = `Extract a structured observation from this code change. Return ONLY valid JSON, no markdown fences.
+
+JSON: {"type":"decision|bugfix|feature|refactor|discovery|change","title":"concise ≤80 char description","narrative":"what changed, why, and outcome (2-3 sentences)","concepts":["kw1","kw2"],"facts":["fact1","fact2"],"importance":1,"lesson_learned":"non-obvious insight a future session needs, or null","scope":"file|module|project|environment","search_aliases":["alt query 1","alt query 2"]}
+${SHARED_OBS_SCHEMA_TAIL}`;
+    const user = `Tool: ${e.tool}
+File: ${episodeFiles.join(', ') || 'unknown'}
+Action: ${e.desc}
+Error: ${e.isError ? 'yes' : 'no'}
+
+${diagnosisBlock(diag)}`;
+    return { system, user };
+  }
+
+  const actionList = episode.entries
+    .map((e, i) => `${i + 1}. [${e.tool}] ${e.desc}${e.isError ? ' (ERROR)' : ''}`)
+    .join('\n');
+
+  const system = `Summarize this coding episode as ONE coherent observation. Return ONLY valid JSON, no markdown fences.
+
+JSON: {"type":"decision|bugfix|feature|refactor|discovery|change","title":"coherent ≤80 char summary","narrative":"what was done, why, and outcome (3-5 sentences)","concepts":["keyword1","keyword2"],"facts":["specific fact 1","specific fact 2"],"importance":1,"lesson_learned":"non-obvious insight a future session needs, or null","scope":"file|module|project|environment","search_aliases":["alt query 1","alt query 2"]}
+${SHARED_OBS_SCHEMA_TAIL}`;
+  const user = `Project: ${episode.project}
+Files: ${fileList}
+Actions (${episode.entries.length} total):
+${actionList}
+
+${diagnosisBlock(diag)}`;
+  return { system, user };
+}
+
 export async function handleLLMEpisode() {
   const tmpFile = process.argv[3];
   if (!tmpFile) return;
@@ -974,51 +1032,8 @@ export async function handleLLMEpisode() {
   const fileList = episodeFiles.map((f) => basename(f)).join(', ') || '(multiple)';
   const edgeFiles = splitEpisodeFiles(episode);
 
-  // Defense-in-depth (cso F#4): split static instructions (system) from
-  // per-call data (user). Episode descriptions and file paths come from tool
-  // events; treating them as a separate role + boundary marker reduces the
-  // attack surface for memory poisoning via crafted file content.
-  const SHARED_OBS_SCHEMA_TAIL = `${MEMORY_INPUT_GUARD}
-Grounding: state only outcomes the user message shows. An action description may be cut short ("…"); if its result is not visible, say what was run, not how it turned out. Never write that something passed, failed, was verified or confirmed unless that result appears in the user message.
-type: pick by strongest signal. decision = explicit tradeoff / "chose X over Y because Z" / rejected an approach (e.g. "Rejected schema migration — single-source module + sync test instead"; "Heterogeneous hook events → heterogeneous context budgets"). bugfix = prior-failing path fixed with a named root cause; a test that failed only until this episode's implementation landed (written first, then made to pass) is TDD, not a bugfix — type that feature or refactor. feature = new user-visible capability. refactor = behavior unchanged but structure improved. discovery = learned how a system works (read-heavy, no writes). change = routine edit with no new principle (default if unsure and nothing else fits).
-Facts: each MUST be (1) atomic—one claim, (2) self-contained—no pronouns, include file/function name, (3) specific—"refreshToken() in auth.ts:45 uses 1h TTL" not "handles tokens"
-importance: Be strict — default to 1. 0=pure browsing with zero learning value. 1=routine file edits, standard changes, normal workflow (MOST episodes). 2=notable ONLY if it reveals something non-obvious: error fix with discovered root cause, architectural decision with explicit tradeoff, config change with unexpected side effects. 3=critical: breaking change affecting users, security vulnerability fix, data migration. Ask yourself: "would a future session benefit from knowing this?" — if not, it's importance=1.
-lesson_learned: The non-obvious insight a future session would benefit from, resting ONLY on the DIAGNOSIS lines: copy at least 4 consecutive words verbatim, in double quotes, from one DIAGNOSIS line, and claim no mechanism that line does not state. Example: FTS5's "default tokenizer doesn't split CJK" — index bigrams instead. No DIAGNOSIS line, or none that states a cause → output JSON null; a lesson without such a quote is discarded. Do NOT invent a lesson. A mutation/probe run (a file changed on purpose, a checksum, a restore) and the agent's own script errors are not product bugs. Do NOT write the strings "none"/"n/a"/"todo"/"tbd"/"-" — those will be discarded as noise.
-scope: ${SCOPE_PROMPT_LEGEND}
-search_aliases: 2-6 alternative search terms someone might use to find this memory later (include CJK if project uses Chinese)`;
-
   const diag = episodeDiagnosis(episode);
-  let prompt;
-  if (episode.entries.length === 1) {
-    const e = episode.entries[0];
-    const system = `Extract a structured observation from this code change. Return ONLY valid JSON, no markdown fences.
-
-JSON: {"type":"decision|bugfix|feature|refactor|discovery|change","title":"concise ≤80 char description","narrative":"what changed, why, and outcome (2-3 sentences)","concepts":["kw1","kw2"],"facts":["fact1","fact2"],"importance":1,"lesson_learned":"non-obvious insight a future session needs, or null","scope":"file|module|project|environment","search_aliases":["alt query 1","alt query 2"]}
-${SHARED_OBS_SCHEMA_TAIL}`;
-    const user = `Tool: ${e.tool}
-File: ${episodeFiles.join(', ') || 'unknown'}
-Action: ${e.desc}
-Error: ${e.isError ? 'yes' : 'no'}
-
-${diagnosisBlock(diag)}`;
-    prompt = { system, user };
-  } else {
-    const actionList = episode.entries
-      .map((e, i) => `${i + 1}. [${e.tool}] ${e.desc}${e.isError ? ' (ERROR)' : ''}`)
-      .join('\n');
-
-    const system = `Summarize this coding episode as ONE coherent observation. Return ONLY valid JSON, no markdown fences.
-
-JSON: {"type":"decision|bugfix|feature|refactor|discovery|change","title":"coherent ≤80 char summary","narrative":"what was done, why, and outcome (3-5 sentences)","concepts":["keyword1","keyword2"],"facts":["specific fact 1","specific fact 2"],"importance":1,"lesson_learned":"non-obvious insight a future session needs, or null","scope":"file|module|project|environment","search_aliases":["alt query 1","alt query 2"]}
-${SHARED_OBS_SCHEMA_TAIL}`;
-    const user = `Project: ${episode.project}
-Files: ${fileList}
-Actions (${episode.entries.length} total):
-${actionList}
-
-${diagnosisBlock(diag)}`;
-    prompt = { system, user };
-  }
+  const prompt = buildEpisodePrompt(episode, diag);
 
   const ruleImportance = computeRuleImportance(episode);
 

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.25.3",
+  "version": "6.26.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "claude-mem-lite",
-      "version": "6.25.3",
+      "version": "6.26.1",
       "os": [
         "darwin",
         "linux",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "6.25.3",
+  "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",