@modusensus/dsh-mneme 0.8.6 → 0.8.8

package/test/mirror-types.test.js

@@ -0,0 +1,208 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync, existsSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { MIRROR_EXCLUDED_TYPES, MIRROR_READONLY_TYPES, TYPE_FILE, createMirror, parseHumanEdits, renderMirrorText } from "../src/mirror.js";
+import { createStore, TYPES } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { PACKAGE_VERSION } from "../src/version-check.js";
+
+// #278 第一批：落盘盲区。TYPE_FILE 原先只有 5 个键，pitfall / constraint /
+// rejected_solution / pattern 这些后加的 type 从不进镜像与导出——落点存在，但对
+// 一半活跃记忆是盲的，且没有任何提示。#296 第二批把 document 也收了进来（只读
+// 指针视图），排除集因此为空；两个集合的边界仍由下面的双向断言钉住。
+const FORMERLY_UNCOVERED = ["pitfall", "constraint", "rejected_solution", "pattern"];
+
+function tempDir() {
+  return mkdtempSync(join(tmpdir(), "dsh-mneme-types-"));
+}
+
+function memory(type, over = {}) {
+  return {
+    id: "m1", type, title: "标题", content: "内容", tags: ["a"], importance: 3,
+    forgotten: false, created_at: "2026-01-01T00:00:00.000Z",
+    updated_at: "2026-01-01T00:00:00.000Z", ...over
+  };
+}
+
+test("#278: every store type has a landing point except the pinned exclusions", () => {
+  const missing = [...TYPES].filter((t) => !TYPE_FILE[t] && !MIRROR_EXCLUDED_TYPES.has(t));
+  assert.deepEqual(missing, [], "新增 type 必须显式决定落不落镜像，不能留下静默盲区");
+  assert.deepEqual(Object.keys(TYPE_FILE).filter((t) => !TYPES.has(t)), [], "TYPE_FILE 不得含 store 不认识的键");
+  assert.deepEqual([...MIRROR_EXCLUDED_TYPES].filter((t) => !TYPES.has(t)), [], "排除集里的 key 必须是真 type");
+  // 双向：注释说的「TYPES \ TYPE_FILE 恰好等于排除集」要真被钉住。只查上面两条
+  // 的话，将来有人把 document 加进 TYPE_FILE 却忘了从排除集删，两边同时变假还全绿。
+  assert.deepEqual([...MIRROR_EXCLUDED_TYPES].filter((t) => TYPE_FILE[t]), [], "排除集与落盘集不得重叠");
+  for (const type of FORMERLY_UNCOVERED) {
+    assert.ok(TYPE_FILE[type], `${type} 必须有镜像文件（#278 第一批验收项）`);
+  }
+});
+
+test("#278: an entry of a formerly uncovered type survives render → parse round-trip", () => {
+  const text = renderMirrorText("pitfall", [memory("pitfall")]);
+  const [edit] = parseHumanEdits(text);
+  assert.equal(edit.id, "m1");
+  assert.equal(edit.title, "标题");
+  assert.equal(edit.content, "内容", "frontmatter 与元数据行都不得进 content");
+  assert.equal(edit.updated_at, "2026-01-01T00:00:00.000Z");
+});
+
+test("#278: file header carries type / covered / coverage / tags union", () => {
+  const text = renderMirrorText("constraint", [
+    memory("constraint", { id: "m2", tags: ["z", "a"], updated_at: "2026-02-01T00:00:00.000Z" }),
+    memory("constraint", { id: "m1", tags: ["a", "m"] })
+  ]);
+  assert.ok(text.startsWith("---\n"), "frontmatter 必须在文件最前");
+  const fm = text.slice(4, text.indexOf("\n---", 3));
+  assert.match(fm, /^type: constraint$/m);
+  // OKF §7 actor 约定：<producer>/<version>，不是裸的 producer 名
+  assert.equal(fm.match(/^generated\.by: (.+)$/m)?.[1], `dsh-mneme/${PACKAGE_VERSION}`);
+  assert.match(fm, /^generated\.at: \d{4}-\d{2}-\d{2}T/m);
+  assert.match(fm, /^covered: 2$/m);
+  assert.match(fm, /^coverage: active-only$/m);
+  assert.match(fm, /^tags: \["a", "m", "z"\]$/m);
+  // frontmatter 不是条目、也不改条目数
+  assert.equal(parseHumanEdits(text).length, 2);
+});
+
+test("#278/#296: mirror writes the formerly uncovered files, and documents land as a pointer view", () => {
+  const dir = tempDir();
+  try {
+    const mirror = createMirror(dir);
+    const rows = FORMERLY_UNCOVERED.map((type, i) => memory(type, { id: `m${i}`, content: `内容${i}` }));
+    rows.push(memory("document", {
+      id: "doc1", title: "报告", content: "第一句。第二句不该出现。", doc_path: "C:/docs/report.md"
+    }));
+    mirror.sync(rows);
+    for (const [i, type] of FORMERLY_UNCOVERED.entries()) {
+      const file = join(dir, TYPE_FILE[type]);
+      assert.ok(existsSync(file), `${TYPE_FILE[type]} 必须落盘`);
+      const [edit] = parseHumanEdits(readFileSync(file, "utf8"));
+      assert.equal(edit.id, `m${i}`);
+      assert.equal(edit.content, `内容${i}`);
+    }
+    // #296 第 4 条：document 落盘，但只给指针行——id + 标题 + 摘要首句 + 路径，
+    // 不含正文；文件头必须说清这是只读视图（不能复用「可编辑」那句）。
+    assert.ok(MIRROR_READONLY_TYPES.has("document"), "document 是只读 type");
+    assert.ok(existsSync(join(dir, "documents.md")), "document 指针行现在落盘");
+    const docs = readFileSync(join(dir, "documents.md"), "utf8");
+    assert.match(docs, /只读视图/);
+    assert.ok(docs.includes("doc1") && docs.includes("报告") && docs.includes("第一句"));
+    assert.ok(docs.includes("report.md"), "指针行必须给出 doc_path，否则「看着完整、其实找不到文件」的老问题原样回来");
+    assert.ok(!docs.includes("第二句"), "只读视图不含全文，只留摘要首句");
+    assert.equal(parseHumanEdits(docs).length, 0, "指针行不是可回填的条目");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("#296: readHumanEdits never returns the read-only type — a hand-edited view cannot reach the store", () => {
+  const dir = tempDir();
+  try {
+    const mirror = createMirror(dir);
+    mirror.sync([memory("document", { id: "doc1", doc_path: "/tmp/report.md" })]);
+    // 模拟有人在 documents.md 里手改（视图是机器所有，改动必须被忽略而不是回填）
+    const file = join(dir, TYPE_FILE.document);
+    writeFileSync(file, readFileSync(file, "utf8") + "- **ID**: `doc1`\n- **类型**: document\n被人改过的正文\n", "utf8");
+    assert.deepEqual(mirror.readHumanEdits("document"), [], "指定的只读 type 也要跳过");
+    assert.deepEqual(mirror.readHumanEdits().filter((e) => e.id === "doc1"), [], "全量扫描同样跳过它");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("#278: mirror covers every active row — no silent 500-row truncation", () => {
+  const dir = tempDir();
+  let store;
+  try {
+    store = createStore(join(dir, "memory.db"));
+    const service = createService({ store, mirror: createMirror(dir), config: {} });
+    for (let i = 0; i < 501; i++) store.save({ type: "pitfall", title: `t${i}`, content: `c${i}` });
+    // 任意一次业务写触发一次镜像同步（不是逐条 save，避免 501 次渲染）
+    service.saveWithDedupe({ type: "pattern", title: "trigger", content: "x" });
+    const text = readFileSync(join(dir, TYPE_FILE.pitfall), "utf8");
+    assert.match(text, /^covered: 501$/m, "文件头必须如实自述覆盖条数");
+    assert.equal((text.match(/^- \*\*ID\*\*: /gm) ?? []).length, 501, "超过 500 条的活跃集必须全部落盘");
+    assert.equal(parseHumanEdits(text).length, 501);
+  } finally {
+    // close 必须在 rm 之前：Windows 上库文件仍被打开时 rmSync 会 EPERM，把断言
+    // 失败覆盖成文件锁错误。
+    store?.close();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("#278: scope / sensitivity 只作展示字段，且永不进 content", () => {
+  const text = renderMirrorText("constraint", [memory("constraint", {
+    agent_scope: "standard",
+    workspace_scope: "D:/WorkSpace/demo",
+    sensitivity: "personal"
+  })]);
+  assert.match(text, /^- \*\*作用域\*\*: standard \/ D:\/WorkSpace\/demo$/m);
+  assert.match(text, /^- \*\*敏感度\*\*: personal$/m);
+  assert.equal(parseHumanEdits(text)[0].content, "内容", "新字段不得进 content");
+  // 没值的条目不该多出空字段行（本机 2843 条里只有 37 条带 scope 标签）
+  const bare = renderMirrorText("constraint", [memory("constraint")]);
+  assert.ok(!bare.includes("作用域") && !bare.includes("敏感度"));
+  // 值是调用方传的任意字符串：里面的换行不得伪造出第二个条目头
+  const injected = renderMirrorText("constraint", [memory("constraint", {
+    sensitivity: "x\n- **ID**: `ghost`\n- **类型**: decision"
+  })]);
+  assert.equal(parseHumanEdits(injected).length, 1, "值里的换行不得造出幽灵条目");
+  // 值本身仍在（被压成一行），关键是它不再位于行首——行首才是条目头的锚
+  assert.ok(!/^- \*\*ID\*\*: `ghost`/m.test(injected), "不得出现伪造的条目头");
+});
+
+test("#278: mirror keeps its active-only claim — archived and forgotten rows stay out", () => {
+  const dir = tempDir();
+  let store;
+  try {
+    store = createStore(join(dir, "memory.db"));
+    const service = createService({ store, mirror: createMirror(dir), config: {} });
+    // forgotten 在 INSERT 里硬编码为 0（store.js insertMemoryRow），只能经 setForget
+    // 设置；archived 可以在载荷里给，这里统一走 setter 保持同一个路径。
+    for (const [id, title] of [["keep-c", "留"], ["arch-c", "归档"], ["gone-c", "遗忘"]]) {
+      store.save({ id, type: "constraint", title, content: "c" });
+    }
+    store.setArchived("arch-c", true);
+    store.setForget("gone-c", true);
+    service.saveWithDedupe({ type: "pattern", title: "trigger", content: "x" });
+    const text = readFileSync(join(dir, TYPE_FILE.constraint), "utf8");
+    // 文件头写 coverage: active-only，正文就必须只有活跃行——说一套写一套比没有
+    // 这个字段更糟（外部工具照着聚合）。
+    assert.match(text, /^covered: 1$/m, "覆盖条数只数活跃行");
+    assert.ok(text.includes("keep-c"));
+    assert.ok(!text.includes("arch-c"), "归档行不进镜像");
+    assert.ok(!text.includes("gone-c"), "遗忘行不进镜像");
+  } finally {
+    store?.close();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("#278: re-syncing unchanged content does not rewrite the file", () => {
+  const dir = tempDir();
+  try {
+    const mirror = createMirror(dir);
+    const rows = [memory("pitfall"), memory("constraint", { id: "m2" })];
+    mirror.sync(rows);
+    const first = readFileSync(join(dir, TYPE_FILE.pitfall), "utf8");
+    const firstAt = first.match(/^generated\.at: (.+)$/m)[1];
+    // generated.at 每次渲染都是新时间戳：无脑落盘会让编辑器、同步盘与 git 在每次
+    // 业务写后都看到全部镜像「被外部修改」，而内容一字未变。
+    mirror.sync(rows);
+    const second = readFileSync(join(dir, TYPE_FILE.pitfall), "utf8");
+    assert.equal(second, first, "内容未变的文件不得被重写");
+    assert.equal(second.match(/^generated\.at: (.+)$/m)[1], firstAt, "未变时保留原时间戳");
+    // 内容真变了必须落盘
+    mirror.sync([memory("pitfall", { content: "改了" })]);
+    const third = readFileSync(join(dir, TYPE_FILE.pitfall), "utf8");
+    assert.notEqual(third, second);
+    assert.ok(third.includes("改了"));
+    // 顺手确认「空 type 删文件」这条防复活行为没被上面的跳过逻辑带坏
+    assert.ok(!existsSync(join(dir, TYPE_FILE.constraint)), "该 type 没行时文件要删掉");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/test/reasoning-effort.test.js

@@ -48,11 +48,17 @@ test("issue#135: reasoningEffort unset = undefined (auto-lowest at resolve time)
   const cfg = Config({});
   assert.equal(cfg.dreamReasoningEffort, undefined, "unset must be distinguishable from explicit 'none'");
   assert.equal(cfg.sleepReasoningEffort, undefined);
+  // issue #315: the distill knob defaults to 'none' (entity-extraction shape,
+  // no auto-lowest resolution — distill keeps its current behavior until the
+  // user opts in).
+  assert.equal(cfg.summarizeReasoningEffort, "none", "distill effort defaults to 'none'");
+  assert.equal(Config({ summarizeReasoningEffort: "off" }).summarizeReasoningEffort, "off");
   assert.equal(Config({ dreamReasoningEffort: "none" }).dreamReasoningEffort, "none", "explicit 'none' kept");
   assert.equal(Config({ dreamReasoningEffort: "off" }).dreamReasoningEffort, "off", "'off' now a valid explicit choice");
   assert.equal(Config({ sleepReasoningEffort: "medium" }).sleepReasoningEffort, "medium");
   assert.throws(() => Config({ dreamReasoningEffort: "bogus" }), "invalid effort rejected");
   assert.throws(() => Config({ sleepReasoningEffort: "ultra" }), "invalid effort rejected");
+  assert.throws(() => Config({ summarizeReasoningEffort: "max" }), "invalid distill effort rejected");
 });
 
 // ---------------------------------------------------------------- dream passthrough

package/test/recall-evals.test.js

@@ -233,3 +233,21 @@ test("production search never writes recall_evals, even with the switch on", asy
   assert.deepEqual(store.listRecallEvals(), [], "recall_evals stays untouched by production search");
   store.close();
 });
+
+// ---------------------------------------------------------------- per-source signals in receipt
+
+test("recall receipt: candidates carry per-source signals for offline fusion-weight profiling", async () => {
+  const { store, service } = setup({});
+  const captured = [];
+  service.setRecallRecorder((recall) => captured.push(recall));
+  saveMemory(service, "量子计算入门", "叠加态");
+  const rows = await service.searchMemories("量子", { mode: "hybrid", recordRecall: true });
+  assert.ok(rows.length >= 1, "search returned results");
+  assert.equal(captured.length, 1, "exactly one receipt");
+  for (const c of captured[0].candidates) {
+    assert.ok(c.signals && typeof c.signals === "object", "every candidate carries a signals object");
+    assert.ok("keyword" in c.signals, "raw keyword score present (pre-fusion, unweighted)");
+    assert.ok(!("final" in c.signals), "raw signals only — the fused score already lives in c.score");
+  }
+  store.close();
+});

package/test/recall-stats.test.js

@@ -121,3 +121,69 @@ test("windowDays/exemptDays 越界回默认；扫描超上限标 truncated", ()
   assert.equal(total, 2, "窗口总数不截断 → truncated = total > rows.length");
   store.close();
 });
+
+// ============================ 第五指标（#275）：归档净增速率 + 可压掉行数
+
+test("归档净增速率：按 updated_at 取归档时刻，窗外归档只进总数不进净增", () => {
+  const { store, service } = setup();
+  const fresh = service.saveWithDedupe({ type: "history", title: "刚归档", content: "x", importance: 3 }).memory;
+  const old = service.saveWithDedupe({ type: "history", title: "早归档", content: "y", importance: 3 }).memory;
+  service.saveWithDedupe({ type: "history", title: "活跃件", content: "z", importance: 3 });
+  store.setArchived(fresh.id, true);
+  store.setArchived(old.id, true);
+  // 归档时刻 = 最后一次写（setArchived 刷 updated_at）：把这行推到窗口外
+  store.db.prepare("UPDATE memories SET updated_at = ? WHERE id = ?")
+    .run(new Date(Date.now() - 100 * 86400000).toISOString(), old.id);
+
+  const stats = service.recallStats({ windowDays: 30, exemptDays: 0 });
+  assert.equal(stats.archive.total, 2, "归档区现有行数（活跃件不算）");
+  assert.equal(stats.archive.addedInWindow, 1, "窗外那次归档不算本窗口净增");
+  assert.equal(stats.archive.perDay, Math.round((1 / 30) * 100) / 100);
+  store.close();
+});
+
+test("可压掉行数：同 type 同 scope 的内容哈希精确重复（跨 scope / 活跃行都不算）", () => {
+  const { store, service } = setup();
+  // 标题只差大小写、正文只差标点与空白 → 归一化后同哈希（#254 的口径）
+  const a = store.save({ type: "history", title: "Task A", content: "line1.\n\nline2" });
+  const b = store.save({ type: "history", title: "task a", content: "line1 line2" });
+  const otherScope = store.save({ type: "history", title: "Task A", content: "line1 line2", agent_scope: "other" });
+  store.save({ type: "history", title: "Task A", content: "line1 line2" });
+  for (const id of [a.id, b.id, otherScope.id]) store.setArchived(id, true);
+
+  const stats = service.recallStats({ windowDays: 30, exemptDays: 0 });
+  assert.equal(stats.archive.compressible.groups, 1, "跨 scope 不互判（与去重候选集同一把尺）");
+  assert.equal(stats.archive.compressible.rows, 1, "每组留一行，多出来的才叫可压掉");
+  assert.equal(stats.archive.total, 3, "跨 scope 行照进总数，只是不参与可压掉");
+  assert.equal(stats.archive.addedInWindow, 3, "三行都是本窗口内归档的");
+  store.close();
+});
+
+test("可压掉行数：向量口径不可用时的兜底——指标不依赖 embedding", () => {
+  // 回归点：回收动作会清掉归档行向量（clearArchivedEmbeddings），若指标建在向量近
+  // 重复上，回收一跑它就归零。这里清完向量后指标必须不变。
+  const { store, service } = setup();
+  const a = store.save({ type: "history", title: "同题", content: "同一件事" });
+  const b = store.save({ type: "history", title: "同题", content: "同一件事" });
+  store.setArchived(a.id, true);
+  store.setArchived(b.id, true);
+  assert.equal(service.recallStats({ windowDays: 30, exemptDays: 0 }).archive.compressible.rows, 1);
+
+  store.clearArchivedEmbeddings();
+  assert.equal(
+    service.recallStats({ windowDays: 30, exemptDays: 0 }).archive.compressible.rows,
+    1,
+    "清向量不影响可压掉行数"
+  );
+  store.close();
+});
+
+test("没有归档行时给 0，不返回 null / NaN", () => {
+  const { store, service } = setup();
+  service.saveWithDedupe({ type: "project", title: "只有活跃", content: "x", importance: 3 });
+  const stats = service.recallStats({ windowDays: 30, exemptDays: 0 });
+  assert.deepEqual(stats.archive, {
+    total: 0, addedInWindow: 0, perDay: 0, compressible: { rows: 0, groups: 0 }
+  });
+  store.close();
+});

package/test/summarize-reasoning-effort.test.js

@@ -0,0 +1,189 @@
+// Regression for issue #315: the distill (summarize) LLM call gets a reasoning
+// effort knob, mirroring the entity-extraction shape (issue #109) and reusing
+// the dream/sleep fallback machinery. Pins:
+//  - explicit effort is forwarded on the distill stream call;
+//  - default 'none' omits the field entirely (current behavior unchanged);
+//  - a stream-level effort rejection (error finish chunk, the rc.1 shape that
+//    never reaches catch) is retried once WITHOUT the field;
+//  - non-effort stream failures are NOT retried (no blind double calls) and
+//    the aborted window stays retryable (cursor not consumed);
+//  - 'off' works like any explicit effort (rejected → retried without it).
+// Mock shapes (ctx.on subscription capture, {delta} text chunks, finish
+// {reason:{kind,failure}}) follow the existing summarize.test.js conventions.
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createSummarizer } from "../src/summarize.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+
+const ENTRIES_JSON = JSON.stringify([
+  { type: "decision", title: "选型", content: "确定用 node:sqlite", importance: 4 }
+]);
+
+function userMessage(text, seq) {
+  return {
+    seq,
+    type: "user/message",
+    data: { source: { kind: "user" }, content: [{ type: "text", text }] }
+  };
+}
+
+function setup(configOver = {}, stream) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const calls = [];
+  const events = [];
+  const ctx = {
+    on(name, fn) {
+      events.push({ name, fn });
+      return () => {};
+    },
+    llm: {
+      stream(options) {
+        calls.push(options);
+        return stream(options);
+      }
+    }
+  };
+  const config = { autoSummarize: true, distillRateLimitIntervalMs: 0, ...configOver };
+  createSummarizer(ctx, service, config, {});
+  const handler = events.find((e) => e.name === "session/event").fn;
+  const session = {
+    id: "s315",
+    requestHeader: () => ({ config: { provider: "deepseek", model: "deepseek-chat" } }),
+    events: [userMessage("帮我选型", 1), { seq: 2, type: "turn/end" }]
+  };
+  return { store, service, calls, handler, session };
+}
+
+test("issue#315: explicit summarizeReasoningEffort is forwarded on the distill call", async () => {
+  const { store, calls, handler, session } = setup(
+    { summarizeReasoningEffort: "low" },
+    () => (async function* () {
+      yield { type: "text-delta", delta: ENTRIES_JSON };
+      yield { type: "finish", kind: "ok" };
+    })()
+  );
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].reasoningEffort, "low", "the configured effort rides the distill call");
+  store.close();
+});
+
+test("issue#315: default 'none' omits the reasoningEffort field entirely", async () => {
+  const { store, calls, handler, session } = setup(
+    {},
+    () => (async function* () {
+      yield { type: "text-delta", delta: ENTRIES_JSON };
+      yield { type: "finish", kind: "ok" };
+    })()
+  );
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 1);
+  assert.equal("reasoningEffort" in calls[0], false, "unset/'none' must not add the field");
+  assert.equal(store.count(), 1, "entries still stored as before");
+  store.close();
+});
+
+test("issue#315: stream-level effort rejection retries once without the field", async () => {
+  const { store, calls, handler, session } = setup(
+    { summarizeReasoningEffort: "low" },
+    (options) => (async function* () {
+      if (options.reasoningEffort) {
+        // rc.1 shape: the provider rejection arrives as a terminal error finish
+        // chunk (adapterStream never throws), so the retry must be triggered
+        // from the chunk path, not a catch block.
+        yield {
+          type: "finish",
+          reason: {
+            kind: "error",
+            failure: {
+              code: "UNSUPPORTED_REASONING_EFFORT",
+              message: 'provider "deepseek" model "deepseek-chat" does not support reasoning effort "low"'
+            }
+          }
+        };
+        return;
+      }
+      yield { type: "text-delta", delta: ENTRIES_JSON };
+      yield { type: "finish", kind: "ok" };
+    })()
+  );
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 2, "exactly one no-effort retry");
+  assert.equal(calls[0].reasoningEffort, "low", "first attempt forwards the effort");
+  assert.equal("reasoningEffort" in calls[1], false, "retry omits the rejected effort field");
+  assert.equal(store.count(), 1, "the retried run still stores its entry");
+  store.close();
+});
+
+test("issue#315: non-effort stream failures are not retried and stay abortable", async () => {
+  const { store, calls, handler, session } = setup(
+    { summarizeReasoningEffort: "low" },
+    () => (async function* () {
+      yield { type: "finish", reason: { kind: "error", failure: { code: "PROVIDER_GONE", message: "provider deepseek is not registered" } } };
+    })()
+  );
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 1, "no blind retry when the stream failure is not an effort rejection");
+  assert.equal(store.count(), 0, "failed window stores nothing");
+  store.close();
+});
+
+test("issue#315: off works like any explicit effort (rejected → retried without it)", async () => {
+  const { store, calls, handler, session } = setup(
+    { summarizeReasoningEffort: "off" },
+    (options) => (async function* () {
+      if (options.reasoningEffort) {
+        yield { type: "finish", reason: { kind: "error", failure: { code: "UNSUPPORTED_REASONING_EFFORT", message: 'reasoning effort "off" is not supported here' } } };
+        return;
+      }
+      yield { type: "text-delta", delta: ENTRIES_JSON };
+      yield { type: "finish", kind: "ok" };
+    })()
+  );
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 2);
+  assert.equal(calls[0].reasoningEffort, "off");
+  assert.equal(store.count(), 1);
+  store.close();
+});
+
+test("issue#315: successful effort-fallback retry records audit as success, not the first failure", async () => {
+  const { store, service, calls, handler, session } = setup(
+    { summarizeReasoningEffort: "low" },
+    (options) => (async function* () {
+      if (options.reasoningEffort) {
+        // first attempt is rejected (effort unsupported)…
+        yield { type: "finish", reason: { kind: "error", failure: { code: "UNSUPPORTED_REASONING_EFFORT", message: 'reasoning effort "low" rejected' } } };
+        return;
+      }
+      // …but the no-effort retry succeeds.
+      yield { type: "text-delta", delta: ENTRIES_JSON };
+      yield { type: "finish", kind: "ok" };
+    })()
+  );
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 2, "effort rejection + one retry");
+  const rows = service.listLlmAudits();
+  const summarize = rows.find((r) => r.operation_type === "summarize_compress");
+  assert.ok(summarize, "summarize audit row present");
+  assert.equal(summarize.status, "success",
+    "the retried run must record success, not the first attempt's error status");
+  store.close();
+});
+
+test("issue#315: abort is not misread as an effort rejection even when the message matches the pattern", async () => {
+  const { store, calls, handler, session } = setup(
+    { summarizeReasoningEffort: "low" },
+    () => (async function* () {
+      // The message matches EFFORT_REJECT_RE on purpose: without the AbortError
+      // guard in withEffortFallback this would be misread as an effort rejection
+      // and trigger a wasteful no-effort retry.
+      throw Object.assign(new Error("aborted by dispose: UNSUPPORTED_REASONING_EFFORT"), { name: "AbortError" });
+    })()
+  );
+  await handler(session, { seq: 2, type: "turn/end" });
+  assert.equal(calls.length, 1, "abort must not trigger a no-effort fallback retry");
+  store.close();
+});