sage-mem 1.8.2 → 1.9.1

package/README.md

@@ -12,7 +12,7 @@
 
 **Cross-session memory for DeepSeek Harness — plain markdown files, no database, no worker.**
 
-**Current release: `1.8.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
+**Current release: `1.9.1`** — 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.
@@ -164,6 +164,8 @@ The state directory (configuration, ledger, rollback points, conflict queue) def
 
 Every image below is **rendered from the UI code in this repository** (the same CSS, the same component tree; the data is demo data for illustration, not a real memory directory).
 
+Since 1.9.0 the memory-management surface follows the harness language (**Settings → General → Language**); memory content itself stays in whatever language it was written in, and the remaining panels (autodream, archive, starmap, audit) are still Chinese until the next i18n batch.
+
 ![File list: one Markdown file per memory, greyed rows are archived](https://raw.githubusercontent.com/gezi-wen/sage-mem/main/docs/images/files-list.png)
 
 *File list — the header always shows 「体检 N 个问题」(audit: N issues) and 「待重启生效」(restart to apply), so you know whether you should deal with it without opening anything; greyed rows are archived and can be restored at any time, or deleted for good with 「彻底删除」(irreversible, asks once more).*
@@ -291,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 **1.10.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
@@ -362,7 +367,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.8.2`** —— 顶部 npm 徽章是动态权威。**契约基线：`1.0.0`** —— 第一个稳定版，公开承诺、能力边界与「明确做不到」的清单冻结在
+**当前发布版本：`1.9.1`** —— 顶部 npm 徽章是动态权威。**契约基线：`1.0.0`** —— 第一个稳定版，公开承诺、能力边界与「明确做不到」的清单冻结在
 [契约冻结](https://github.com/gezi-wen/sage-mem/blob/main/docs/1.0.0-contract.md)。
 
 如果它对你有用，给个 Star 是最直接的反馈。
@@ -164,6 +164,8 @@ SAGE_MEM_DIR=/path/to/your/memory
 
 下面每张图都是**从仓库里的界面代码渲染出来的**（同一份 CSS、同一棵组件树；数据是演示用的假数据，不是真实记忆目录）。
 
+1.9.0 起，记忆管理这一块跟随宿主语言（**设置 → 通用 → 语言**）；记忆内容本身保持它被写下时的语言，其余面板（自动做梦、自动归档、记忆星图、体检）仍是中文，等下一批 i18n。
+
 ![文件列表：每条记忆一个 Markdown 文件，灰底的是已归档](https://raw.githubusercontent.com/gezi-wen/sage-mem/main/docs/images/files-list.png)
 
 *文件列表 —— 头部常显「体检 N 个问题」与「待重启生效」，不用点开就知道该不该处理；灰底条目是已归档，随时可以恢复，也可以点「彻底删除」真的删掉（不可恢复，要再确认一次）。*
@@ -291,6 +293,9 @@ sage-mem 给记忆目录的写入加了**版本守卫**：写入前记下当前
 | **插件自己**写（自动做梦的整理） | 调用方在写入时带上读到的版本 | 落一条待处理记录 `<状态目录>/conflicts/<id>.json`，里面留着**盘上那一版**和**想要写的那一版** —— 只有一边等于没得判 |
 
 - **冲突不会自动合并**，保留哪边由你决定（记录是 JSON，需要时直接打开看）。静默重试和静默放弃都是在替你决定。
+- **注入侧目前不读这个队列**：有未裁决冲突的记忆照常作为正文注入；`conflict_pending` 这条抑制规则要等 **1.10.0 的矛盾检测**（连面板里的裁决入口一起）才生效 —— 只接抑制、不做入口，会让一条记忆**永久不再被注入**，比现在更糟。现阶段处理：打开 `conflicts/<id>.json`，把 `status` 改成 `resolved` 或 `dismissed`（或直接删掉文件）。
+- **同一件事不会越积越多**：一次失败如果与队列里某条未裁决记录逐字段相同（同一文件、两份正文、两个版本），不再追加副本。
+- **宿主的文件沙箱**：自动做梦在**会话外**运行，拿不到会话工作区。宿主用 `workspace-write` 时，插件给每次写入带上**收窄到记忆目录**的逐次沙箱策略（比回退根更窄）；宿主是 `read-only` 时不传策略、写入照旧被拒，且这一趟会被记成**失败**（不是「成功，没改什么」）。
 - 已知边界：**在 shell 里改记忆不走这条路**。写门守的是「经过工具的记忆写入」，不是「所有对文件的修改」；`pwsh` 里的重定向之类认不出来。认不准就不认，免得把「看不到」误记成事实。
 
 ### 访问台账：三种「用过」分开记
@@ -362,7 +367,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/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）
@@ -331,12 +356,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,
@@ -354,7 +395,8 @@ export class AutodreamEngine {
       await this.persist()
       this.phase = ''
       return {
-        ok: true,
+        ok: !allWritesDenied,
+        ...(allWritesDenied ? { error: deniedError } : {}),
         runId,
         report: report.name,
         touched: result.touched,

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)}`
       }
     },
   }