@modusensus/dsh-mneme 0.8.7 → 0.8.8

package/test/dream-failure-backoff.test.js

@@ -0,0 +1,173 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createDreamScheduler } from "../src/dream.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+
+// Issue #292：autoDream 同会话内连续失败退避（autoDreamFailureBackoff，opt-in）。
+//
+// 这些用例锁的是「调度器节流语义」，不是实现细节——防的回归是：
+//   ① 退避闸失效/写反 → 恒定失败的模型（#135 空体面）按 dreamMinIntervalMinutes
+//      的固定节奏连发刷配额（#89 只挡了间隔内重试，间隔本身不会变长）；
+//   ② 成功后连败计数不清零 → 模型恢复正常后仍被旧失败拖着重试推迟（巩固变相停摆）；
+//   ③ 30 分钟封顶失效 → 指数无限翻倍，一整天都不再巩固；
+//   ④ 默认关路径被顺手改掉 → 未 opt-in 用户的重试间隔漂移（默认关 = 行为与
+//      现状逐字节一致的承诺）；
+//   ⑤ 0 基数被偷偷补了间隔 → 未配 dreamMinIntervalMinutes 的用户开退避即被限流
+//      （文档口径：基数 0 时本键不自己产生间隔）。
+//
+// 时钟与定时器全部注入（同 test/dream-peak-hours.test.js 的房型）：「失败 → 推迟
+// → 放行」才能被确定性覆盖，也不在 CI 上留真实等待。退避从上次开跑（lastRunAt）
+// 起算：失败 run 本就占用基数间隔（#89 现状，lastRunAt 在开跑时刷新），退避放大
+// 的是同一道闸，不新增状态面。
+function dreamSetup() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  return { store, service };
+}
+
+function fakeClock(startMs) {
+  let nowMs = startMs;
+  const timers = [];
+  let seq = 1;
+  return {
+    now: () => nowMs,
+    setNow: (v) => { nowMs = v; },
+    timers,
+    setTimeoutFn: (fn, delay) => { const t = { id: seq++, at: nowMs + delay, fn }; timers.push(t); return t.id; },
+    clearTimeoutFn: (id) => { const i = timers.findIndex((t) => t.id === id); if (i >= 0) timers.splice(i, 1); }
+  };
+}
+
+const T0 = new Date(2026, 8, 27, 10, 0, 0, 0).getTime();
+
+/**
+ * 触发一次并等 run 真正落完：断言闸门这次是放行的、恰好挂了一个 delayMs=0 的
+ * 执行定时器，点火后用 setImmediate 冲掉 startRun 的 Promise 链（纯微任务冲刷，
+ * 不留真实等待）。失败路径下 baseline 不刷新，同一份写入可持续触发。
+ */
+async function runOnce(clock, dream, service) {
+  assert.equal(dream.maybeSchedule(service), true, "前置：阈值已过、间隔闸放行");
+  const ts = clock.timers.splice(0);
+  assert.equal(ts.length, 1, "前置：恰好挂了一个执行定时器");
+  ts[0].fn();
+  await new Promise((r) => setImmediate(r));
+}
+
+test("默认关：失败后重试间隔与现状一致（基数，不翻倍）", async () => {
+  const { store, service } = dreamSetup();
+  const clock = fakeClock(T0);
+  let runs = 0;
+  const dream = createDreamScheduler({
+    onRun: async () => { runs++; return { ok: false, error: "llm failed" }; },
+    thresholdCount: 1, thresholdChars: 0, delayMs: 0, minIntervalMs: 100,
+    failureBackoff: false, // 显式默认值：锁「默认关 = 行为逐字节不变」
+    logger: { warn: () => {} },
+    now: clock.now, setTimeoutFn: clock.setTimeoutFn, clearTimeoutFn: clock.clearTimeoutFn
+  });
+  service.saveWithDedupe({ type: "project", title: "a", content: "x" });
+  await runOnce(clock, dream, service); // 失败一次：失败 run 占用基数间隔（#89 现状）
+  assert.equal(runs, 1);
+  clock.setNow(T0 + 50);
+  assert.equal(dream.maybeSchedule(service), false, "基数间隔内照旧跳过");
+  clock.setNow(T0 + 100);
+  assert.equal(dream.maybeSchedule(service), true, "关键：基数间隔一到即放行——不翻倍");
+  store.close();
+});
+
+test("开启：连续失败 2 次 → 第 3 次触发被指数推迟", async () => {
+  const { store, service } = dreamSetup();
+  const clock = fakeClock(T0);
+  let runs = 0;
+  const dream = createDreamScheduler({
+    onRun: async () => { runs++; return { ok: false, error: "empty body" }; },
+    thresholdCount: 1, thresholdChars: 0, delayMs: 0, minIntervalMs: 100,
+    failureBackoff: true,
+    logger: { warn: () => {} },
+    now: clock.now, setTimeoutFn: clock.setTimeoutFn, clearTimeoutFn: clock.clearTimeoutFn
+  });
+  service.saveWithDedupe({ type: "project", title: "a", content: "x" });
+  await runOnce(clock, dream, service); // 败 1：effective = 100 × 2^1 = 200
+  assert.equal(runs, 1);
+  clock.setNow(T0 + 100);
+  assert.equal(dream.maybeSchedule(service), false, "关键：基数到点不放行（现状会在 +100 放行）");
+  clock.setNow(T0 + 200);
+  await runOnce(clock, dream, service); // 败 2：effective = 100 × 2^2 = 400
+  assert.equal(runs, 2);
+  clock.setNow(T0 + 200 + 300);
+  assert.equal(dream.maybeSchedule(service), false, "关键：2 次连败后 400ms 内不放行");
+  clock.setNow(T0 + 200 + 400);
+  assert.equal(dream.maybeSchedule(service), true, "自上次开跑起满 400ms 才放行第 3 次");
+  store.close();
+});
+
+test("成功一次后计数清零、间隔恢复基数", async () => {
+  const { store, service } = dreamSetup();
+  const clock = fakeClock(T0);
+  let failNext = true;
+  const dream = createDreamScheduler({
+    onRun: async () => ({ ok: !failNext }),
+    thresholdCount: 1, thresholdChars: 0, delayMs: 0, minIntervalMs: 100,
+    failureBackoff: true,
+    logger: { warn: () => {} },
+    now: clock.now, setTimeoutFn: clock.setTimeoutFn, clearTimeoutFn: clock.clearTimeoutFn
+  });
+  service.saveWithDedupe({ type: "project", title: "a", content: "x" });
+  await runOnce(clock, dream, service); // 败 1：effective = 200
+  clock.setNow(T0 + 100);
+  assert.equal(dream.maybeSchedule(service), false, "前置：退避确实在挡（基数到点不放行）");
+  clock.setNow(T0 + 200);
+  failNext = false;
+  await runOnce(clock, dream, service); // 成功：连败清零、baseline 刷新为当前库量
+  service.saveWithDedupe({ type: "project", title: "b", content: "y" }); // 补过刷新后的阈值
+  clock.setNow(T0 + 300); // 距上次开跑 +100 = 基数
+  assert.equal(dream.maybeSchedule(service), true, "关键：成功清零后基数即放行（未清零要等 +400）");
+  store.close();
+});
+
+test("cap：连败 10 次 → 推迟量封顶 30 分钟（未封顶需等约 34 小时）", async () => {
+  const { store, service } = dreamSetup();
+  const clock = fakeClock(T0);
+  const BASE = 2 * 60000; // 2 分钟基数：2^10 × 基数 ≈ 34h，30 分钟封顶必被触发
+  let runs = 0;
+  const dream = createDreamScheduler({
+    onRun: async () => { runs++; return { ok: false }; },
+    thresholdCount: 1, thresholdChars: 0, delayMs: 0, minIntervalMs: BASE,
+    failureBackoff: true,
+    logger: { warn: () => {} },
+    now: clock.now, setTimeoutFn: clock.setTimeoutFn, clearTimeoutFn: clock.clearTimeoutFn
+  });
+  service.saveWithDedupe({ type: "project", title: "a", content: "x" });
+  let lastFailAt = T0;
+  for (let i = 1; i <= 10; i++) {
+    if (i > 1) {
+      const wait = Math.min(BASE * 2 ** (i - 1), 30 * 60000); // 与实现同一口径的期望间隔
+      clock.setNow(lastFailAt + wait);
+    }
+    await runOnce(clock, dream, service);
+    lastFailAt = clock.now();
+  }
+  assert.equal(runs, 10);
+  clock.setNow(lastFailAt + 30 * 60000 - 1);
+  assert.equal(dream.maybeSchedule(service), false, "关键：封顶后 30 分钟内仍不放行");
+  clock.setNow(lastFailAt + 30 * 60000);
+  assert.equal(dream.maybeSchedule(service), true, "封顶生效：恰好 30 分钟放行，不再随失败数翻倍");
+  store.close();
+});
+
+test("基数为 0 时退避不自己产生间隔（需先配 dreamMinIntervalMinutes）", async () => {
+  const { store, service } = dreamSetup();
+  const clock = fakeClock(T0);
+  const dream = createDreamScheduler({
+    onRun: async () => ({ ok: false }),
+    thresholdCount: 1, thresholdChars: 0, delayMs: 0, minIntervalMs: 0,
+    failureBackoff: true,
+    logger: { warn: () => {} },
+    now: clock.now, setTimeoutFn: clock.setTimeoutFn, clearTimeoutFn: clock.clearTimeoutFn
+  });
+  service.saveWithDedupe({ type: "project", title: "a", content: "x" });
+  await runOnce(clock, dream, service); // 失败一次
+  clock.setNow(T0);
+  assert.equal(dream.maybeSchedule(service), true, "关键：0 基数无闸可翻倍，开退避也不限流");
+  store.close();
+});

package/test/dream-peak-hours.test.js

@@ -0,0 +1,194 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createDreamScheduler } from "../src/dream.js";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+
+// Issue #239（第 4 项，错峰队列）镜像到巩固：dreamPeakHours / dreamPeakMaxDeferMinutes。
+//
+// 这些用例锁的是「排程语义」，不是实现细节——它们防的回归是：
+//   ① 错峰闸门被写反/失效 → 高峰期又开始做梦（省钱能力静默消失）；
+//   ② 顺延路径把 skip 做成静默 → 用户看到「不再巩固了」却查不出原因；
+//   ③ 顺延没有上限 → 长高峰（如全天）把巩固永久饿死；
+//   ④ 非法时段串被当成「全天高峰」→ 一个笔误把功能整个停掉；
+//   ⑤ dispose 漏清顺延定时器 → 进程关掉后仍触发一次巩固。
+//
+// 时钟与定时器全部注入（同 src/dream/sleep.js 的房型）：排程不绑死真实时钟，
+// 「高峰顺延 → 非高峰补跑」才能被确定性覆盖，也不会在 CI 上留下真实等待。
+function dreamSetup() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  return { store, service };
+}
+
+/** 本地墙钟时间：用本地时区构造，getHours() 在 ubuntu/windows CI 上都等于入参。 */
+function at(hour, minute = 0) {
+  return new Date(2026, 5, 15, hour, minute, 0, 0).getTime();
+}
+
+function fakeClock(startMs) {
+  let nowMs = startMs;
+  const timers = [];
+  let seq = 1;
+  return {
+    now: () => nowMs,
+    setNow: (v) => { nowMs = v; },
+    timers,
+    setTimeoutFn: (fn, delay) => { const t = { id: seq++, at: nowMs + delay, fn }; timers.push(t); return t.id; },
+    clearTimeoutFn: (id) => { const i = timers.findIndex((t) => t.id === id); if (i >= 0) timers.splice(i, 1); }
+  };
+}
+
+/** 造出「超过阈值」的写入量（thresholdCount=2）。 */
+function fill(service, n = 2) {
+  for (let i = 0; i < n; i++) service.saveWithDedupe({ type: "project", title: `m${i}`, content: "x".repeat(50) });
+}
+
+test("dreamPeakHours: 命中高峰不调模型，登记 skip 审计并顺延", () => {
+  const { store, service } = dreamSetup();
+  const clock = fakeClock(at(10, 0)); // 本地 10:00，落在 09:00-18:00 内
+  let runs = 0;
+  const audits = [];
+  const dream = createDreamScheduler({
+    onRun: async () => { runs++; return { ok: true }; },
+    thresholdCount: 2, thresholdChars: 5000, delayMs: 0,
+    peakHours: "09:00-18:00",
+    peakMaxDeferMinutes: 0, // 不设上限：顺延应落在真正的高峰结束时刻
+    now: clock.now, setTimeoutFn: clock.setTimeoutFn, clearTimeoutFn: clock.clearTimeoutFn,
+    auditPeakSkip: (info) => audits.push(info)
+  });
+  fill(service);
+  assert.equal(dream.maybeSchedule(service), false, "高峰内不排「马上跑」");
+  assert.equal(runs, 0, "高峰内绝不调 LLM");
+  assert.equal(audits.length, 1, "skip 必须留痕，否则「为什么不再巩固」不可观测");
+  assert.equal(audits[0].count, 2, "审计带上窗口里积了多少（阈值继续累积，不是丢弃）");
+  assert.equal(clock.timers.length, 1, "挂了一个顺延定时器");
+  assert.equal(clock.timers[0].at, at(18, 0), "顺延到最近的高峰结束时刻");
+  store.close();
+});
+
+test("dreamPeakHours: 顺延到点后补跑（非高峰真的会跑）", async () => {
+  const { store, service } = dreamSetup();
+  const clock = fakeClock(at(10, 0));
+  let runs = 0;
+  const dream = createDreamScheduler({
+    onRun: async () => { runs++; return { ok: true }; },
+    thresholdCount: 2, thresholdChars: 5000, delayMs: 0,
+    peakHours: "09:00-18:00",
+    now: clock.now, setTimeoutFn: clock.setTimeoutFn, clearTimeoutFn: clock.clearTimeoutFn,
+    auditPeakSkip: () => {}
+  });
+  fill(service);
+  dream.maybeSchedule(service);
+  const deferred = clock.timers[0];
+  clock.setNow(deferred.at); // 走到 18:00
+  await deferred.fn();
+  assert.equal(runs, 1, "出高峰后补跑一次");
+  store.close();
+});
+
+test("dreamPeakHours: 重复触发不叠加顺延定时器", () => {
+  const { store, service } = dreamSetup();
+  const clock = fakeClock(at(10, 0));
+  let audits = 0;
+  const dream = createDreamScheduler({
+    onRun: async () => ({ ok: true }),
+    thresholdCount: 2, thresholdChars: 5000, delayMs: 0,
+    peakHours: "09:00-18:00",
+    now: clock.now, setTimeoutFn: clock.setTimeoutFn, clearTimeoutFn: clock.clearTimeoutFn,
+    auditPeakSkip: () => { audits++; }
+  });
+  fill(service);
+  dream.maybeSchedule(service);
+  dream.maybeSchedule(service); // 顺延期间又来一次写入触发
+  assert.equal(clock.timers.length, 1, "同一时刻只有一个顺延定时器");
+  assert.equal(audits, 1, "不重复刷审计行");
+  store.close();
+});
+
+test("dreamPeakMaxDeferMinutes: 上限截断后到点照跑，长高峰不饿死巩固", async () => {
+  const { store, service } = dreamSetup();
+  const clock = fakeClock(at(10, 0));
+  let runs = 0;
+  const dream = createDreamScheduler({
+    onRun: async () => { runs++; return { ok: true }; },
+    thresholdCount: 2, thresholdChars: 5000, delayMs: 0,
+    peakHours: "00:00-23:59", // 全天高峰：不设上限就会顺延到 23:59
+    peakMaxDeferMinutes: 120,
+    now: clock.now, setTimeoutFn: clock.setTimeoutFn, clearTimeoutFn: clock.clearTimeoutFn,
+    auditPeakSkip: () => {}
+  });
+  fill(service);
+  dream.maybeSchedule(service);
+  const t = clock.timers[0];
+  assert.equal(t.at, at(12, 0), "被上限截断到 120 分钟后（而不是等到 23:59）");
+  clock.setNow(t.at);
+  await t.fn();
+  assert.equal(runs, 1, "截断放行：仍在高峰也照跑，避免无限顺延");
+  store.close();
+});
+
+test("dreamPeakHours: 非法时段串按「未配置」处理（宁可不省，也不能误停）", async () => {
+  const { store, service } = dreamSetup();
+  const clock = fakeClock(at(10, 0));
+  let runs = 0;
+  let audits = 0;
+  const dream = createDreamScheduler({
+    onRun: async () => { runs++; return { ok: true }; },
+    thresholdCount: 2, thresholdChars: 5000, delayMs: 0,
+    peakHours: "10:00-99:00", // 非法：解析失败必须回落成「关闭」
+    now: clock.now, setTimeoutFn: clock.setTimeoutFn, clearTimeoutFn: clock.clearTimeoutFn,
+    auditPeakSkip: () => { audits++; }
+  });
+  fill(service);
+  assert.equal(dream.maybeSchedule(service), true, "非法串 = 未配置 → 走原有触发路径");
+  assert.equal(audits, 0, "不写 skip 审计");
+  const t = clock.timers[0];
+  clock.setNow(t.at);
+  await t.fn();
+  assert.equal(runs, 1, "巩固照常进行");
+  store.close();
+});
+
+test("dreamPeakHours: 非高峰时段不受影响（行为与现状一致）", async () => {
+  const { store, service } = dreamSetup();
+  const clock = fakeClock(at(20, 0)); // 本地 20:00，在 09:00-18:00 之外
+  let runs = 0;
+  const dream = createDreamScheduler({
+    onRun: async () => { runs++; return { ok: true }; },
+    thresholdCount: 2, thresholdChars: 5000, delayMs: 5,
+    peakHours: "09:00-18:00",
+    now: clock.now, setTimeoutFn: clock.setTimeoutFn, clearTimeoutFn: clock.clearTimeoutFn,
+    auditPeakSkip: () => { throw new Error("非高峰不该写 skip 审计"); }
+  });
+  fill(service);
+  assert.equal(dream.maybeSchedule(service), true, "非高峰照常排程");
+  const t = clock.timers[0];
+  assert.equal(t.at, at(20, 0) + 5, "走的是 delayMs 的「马上跑」路径，不是顺延路径");
+  clock.setNow(t.at);
+  await t.fn();
+  assert.equal(runs, 1);
+  store.close();
+});
+
+test("dreamPeakHours: dispose 清掉顺延定时器，进程关闭后不再触发巩固", async () => {
+  const { store, service } = dreamSetup();
+  const clock = fakeClock(at(10, 0));
+  let runs = 0;
+  const dream = createDreamScheduler({
+    onRun: async () => { runs++; return { ok: true }; },
+    thresholdCount: 2, thresholdChars: 5000, delayMs: 0,
+    peakHours: "09:00-18:00",
+    now: clock.now, setTimeoutFn: clock.setTimeoutFn, clearTimeoutFn: clock.clearTimeoutFn,
+    auditPeakSkip: () => {}
+  });
+  fill(service);
+  dream.maybeSchedule(service);
+  const t = clock.timers[0];
+  await dream.dispose();
+  assert.equal(clock.timers.length, 0, "顺延定时器已清");
+  clock.setNow(t.at);
+  await t.fn(); // 模拟「定时器已经进了事件队列，清不掉」的那一帧
+  assert.equal(runs, 0, "disposed 守卫拦住补跑");
+  store.close();
+});

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/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();
+});