sage-mem 1.9.0 → 1.9.2

package/README.md

@@ -12,7 +12,7 @@
 
 **Cross-session memory for DeepSeek Harness — plain markdown files, no database, no worker.**
 
-**Current release: `1.9.0`** — the npm badge above is the dynamic source of truth. **Contract baseline: `1.0.0`** — the first stable release, whose public commitments, the capability boundaries and the list of things it explicitly cannot do are frozen in the
+**Current release: `1.9.2`** — the npm badge above is the dynamic source of truth. **Contract baseline: `1.0.0`** — the first stable release, whose public commitments, the capability boundaries and the list of things it explicitly cannot do are frozen in the
 [frozen contract](https://github.com/gezi-wen/sage-mem/blob/main/docs/1.0.0-contract.md).
 
 If it is useful to you, a Star is the most direct feedback.
@@ -293,6 +293,9 @@ The guard has two paths, with **different** coverage, spelled out:
 | **The plugin itself** writing (autodream consolidation) | The caller passes the version it read at write time | A pending record `<state directory>/conflicts/<id>.json` is written, keeping **the version on disk** and **the version it wanted to write** — with only one side there is nothing to judge |
 
 - **Conflicts are not merged automatically**; which side to keep is your decision (the record is JSON, open it directly when you need to). Silent retry and silent abandonment both decide on your behalf.
+- **The injection side does not read this queue yet**: a memory with an unresolved conflict is still injected as body text. The `conflict_pending` suppression rule arrives with **2.0.0 conflict detection**, together with the panel entry that resolves conflicts — wiring the suppression without that entry would make a memory **permanently non-injectable**, which is worse than the current state. For now, open `conflicts/<id>.json` and set `status` to `resolved` or `dismissed` (or delete the file).
+- **The same conflict is not duplicated**: if a failure matches an unresolved record field for field (same file, both bodies, both versions), no extra copy is appended.
+- **The host file sandbox**: autodream runs **outside any session**, so it cannot inherit a session workspace. On a `workspace-write` host the plugin passes a per-call sandbox policy **narrowed to the memory directory** (narrower than the fallback root); on a `read-only` host it passes nothing, the write is still refused, and the run is recorded as a **failure** (not "success, nothing changed").
 - Known boundary: **editing memories in a shell does not go through this path**. The write gate guards "memory writes that go through the tools", not "all modifications to files"; redirection and the like inside `pwsh` are not recognized. If it cannot be sure, it does not claim it — so that "cannot see it" is not mistakenly recorded as fact.
 
 ### Access Ledger: Three Kinds of "Used" Recorded Separately
@@ -341,6 +344,14 @@ Consolidation is a background batch job and need not be the same model as the on
 - The panel always shows **which one is actually in effect**; if the route named in the configuration happens to disappear from the catalog, the dropdown still shows it rather than quietly jumping back to the default.
 - When the model catalog cannot be obtained (host differences), it degrades to typing `provider` and `model` by hand.
 
+### When the Report Does Not Fit
+
+The consolidation report is written by the model in one go, and a single output has a length cap. **The cap, the retry and the truncated label** all have defined behaviour:
+
+- **The single-output cap is configurable**: Settings → Autodream → Settings → Advanced → "single output cap" (default 32768 tokens, range 1024–131072). For reasoning models the reasoning and the body **share** that budget; when the closing turn spends it all on reasoning, no body is left — raise the cap and run again.
+- **Retry when the body is empty**: if an output hits the cap with **no body at all** (reasoning only), one retry asks for "the body directly, do not re-analyse"; up to 2 times, and only then is the report marked truncated. When there is a partial body, the loop asks it to continue from where it stopped (up to 3 rounds).
+- **Truncation is stated**: the report's first screen, the consolidation manifest, the machine-readable record and the Settings → Autodream "last run" line all say "report truncated (fragment)" — a half report is never reported as "success". If the closing step produced no text, the report says "the model gave no textual summary" instead of reusing narration from an earlier step.
+
 ### Rollback Points
 
 **Whenever this run is a "direct rewrite", a rollback point is created before work starts** (a full snapshot of the top-level `.md` files in the memory directory, each with a sha256), and after the run you can see it in the settings page and roll back to it in one click.
@@ -364,7 +375,7 @@ It records item by item: **file / operation (create · rewrite · archive) / rea
 
 1. **The safety boundary is in the tool set, not in the prompt** — during autodream the host gives the model only read-only tools, and only rewrite mode adds the rewriting tools; and **there is no "delete" capability at all** — archiving moves a file into `archive/`, recoverable by hand.
 2. **A rollback point is created automatically before rewriting**, under `<parent of the memory directory>/.sage-mem/autodream/snapshots/<runId>/`, keeping the most recent N. The reason: the memory directory is **not under any version control** and deletion has no recycle bin, so "rollback-ability" has to be built by hand.
-3. **An audit runs automatically at the end** — dangling index entries, missing index entries, `type` disagreeing with the file name prefix, CRLF, broken wikilinks, "space + #" swallowed as a YAML comment inside frontmatter, missing frontmatter, temporary files left behind by an interrupted archive, plus "unreadable" as a category of its own, and the result and the before/after comparison are written into the report. It **only reports, it does not change**.
+3. **An audit runs automatically at the end** — dangling index entries, missing index entries, `type` disagreeing with the file name prefix, CRLF, broken wikilinks, "space + #" swallowed as a YAML comment inside frontmatter, missing frontmatter, temporary files left behind by an interrupted archive, plus "unreadable" as a category of its own, and the result and the before/after comparison are written into the report. It **only reports, it does not change**. The index `MEMORY.md` is a list, not a memory, so it takes part in **neither** the "type vs prefix" check nor the "missing frontmatter" check (since 1.9.1).
 
 ### Rename Note
 

package/README.zh.md

@@ -14,7 +14,7 @@
 
 > File-based cross-session memory for DeepSeek Harness — every memory is a plain markdown file you can open, edit and delete. No database, no worker, no port.
 
-**当前发布版本：`1.9.0`** —— 顶部 npm 徽章是动态权威。**契约基线：`1.0.0`** —— 第一个稳定版，公开承诺、能力边界与「明确做不到」的清单冻结在
+**当前发布版本：`1.9.2`** —— 顶部 npm 徽章是动态权威。**契约基线：`1.0.0`** —— 第一个稳定版，公开承诺、能力边界与「明确做不到」的清单冻结在
 [契约冻结](https://github.com/gezi-wen/sage-mem/blob/main/docs/1.0.0-contract.md)。
 
 如果它对你有用，给个 Star 是最直接的反馈。
@@ -293,6 +293,9 @@ sage-mem 给记忆目录的写入加了**版本守卫**：写入前记下当前
 | **插件自己**写（自动做梦的整理） | 调用方在写入时带上读到的版本 | 落一条待处理记录 `<状态目录>/conflicts/<id>.json`，里面留着**盘上那一版**和**想要写的那一版** —— 只有一边等于没得判 |
 
 - **冲突不会自动合并**，保留哪边由你决定（记录是 JSON，需要时直接打开看）。静默重试和静默放弃都是在替你决定。
+- **注入侧目前不读这个队列**：有未裁决冲突的记忆照常作为正文注入；`conflict_pending` 这条抑制规则要等 **2.0.0 的矛盾检测**（连面板里的裁决入口一起）才生效 —— 只接抑制、不做入口，会让一条记忆**永久不再被注入**，比现在更糟。现阶段处理：打开 `conflicts/<id>.json`，把 `status` 改成 `resolved` 或 `dismissed`（或直接删掉文件）。
+- **同一件事不会越积越多**：一次失败如果与队列里某条未裁决记录逐字段相同（同一文件、两份正文、两个版本），不再追加副本。
+- **宿主的文件沙箱**：自动做梦在**会话外**运行，拿不到会话工作区。宿主用 `workspace-write` 时，插件给每次写入带上**收窄到记忆目录**的逐次沙箱策略（比回退根更窄）；宿主是 `read-only` 时不传策略、写入照旧被拒，且这一趟会被记成**失败**（不是「成功，没改什么」）。
 - 已知边界：**在 shell 里改记忆不走这条路**。写门守的是「经过工具的记忆写入」，不是「所有对文件的修改」；`pwsh` 里的重定向之类认不出来。认不准就不认，免得把「看不到」误记成事实。
 
 ### 访问台账：三种「用过」分开记
@@ -341,6 +344,14 @@ sage-mem 给记忆目录的写入加了**版本守卫**：写入前记下当前
 - 面板下方始终显示**实际生效的是哪条**；配置里那条路线万一从目录里消失了，下拉框也会把它显示出来而不是悄悄跳回默认。
 - 拿不到模型目录时（宿主差异），退化成手填 `provider` 与 `model`。
 
+### 报告写不完的时候
+
+整理报告由模型一口气写完，而单次输出有长度上限。**上限、重试、残篇标注**三件事都有明确行为：
+
+- **单次输出上限可配**：设置页「自动做梦 → 设置 → 高级设置 → 单次输出上限」（默认 32768 token，范围 1024–131072）。思考型模型的思考与正文**共用**这份额度；收尾那轮思考吃满时正文会一个字不剩 —— 这类报告先把上限调大再跑。
+- **零正文先重试**：一轮额度用尽却**没有任何正文**（只剩思考）时，先要求它「直接输出正文、不要重新分析」重试；最多 2 次，仍为零才标残篇。撞上限但**有正文**的，按「从中断处继续写」续写（最多 3 轮）。
+- **残篇会被指出来**：报告首屏、整理声明、机读记录与设置页「上次运行」那一行都会标「报告被截断（残篇）」—— 不会再把半篇报成「成功」。收尾那一步没写文字时，报告写「模型没有给出文字说明」，**不拿中途旁白顶替**。
+
 ### 回滚点
 
 **只要这次是「直接改写」，开工前就先建一个回滚点**（记忆目录顶层 `.md` 全量快照，每条带 sha256），跑完之后能在设置页看到它、也能一键退回去。
@@ -364,7 +375,7 @@ sage-mem 给记忆目录的写入加了**版本守卫**：写入前记下当前
 
 1. **安全边界在工具集上，不在提示词里** —— 自动做梦时宿主只把只读工具交给模型，改写模式才多给改写工具；而且**没有「删除」这个能力**，归档是把文件移进 `archive/`，可以人工捞回。
 2. **改写前自动建回滚点**，落在 `<记忆目录的上一层>/.sage-mem/autodream/snapshots/<runId>/`，保留最近 N 份。理由是记忆目录**不在任何版本控制下**、删除没有回收站，「可回滚」得自己造。
-3. **跑完自动审计** —— 索引悬空、漏索引、`type` 与文件名前缀不一致、CRLF、双链断链、frontmatter 里被 YAML 当注释吞掉的「空格 + #」、无 frontmatter、归档中途残留的临时文件，外加「读不动」单列一类，结果与前后对比写进报告。它**只报不改**。
+3. **跑完自动审计** —— 索引悬空、漏索引、`type` 与文件名前缀不一致、CRLF、双链断链、frontmatter 里被 YAML 当注释吞掉的「空格 + #」、无 frontmatter、归档中途残留的临时文件，外加「读不动」单列一类，结果与前后对比写进报告。它**只报不改**。索引 `MEMORY.md` 是清单而不是一条记忆，因此**不参与**「type 与前缀」和「无 frontmatter」这两项（1.9.1 起）。
 
 ### 改名说明
 

package/lib/autodream/audit.js

@@ -255,7 +255,16 @@ export async function auditMemoryDir(dir) {
       const meta = parseFrontmatterLite(raw)
       const prefix = f.split('_')[0]
       const effective = meta.type || 'reference'
-      if (effective !== prefix) {
+      /**
+       * ⚠️ **索引同样豁免「type 与前缀」这条**，与上面 `f !== INDEX_FILE` 是同一个理由。
+       *
+       * `MEMORY.md` 没有下划线，`f.split('_')[0]` 得到的就是整个 `MEMORY.md`；而历史版本的
+       * `write_memory` 硬要求内容以 frontmatter 开头，模型只好给索引补一个 `type: reference`
+       * —— 于是**每一个健康的记忆库都常驻一条**「type=reference 前缀=MEMORY.md」，把
+       * `problems` 这个唯一健康数字变成恒大于 0 的噪音（外部报告 2026-10-25 抓到）。
+       * 索引不是一条记忆，它没有「前缀」可言，这条检查对它不成立。
+       */
+      if (f !== INDEX_FILE && effective !== prefix) {
         typeMismatch.push({ file: f, type: meta.type || '(缺失)', prefix, effective })
       }
       for (const line of fmMatch[1].split(/\r?\n/)) {

package/lib/autodream/config.js

@@ -19,6 +19,16 @@ export const DEFAULT_CONFIG = {
   provider: '',
   model: '',
   maxSteps: 24,
+  /**
+   * 单次模型调用的输出上限（token）。
+   *
+   * ⚠️ 2026-10-26（1.9.2）从写死的 4096 提到 32768 并做成设置项。4096 对**思考型模型**
+   * 不够：思考与正文共用同一份额度，收尾那一轮里思考吃光额度、正文一个字都没剩下，
+   * 结果报告是残篇而面板报「成功」（2026-10-25 两趟手动整理连续复现）。
+   * 调大它不是治本（报告长度没有上界），治本是「零正文先重试、写不完才标残篇」；
+   * 做成设置项是为了让用户按自己模型的输出上限调，而不是每次为它改代码。
+   */
+  maxOutputTokens: 32768,
   maxSnapshotKeep: 5,
   /** 回滚按钮的默认范围：files = 只恢复该次运行动过的文件；all = 整目录恢复到该时点。 */
   rollbackScope: 'files',

package/lib/autodream/engine.js

@@ -49,6 +49,31 @@ import * as rollbackMod from './rollback.js'
 import * as settingsMod from './settings.js'
 import * as snapshotMod from './snapshot.js'
 
+/**
+ * 一趟整理的结果该怎么定性（纯函数，`run()` 与单测共用这一份判据）。
+ *
+ * 单纯「有写入被沙箱拒绝」不是失败 —— 其余文件可能照样改成功了，那时该算成功，
+ * 被拒的几次由整理声明里的 warnings 交代。但**一次改动都没有、却有拒绝**就是失败：
+ * 那是空转，报成成功会让用户以为「整理过了，没需要改的」。
+ *
+ * 为什么抽出来：`run()` 那条路径要 llm 与真实磁盘才跑得动，判据本身却只是三行逻辑；
+ * 不抽出来的话，这条最要紧的修复只能靠源码级断言看着。
+ *
+ * @param {{apply?:boolean, changeCount?:number, denials?:Array<{message?:string}>}} input
+ * @returns {{allDenied:boolean, error:string}}
+ */
+export function judgeWriteOutcome(input) {
+  const i = input && typeof input === 'object' ? input : {}
+  const denials = Array.isArray(i.denials) ? i.denials : []
+  const allDenied = i.apply === true && Number(i.changeCount) === 0 && denials.length > 0
+  return {
+    allDenied,
+    error: allDenied
+      ? `本次 ${denials.length} 次写入全部被宿主文件沙箱拒绝，没有改动任何文件：${denials[0]?.message ?? ''}`
+      : '',
+  }
+}
+
 export class AutodreamEngine {
   /**
    * @param {object} ctx — 插件上下文（Cordis）
@@ -291,6 +316,7 @@ export class AutodreamEngine {
         auditAfter,
         finalText: result.finalText,
         continuations: result.continuations,
+        retries: result.retries,
         truncated: result.truncated,
         archiveMode: policy.mode,
         archiveRequested: policy.requested,
@@ -319,6 +345,7 @@ export class AutodreamEngine {
         auditAfter,
         finalText: result.finalText,
         continuations: result.continuations,
+        retries: result.retries,
         truncated: result.truncated,
         transcript: result.transcript,
         tokensIn: result.tokensIn,
@@ -331,12 +358,28 @@ export class AutodreamEngine {
         archiveDegraded: policy.degraded,
       })
 
+      /**
+       * 「有写入被沙箱拒绝」不等于「这一趟失败」，但**「所有写入都被拒绝、零改动」就是失败**。
+       *
+       * 原先这条路无条件写 `ok: true`：报告上写「成功，没改什么」，用户看到的是
+       * 一次空转被当成一次成功的整理 —— 外部报告 2026-10-25（issue #6）点的正是这里。
+       * 有部分改动时仍算成功：改动确实落地了，被拒的几次由整理声明的 warnings 交代。
+       */
+      const judged = judgeWriteOutcome({
+        apply: !!cfg.apply,
+        changeCount: result.changes.length,
+        denials: typeof runner?.denials === 'function' ? runner.denials() : [],
+      })
+      const allWritesDenied = judged.allDenied
+      const deniedError = judged.error
+
       this.state.lastRunAt = Date.now()
       this.state.retryAfter = 0
       this.state.lastResult = {
         at: this.state.lastRunAt,
         atHuman: stampHuman(this.state.lastRunAt),
-        ok: true,
+        ok: !allWritesDenied,
+        ...(allWritesDenied ? { error: deniedError } : {}),
         runId,
         apply: !!cfg.apply,
         touched: result.touched,
@@ -347,6 +390,7 @@ export class AutodreamEngine {
         tokensOut: result.tokensOut,
         // 残篇要能在界面上被认出来（面板读 lastResult）：只报「成功」是不够的。
         continuations: result.continuations,
+        retries: result.retries,
         truncated: result.truncated,
         report: report.name,
         snapshotId: snapshot?.id ?? null,
@@ -354,13 +398,15 @@ export class AutodreamEngine {
       await this.persist()
       this.phase = ''
       return {
-        ok: true,
+        ok: !allWritesDenied,
+        ...(allWritesDenied ? { error: deniedError } : {}),
         runId,
         report: report.name,
         touched: result.touched,
         changeCount: result.changes.length,
         snapshotId: snapshot?.id ?? null,
         continuations: result.continuations,
+        retries: result.retries,
         truncated: result.truncated,
         auditBefore,
         auditAfter,

package/lib/autodream/llm-loop.js

@@ -151,18 +151,42 @@ export async function streamOnce(llm, req) {
 }
 
 /**
- * 一次模型调用的输出上限。
+ * 一次模型调用的输出上限（配置缺字段 / 坏值时的回落值）。
  *
  * ⚠️ **调大它解决不了「长报告被截断」**：报告长度没有上界，调大只是把墙往后挪一格
  * （2026-10-17 实测：10-01 的报告 5532 字符、10-13 是 5957，都完整收尾；这次 8553 字符
  * 就断在半个句子里）。真正的处理是撞上它时**接着写** —— 见下面的 MAX_CONTINUATIONS。
+ *
+ * 但 4096 对**思考型模型**连「把收尾那一轮写完」都不够：思考与正文共用额度，
+ * 2026-10-25 两趟手动整理都在最后一步思考吃光额度、正文零字（1.9.2 改成可配置，默认 32768）。
  */
-const MAX_TOKENS_PER_CALL = 4096
+const FALLBACK_MAX_TOKENS = 32768
+
+/** 配置里的单次输出上限。缺字段（老配置 / 测试桩）或坏值都回落到常量。 */
+export function resolveMaxTokens(cfg) {
+  const n = Number(cfg?.maxOutputTokens)
+  return Number.isFinite(n) && n >= 1024 ? Math.round(n) : FALLBACK_MAX_TOKENS
+}
+
 /** 撞上单次上限后最多续写几轮：够把最后一段写完，又不至于让一次跑飞掉。 */
 const MAX_CONTINUATIONS = 3
+/**
+ * 「零正文截断」最多重试几次（1.9.2）。
+ *
+ * 零正文不是「这段写完了」，而是**思考把额度吃光了**：直接标残篇会让一次本来能写完的报告
+ * 白丢。先重试一次「直接输出正文、不要重新分析」；仍为零才标残篇。
+ * 上限 2：思考型模型可能连续两轮都只顾着思考，再多就是拿 token 赌运气。
+ */
+const MAX_EMPTY_RETRIES = 2
 /** 续写指令。三条禁令缺一不可 —— 重写整篇 / 重新开头 / 道歉寒暄，模型都干得出来。 */
 const CONTINUE_PROMPT =
   '（上一条回答被输出长度上限截断了。请**从中断处继续写**，不要重复已经写过的内容，不要重新开头，不要解释或道歉，直接接着写。）'
+/**
+ * 零正文重试指令。与 CONTINUE_PROMPT 的区别：**没有「已写内容」可续**，
+ * 上一轮只有思考。所以这里要压住「再分析一遍」的冲动，只要正文。
+ */
+const EMPTY_RETRY_PROMPT =
+  '（上一条回答把输出额度全用在思考上了，最终没有任何正文。请**直接输出正文**：不要再重新分析、不要重复思考过程、不要解释，直接给出这一轮要交付的内容。）'
 
 /** 取这一次调用里的全部文字块，拼成一段。 */
 function textOf(asm) {
@@ -206,8 +230,12 @@ export async function agentLoop(cfg, runOpts) {
   // 截断与续写的账：`continuations` 是「确实接着写过几轮」，`truncated` 是「续写用尽还是没写完」。
   // 两个都要进声明与报告 —— 「报告是残篇却报成功」正是这一版要修的那处静默。
   let continuations = 0
+  /** 零正文重试的账（1.9.2）：与「续写」分开记 —— 一个是接着写，一个是根本没写出来。 */
+  let retries = 0
   let truncated = false
   let lastStep = 0
+  // 每次调用都从这里取上限：配置改了不用重启（下一趟就用新值），老配置缺字段也能跑。
+  const maxTokensPerCall = resolveMaxTokens(cfg)
   const allToolsUsed = []
   const addUsage = (u) => {
     if (!u) return
@@ -228,7 +256,7 @@ export async function agentLoop(cfg, runOpts) {
       system,
       messages,
       tools: toolSchemas,
-      maxTokens: MAX_TOKENS_PER_CALL,
+      maxTokens: maxTokensPerCall,
       signal,
     })
     addUsage(asm.usage)
@@ -237,30 +265,64 @@ export async function agentLoop(cfg, runOpts) {
     let text = ''
     let calls = []
     let segment = 0
+    /** 下一段是不是「零正文重试」来的 —— 只影响过程清单上的标记。 */
+    let retryNext = false
     for (;;) {
+      const isRetry = retryNext
+      retryNext = false
       const segText = textOf(asm)
       const blocks = asm.blocks()
       const segCalls = blocks.filter((b) => b.type === 'tool-call')
       // 只有第一段可能带工具调用：被截断时 BlockAssembler 已经丢掉了参数残缺的 tool-call。
       if (segment === 0) calls = segCalls
       text += segText
+      const segMark = segment === 0 ? {} : isRetry ? { retry: true } : { continuation: true }
       transcript.push({
         step,
         text: segText,
         tools: segCalls.map((c) => c.name),
-        ...(segment ? { continuation: true } : {}),
+        ...segMark,
       })
       this.stepLog.push({
         step,
         tools: segCalls.map((c) => c.name),
         chars: segText.length,
         at: Date.now(),
-        ...(segment ? { continuation: true } : {}),
+        ...segMark,
       })
       segment += 1
       if (asm.finish.kind !== 'max-tokens') break
-      // 空段没法接着写；续写名额用尽也一样 —— 两种都算「这篇没写完」，要如实记下来。
-      if (!segText || continuations >= MAX_CONTINUATIONS) {
+      /**
+       * 零正文的截断：不是「这段写完了」，而是**思考把额度吃光了**（思考型模型常见）。
+       * 1.9.2 起先重试「直接输出正文」；重试用尽仍无正文才标残篇。
+       * 旧行为（1.0.1）是直接标残篇 —— 那会让一次本来能写完的报告白丢一段收尾。
+       */
+      if (!segText) {
+        if (retries >= MAX_EMPTY_RETRIES) {
+          truncated = true
+          break
+        }
+        retries += 1
+        // 把这一轮原样回灌（通常只有 reasoning 块）：让模型看到它上一轮只思考、没交付。
+        // 完全空的 blocks 不回灌 —— 空的 assistant 消息不是合法输入，宁可不给。
+        if (blocks.length) messages.push(assistantMessage(blocks, provider, model))
+        messages.push(userMessage(EMPTY_RETRY_PROMPT))
+        retryNext = true
+        this.phase = `第 ${step} 轮：零正文被截断，重试直接输出正文 ${retries}/${MAX_EMPTY_RETRIES}`
+        asm = await this.streamOnce(llm, {
+          provider,
+          model,
+          system,
+          messages,
+          tools: toolSchemas,
+          maxTokens: maxTokensPerCall,
+          signal,
+        })
+        addUsage(asm.usage)
+        continue
+      }
+      // 有正文但被截断：接着写。名额用尽就如实标残篇。
+      if (continuations >= MAX_CONTINUATIONS) {
         truncated = true
         break
       }
@@ -274,13 +336,15 @@ export async function agentLoop(cfg, runOpts) {
         system,
         messages,
         tools: toolSchemas,
-        maxTokens: MAX_TOKENS_PER_CALL,
+        maxTokens: maxTokensPerCall,
         signal,
       })
       addUsage(asm.usage)
     }
 
-    if (text) finalText = text
+    // ④ **每一步都覆盖**（不是「有字才覆盖」）：最后一步零正文时，收尾说明必须留空，
+    // 不能把中途某轮的旁白当成「模型的收尾说明」写进报告（2026-10-25 残篇报告的伴随症状）。
+    finalText = text
     if (asm.finish.kind === 'error') {
       throw new Error(`模型返回错误：${asm.finish.failure?.message ?? '未知'}`)
     }
@@ -308,9 +372,10 @@ export async function agentLoop(cfg, runOpts) {
 
   if (truncated) {
     // 过程清单要以「没写完」收尾：否则报告里那半句话看起来只是模型话说到一半。
+    const retryNote = retries ? `（其中零正文重试 ${retries} 次）` : ''
     transcript.push({
       step: lastStep,
-      text: `（输出撞上单次长度上限，续写 ${continuations} 轮后仍未写完 —— 上面这段是残篇，后文缺失）`,
+      text: `（输出撞上单次长度上限，续写 ${continuations} 轮${retryNote}后仍未写完 —— 上面这段是残篇，后文缺失）`,
       tools: [],
     })
   }
@@ -321,6 +386,8 @@ export async function agentLoop(cfg, runOpts) {
     tokensIn,
     tokensOut,
     continuations,
+    /** 零正文重试次数（1.9.2）：进报告与机读记录，让「重试过」和「一次写成」分得开。 */
+    retries,
     truncated,
     toolsUsed: allToolsUsed,
     touched: runner.touchedFiles(),

package/lib/autodream/report.js

@@ -57,6 +57,8 @@ export async function writeDeclaration(payload) {
     finalText: payload.finalText ?? '',
     // 1.0.1：输出撞上单次上限这件事要进机读记录 —— 残篇在界面上和「话说一半」长得一模一样。
     continuations: Number(payload.continuations) || 0,
+    // 1.9.2：零正文重试是另一本账 —— 「接着写过」与「根本没写出来」不能混成一个数字。
+    retries: Number(payload.retries) || 0,
     truncated: payload.truncated === true,
     rolledBackAt: 0,
     rolledBackAtHuman: '',
@@ -79,10 +81,14 @@ export function renderDeclaration(m, headingLevel = 1) {
       : '- 回滚点：未做（只出报告模式不写盘，无需回滚）',
     `- 审计：结构问题 ${m.audit.before.problems} → ${m.audit.after.problems}`,
     ...(m.truncated
-      ? [`- ⚠️ 输出被单次长度上限截断：续写 ${m.continuations ?? 0} 轮后仍未写完，收尾说明是**残篇**`]
-      : m.continuations
-        ? [`- 输出曾撞上单次长度上限，已自动续写 ${m.continuations} 轮补齐`]
-        : []),
+      ? [
+          `- ⚠️ 输出被单次长度上限截断：续写 ${m.continuations ?? 0} 轮${m.retries ? `、零正文重试 ${m.retries} 次` : ''}后仍未写完，收尾说明是**残篇**`,
+        ]
+      : m.retries
+        ? [`- 输出曾出现零正文截断（思考吃满额度），重试 ${m.retries} 次后补齐`]
+        : m.continuations
+          ? [`- 输出曾撞上单次长度上限，已自动续写 ${m.continuations} 轮补齐`]
+          : []),
     '',
     `${H}# 改了什么、为什么`,
     '',
@@ -213,12 +219,15 @@ export async function writeReport(payload) {
    */
   const truncLines = payload.truncated
     ? [
-        `- ⚠️ **本次输出被单次长度上限截断**：自动续写 ${payload.continuations ?? 0} 轮后仍未写完 —— ` +
+        `- ⚠️ **本次输出被单次长度上限截断**：自动续写 ${payload.continuations ?? 0} 轮` +
+          `${payload.retries ? `、零正文重试 ${payload.retries} 次` : ''}后仍未写完 —— ` +
           '下面「模型的收尾说明」是**残篇**，后文缺失',
       ]
-    : payload.continuations
-      ? [`- 输出曾撞上单次长度上限，已自动续写 ${payload.continuations} 轮补齐（报告完整）`]
-      : []
+    : payload.retries
+      ? [`- 输出曾出现零正文截断（思考吃满额度），重试 ${payload.retries} 次后补齐（报告完整）`]
+      : payload.continuations
+        ? [`- 输出曾撞上单次长度上限，已自动续写 ${payload.continuations} 轮补齐（报告完整）`]
+        : []
 
   const lines = [
     `# Autodream 报告 · ${stampHuman(payload.startedAt)}`,
@@ -257,8 +266,9 @@ export async function writeReport(payload) {
     '## 过程',
     '',
     ...payload.transcript.map((t) => {
-      // 「续写」必须标出来：否则同一轮出现好几条，读起来像模型重复劳动。
-      const mark = t.continuation ? '（截断续写）' : ''
+      // 「续写」与「零正文重试」都必须标出来：否则同一轮出现好几条，读起来像模型重复劳动。
+      // 两者分开标 —— 一个是「接着写」，一个是「上一段根本没写出来」，读者要看得出区别。
+      const mark = t.retry ? '（零正文重试）' : t.continuation ? '（截断续写）' : ''
       const kind = t.tools.length ? `：调用 ${t.tools.join('、')}` : '：结束'
       // ⚠️ **先压平空白再截断**。模型这一步的文字里常带换行与 `## 标题`，直接 slice(0,120)
       // 会把标题漏成真标题 —— 报告读起来像「内容重复了一遍」（2026-10-17 10:42 那次真踩到：

package/lib/autodream/settings.js

@@ -99,6 +99,12 @@ export async function setConfig(patch) {
   if (p.minHours !== undefined) c.minHours = clampNum(Number(p.minHours), 1, 720, DEFAULT_CONFIG.minHours)
   if (p.minSessions !== undefined) c.minSessions = Math.round(clampNum(Number(p.minSessions), 1, 200, DEFAULT_CONFIG.minSessions))
   if (p.maxSteps !== undefined) c.maxSteps = Math.round(clampNum(Number(p.maxSteps), 1, 80, DEFAULT_CONFIG.maxSteps))
+  /**
+   * 单次输出上限（1.9.2）。范围 1024–131072：下限够小、上限够到大多数模型的硬顶；
+   * 越界按统一口径**夹到合法范围**，不写一份坏配置。
+   */
+  if (p.maxOutputTokens !== undefined)
+    c.maxOutputTokens = Math.round(clampNum(Number(p.maxOutputTokens), 1024, 131072, DEFAULT_CONFIG.maxOutputTokens))
   if (p.maxSnapshotKeep !== undefined)
     c.maxSnapshotKeep = Math.round(clampNum(Number(p.maxSnapshotKeep), 1, 50, DEFAULT_CONFIG.maxSnapshotKeep))
   if (typeof p.provider === 'string') c.provider = p.provider.trim().slice(0, 120)

package/lib/autodream/tools.js

@@ -33,7 +33,7 @@ import { MAX_FILE_BYTES, STATE_ROOT } from '../memory/config.js'
 import { INDEX_FILE_KEY, SESSION_LOG_KEY } from '../shared/md-name.js'
 import { stampHuman as localStamp } from '../shared/stamp.js'
 import { writeFileAtomic, warnLog } from '../memory/util.js'
-import { buildConflict, writeConflict } from '../memory/conflicts.js'
+import { buildConflict, listConflicts, writeConflict } from '../memory/conflicts.js'
 import { memoryPathOf } from '../memory/paths.js'
 import { decideWriteIntent } from '../memory/write-gate.js'
 import { inspectMemoryEntry, reservedIdentitySet } from '../memory/scan.js'
@@ -368,7 +368,10 @@ export function autodreamToolSchemas(opts) {
           type: 'object',
           properties: {
             file: str('记忆文件名，例如 project_example.md'),
-            content: str('完整文件内容，必须以 --- 开头的 YAML frontmatter 起始'),
+            content: str(
+              '完整文件内容，必须以 --- 开头的 YAML frontmatter 起始。**唯一的例外是索引 `MEMORY.md`**：' +
+                '它是一份清单、不是一条记忆，没有 type / 前缀，直接写正文（`- [标题](文件.md) — 一句话`）即可，不要给它补 frontmatter。',
+            ),
             reason: str(
               '强烈建议填。一句话说清为什么改这条、改了什么（例如「合并了重复的部署记录，删掉被推翻的旧路径」）。' +
                 '缺了**不会**被拒绝——改动照样生效——但整理声明会把这条标成「未自述」，用宿主能追溯到的信息' +
@@ -433,6 +436,14 @@ export function createToolRunner(opts) {
   const changes = []
   /** 被拒绝的写操作（归档没给 reason 之类）：**改动没有发生**，声明里单列一节。 */
   const warnings = []
+  /**
+   * 被**宿主文件沙箱**拒绝的写入（与「模型没给 reason」这类被拒分开记）。
+   *
+   * 为什么单列：这类失败不是模型写错了，是**环境不允许**——把它混进 warnings 只能让人
+   * 以为「某次写入没成功」，而真正要回答的问题是「这一趟到底有没有落地任何东西」。
+   * 上层（`engine.js`）靠它把「零改动的假成功」判成失败（外部报告 2026-10-25 抓到）。
+   */
+  const denials = []
   /**
    * 提示（advisory）：**改动发生了**，只是有话要说（例如模型没自述缘由）。
    *
@@ -530,6 +541,67 @@ export function createToolRunner(opts) {
     }
   }
 
+  /**
+   * 这一次写入该带上的**逐次沙箱策略**（宿主 `fs.writeText` 的第 5 个参数）。
+   *
+   * 为什么必须有（外部报告 2026-10-25，issue #6）：autodream **刻意不在会话里跑**
+   * （见 README「整理刻意不走会话」），所以永远没有 `session.cwd` 可以继承。宿主的
+   * `sandboxPolicy.resolve()` 在没有 session 时退到**部署回退根**（配置的 workspaceRoot，
+   * 缺省 `process.cwd()`）；而 workspace-write 的可写根只有那个根 + 临时区。于是
+   * 默认记忆目录 `~/.sage-mem/memory` 必然落在根外 → **每一次写入都被围栏拒绝**，
+   * 和宿主怎么配无关，是这条路径的结构性缺口。
+   *
+   * 传 `{ mode: 'workspace-write', workspaceRoot: memoryDir }` 把可写根**收窄到记忆目录**
+   * （比回退根更窄，不是更宽），让「插件写自己的数据目录」这件事成立。
+   *
+   * 三条边界，每一条都是刻意的：
+   *   - `read-only` **原样尊重**：只读是用户此刻的选择，不由后台整理替它翻案；
+   *     这时不传策略，宿主照旧拒绝，失败会如实上报（见下面 `denials`）。
+   *   - `danger-full-access` 本来就不围栏，传了也没意义。
+   *   - 拿不到 `sandboxPolicy` 服务（老宿主 / 测试假 ctx）就**不传**，退回宿主默认行为，
+   *     与改动前逐字一致。
+   *
+   * @returns {{mode:string, workspaceRoot:string}|undefined}
+   */
+  function writeSandboxPolicy() {
+    try {
+      const sp = typeof ctx?.get === 'function' ? ctx.get('sandboxPolicy') : undefined
+      if (!sp || typeof sp.resolve !== 'function') return undefined
+      const policy = sp.resolve()
+      if (!policy || policy.mode !== 'workspace-write') return undefined
+      return { mode: 'workspace-write', workspaceRoot: memoryDir }
+    } catch {
+      return undefined
+    }
+  }
+
+  /** 记一次「宿主沙箱拒绝写入」。调用点只有 `writeMemoryText` 的 catch —— 别在别处重复记。 */
+  function recordSandboxDenial(fullPath, err) {
+    const file = basename(fullPath)
+    const message = String(err?.message ?? err)
+    denials.push({ file, code: String(err?.code ?? ''), message })
+    // 同时进 warnings：整理声明里原本就有「未能落地的改动」一节，别让这类失败只活在内存里。
+    warnings.push(`写入 ${file} 被宿主文件沙箱拒绝：${message}`)
+    warnLog(ctx, `写入被沙箱拒绝：${file}: ${message}`)
+  }
+
+  /**
+   * 沙箱拒绝时给模型的**一句话出路**。
+   *
+   * 原样回一句 `access denied` 的话，模型只会换个文件名反复重试；而人读 transcript 时
+   * 也看不出该去改什么配置。这句提示只说明「这是环境问题、该改哪里」，绝不暗示
+   * 「换个方式绕过围栏」—— 那会把一次功能故障变成一次安全边界失效。
+   */
+  function sandboxDenialHint(err) {
+    if (err?.code !== 'FS_SANDBOX_DENIED') return ''
+    return (
+      '（这次写入被宿主文件沙箱拒绝，与文件名、内容都无关。自动做梦在会话外运行，' +
+      '拿不到会话的工作区：宿主是 read-only 时这是预期行为；是 workspace-write 时，' +
+      '请把记忆目录放进宿主的 workspaceRoot，或给 @deepseek-ai/dsh-sandbox-policy 配置 workspaceRoot。' +
+      '不要用其它方式绕过围栏。）'
+    )
+  }
+
   /**
    * 把一次「版本过期」落成一条**待人工判定**的冲突记录。
    *
@@ -559,12 +631,44 @@ export function createToolRunner(opts) {
         tool: 'write_memory',
         at: new Date().toISOString(),
       })
+      // 同一件事只留一条：否则每一趟重试都会给队列添一份副本（见 hasSameOpenConflict）。
+      if (await hasSameOpenConflict(record)) return
       await writeConflict(record, { stateRoot: STATE_ROOT })
     } catch (conflictErr) {
       warnLog(ctx, `冲突记录没写下来（写入失败的原因不受影响）：${conflictErr?.message ?? conflictErr}`)
     }
   }
 
+  /**
+   * 队列里是否已有一条**完全同一件事**的未裁决记录。
+   *
+   * 为什么需要（外部报告 2026-10-25，issue #7）：记录的 id 带着 `at` 的时间戳前缀
+   * （见 `buildConflict`），而「模型每一趟都试图覆盖一份它没读过的记忆」是**结构性**的
+   * —— 每一趟都会生成新 id，于是 `conflicts/` 只增不减，而其中绝大多数是同一件事的副本。
+   *
+   * 判据是**逐字段相等**（kind / file / 两份正文 / 两个版本）：任何一处不同都算另一件事，
+   * 仍然是两条独立记录 —— 去重只跳过重复，不做「合并」，更不做裁决。
+   * 读队列失败一律当作「没有重复」：去重是省磁盘的优化，不能因为读不动就连该留的记录也不留。
+   */
+  async function hasSameOpenConflict(record) {
+    try {
+      const listed = await listConflicts({ stateRoot: STATE_ROOT })
+      if (!listed.ok) return false
+      return listed.items.some(
+        (c) =>
+          c.status === 'open' &&
+          c.kind === record.kind &&
+          c.file === record.file &&
+          c.expectedVersion === record.expectedVersion &&
+          c.actualVersion === record.actualVersion &&
+          c.incoming === record.incoming &&
+          c.onDisk === record.onDisk,
+      )
+    } catch {
+      return false
+    }
+  }
+
   /**
    * 把内容写进一条记忆文件。
    *
@@ -603,12 +707,15 @@ export function createToolRunner(opts) {
       throw Object.assign(new Error(guard.why), { code: 'SAGE_MEM_UNVERIFIED_OVERWRITE' })
     }
     try {
-      return await fs.writeText(target, content, guard.expected)
+      // 第 4 个参数是 abort signal（这里不用）；第 5 个是逐次沙箱策略 —— 见 writeSandboxPolicy。
+      return await fs.writeText(target, content, guard.expected, undefined, writeSandboxPolicy())
     } catch (err) {
       // 版本过期不是「写失败」，是**一次待判定的冲突**：有人在我们读入之后改过这份记忆。
       // 落一条记录（保留哪边由人决定），然后**照旧把错误抛出去** ——
       // 静默重试或静默放弃都是在替用户做决定。
       if (err?.code === 'FS_STALE_VERSION') await recordStaleConflict(fullPath, content, err)
+      // 沙箱拒绝是环境故障：记下来，让上层别把「零改动」报成成功。
+      if (err?.code === 'FS_SANDBOX_DENIED') recordSandboxDenial(fullPath, err)
       throw err
     }
   }
@@ -647,6 +754,13 @@ export function createToolRunner(opts) {
     warnings() {
       return [...warnings]
     },
+    /**
+     * 被**宿主文件沙箱**拒绝的写入（环境故障，不是模型写错）。
+     * 上层用「有拒绝 + 零改动」把空转判成失败，别只靠 warnings 里的一句话。
+     */
+    denials() {
+      return denials.map((d) => ({ ...d }))
+    },
     /** 提示（改动发生了，但有话要说）。 */
     notes() {
       return [...notes]
@@ -715,7 +829,17 @@ export function createToolRunner(opts) {
             // 文件级回滚就找不到原版（RB-9）。
             const full = join(memoryDir, await resolveRealName(memoryDir, basename(validated)))
             if (typeof a.content !== 'string' || !a.content.trim()) return '错误：content 为空。'
-            if (!/^---\r?\n/.test(a.content)) {
+            /**
+             * 索引 `MEMORY.md` **不要求 frontmatter**（外部报告 2026-10-25，issue #8）。
+             *
+             * 索引是一份清单、不是一条记忆：它没有 `type`，也没有能对上的文件名前缀。
+             * 硬要求 frontmatter 只会让模型为了「能写进去」给它编一个 `type: reference`，
+             * 而体检随后按「type 与前缀不一致」报警 —— 一个纯粹的假阳性，而且是常驻的。
+             * 手动入口（面板「建立索引骨架」）写出来的骨架本来也没有 frontmatter，
+             * 两条写入路径不该对同一个文件给出两套规矩。
+             */
+            const isIndex = basename(full).toLowerCase() === INDEX_FILE_KEY
+            if (!isIndex && !/^---\r?\n/.test(a.content)) {
               return '错误：内容必须以 `---` 开头的 YAML frontmatter 起始。参考 list_memory 里已有文件的写法。'
             }
             /**
@@ -798,7 +922,7 @@ export function createToolRunner(opts) {
             return `错误：没有这个工具：${name}`
         }
       } catch (err) {
-        return `工具执行失败：${err?.message ?? String(err)}`
+        return `工具执行失败：${err?.message ?? String(err)}${sandboxDenialHint(err)}`
       }
     },
   }

package/lib/client.js

@@ -3954,6 +3954,10 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 										" · 结构问题 " + last.problemsBefore + " → " + last.problemsAfter +
 										" · token " + last.tokensIn + " / " + last.tokensOut)
 									: ("失败：" + (last.error || "未知"))) +
+								// 1.9.2：残篇必须在状态行上就能看见 —— 只写「成功」正是 10-25 那次误判的来源。
+								(last.ok && last.truncated ? " · ⚠ 报告被截断（残篇）" : "") +
+								(last.ok && !last.truncated && last.retries ? (" · 零正文重试 " + last.retries + " 次后补齐") : "") +
+								(last.continuations ? (" · 续写 " + last.continuations + " 轮") : "") +
 								(last.report ? " · 报告 " + last.report : ""))
 						: null,
 				]),
@@ -4068,6 +4072,12 @@ h("span", { key: "sep", className: "smem-actions-sep", "aria-hidden": "true" }),
 							h("input", { className: "smem-num", key: "v", type: "number", min: "1", max: "80", value: c.maxSteps, onChange: function (e) { patch({ maxSteps: Number(e.target.value) }); } }),
 							h("span", { className: "smem-status", key: "s" }, "一轮 = 一次模型调用 + 它要的工具调用"),
 						]),
+						// 1.9.2：单次输出上限（原写死 4096）。思考型模型下 4096 会让收尾轮只剩思考、零正文。
+						h("div", { className: "smem-autodream-row", key: "maxout" }, [
+							h("span", { className: "smem-autodream-key", key: "k" }, "单次输出上限"),
+							h("input", { className: "smem-num", key: "v", type: "number", min: "1024", max: "131072", value: c.maxOutputTokens, onChange: function (e) { patch({ maxOutputTokens: Number(e.target.value) }); } }),
+							h("span", { className: "smem-status", key: "s" }, "token（思考与正文共用；报告残篇时先调它）"),
+						]),
 						h("div", { className: "smem-autodream-row", key: "keep" }, [
 							h("span", { className: "smem-autodream-key", key: "k" }, "保留快照"),
 							h("input", { className: "smem-num", key: "v", type: "number", min: "1", max: "50", value: c.maxSnapshotKeep, onChange: function (e) { patch({ maxSnapshotKeep: Number(e.target.value) }); } }),

package/lib/typert.host.js

@@ -307,6 +307,8 @@ const autodreamConfigSchema = z.object({
 	'provider': z.string().readonly(),
 	'model': z.string().readonly(),
 	'maxSteps': z.number().readonly(),
+	// 1.9.2：单次输出上限（token）。响应与 patch 两侧都必须声明 —— strict codec 会剥掉未声明字段。
+	'maxOutputTokens': z.number().readonly(),
 	'maxSnapshotKeep': z.number().readonly(),
 	'rollbackScope': z.string().readonly(),
 	/**
@@ -414,6 +416,7 @@ const autodreamPatchSchema = z.object({
 	'provider': z.string().optional(),
 	'model': z.string().optional(),
 	'maxSteps': z.number().optional(),
+	'maxOutputTokens': z.number().optional(),
 	'maxSnapshotKeep': z.number().optional(),
 	'rollbackScope': z.string().optional(),
 	/**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sage-mem",
   "description": "Cross-session memory for DeepSeek Harness — plain markdown files, no database, no worker.",
-  "version": "1.9.0",
+  "version": "1.9.2",
   "type": "module",
   "main": "lib/index.js",
   "icon": "./icon.png",