@y0shua1ee/dsh-auto-memory 0.3.0 → 0.3.3

package/README.md

@@ -53,14 +53,15 @@ metadata:
 
 - `metadata.type` 取 `user`（用户是谁）、`feedback`（对工作方式的纠正或认可）、`project`（仓库里没记录的进行中工作、目标、约束）、`reference`（外部资源指针）之一；也接受顶层 `type:`。
 - `feedback` 和 `project` 在正文后跟 **Why:** / **How to apply:** 两行，便于模型在边界情况自行判断。
-- `[[name]]` 指向 `/memories/<name>.md`，所以文件名应与 `name` 一致（kebab-case，与 DSH skill 名规则相同）。链接到尚不存在的记忆是允许的，表示“值得以后补写”。
-- frontmatter 不是强制的：缺字段时 `create` 照常写入，只在工具输出里列出缺什么。frontmatter 只解析扁平的 `key: value` 和一层 `metadata:`，不是完整 YAML。
+- `[[name]]` 指向顶层 `/memories/<name>.md`，所以只有顶层文件的 `name` 能直接解析。子目录里的记忆（如 `sub/foo.md`）即使 `name: foo` 也会提示：`[[foo]]` 指向的是 `/memories/foo.md`，不是 `sub/foo.md`；需要互链时请把记忆放在顶层，或自己在正文里写完整路径。链接到尚不存在的记忆仍然允许，表示“值得以后补写”。
+- frontmatter 不是强制的：缺字段、`name` 与文件名不一致、文件在子目录时照常写入，只在工具输出里列出问题。`create` 列出全部问题；`str_replace` / `insert` / `rename` 只列出这次改动新引入的问题**类型**，所以把一个非法值换成另一个非法值不会重复报。`name` 不是合法 kebab-case 时索引标题退回文件名；v0.3.0 遗留的非法标题（内容里的 `name` 仍是那个非法值时）会在下一次编辑或 rename 时按 legacy 标题识别并归一化。frontmatter 只解析扁平的 `key: value` 和一层 `metadata:`，不是完整 YAML。
+- 记忆文件名允许空格等空白字符；索引链接会写成 `[标题](<my note.md>)`，维护逻辑按行首链接的 target 精确匹配。说明或标题里的其他链接、`- [ ]` 任务列表不会被当成索引项。
 
 项目目录名与 DSH 的 session 目录规则一致（`--` + 路径转义 + `--`），所以 `~/.dsh/sessions/` 和 `~/.dsh/auto-memory/` 可以对照着看。
 
 ## 安装到 DSH profile
 
-本包是一个 **DSH bundle**：`package.json` 声明 `dsh.bundle.patch`，安装后自动加入 profile 的 `dsh.profile.bundles`，由包内的 `cordis.patch.yml` 挂载插件行，不需要再手写 `insert`。目标版本为 DSH `0.2.1-rc.3`。
+本包是一个 **DSH bundle**：`package.json` 声明 `dsh.bundle.patch`，安装后自动加入 profile 的 `dsh.profile.bundles`，由包内的 `cordis.patch.yml` 挂载插件行，不需要再手写 `insert`。目标版本为 DSH `0.2.1-rc.3` 及以上（已测到 `0.2.1-rc.5`）；peer 范围是 `^0.2.1-rc.3`。
 
 ### 方式 A：Plugins 页面（推荐）
 
@@ -125,7 +126,7 @@ pnpm install --prefer-offline
 
 ### 生效与验证
 
-- 插件代码通过 `link:` 加载；**更新代码后需要重启 DeepSeek Harness**，配置文件变更在 `patchReload: live` 的 profile 中可以热重组。
+- 插件代码在启动时加载：npm 安装的要先更新 profile 里的版本，`link:` 安装的直接读本地目录；两种情况**更新代码后都要重启 DeepSeek Harness**。配置文件变更在 `patchReload: live` 的 profile 中可以热重组。
 - 重启后在 **插件 → 已安装插件** 里应看到 `@y0shua1ee/dsh-auto-memory`，开关为开启状态。
 - 在会话里让 agent 调一次 `memory view /memories`，应返回空目录提示。
 - 让 agent 记住一条内容，检查 `~/.dsh/auto-memory/<projectKey>/MEMORY.md` 是否出现。
@@ -162,7 +163,7 @@ pnpm install --prefer-offline
 | `str_replace` | `path`、`old_str`、`new_str` | `old_str` 必须恰好出现一次 |
 | `insert` | `path`、`insert_line`、`insert_text` | `insert_line` 从 0 开始，0 表示插到第一行之前 |
 | `delete` | `path` | 删除文件，并清掉索引里的对应行 |
-| `rename` | `path`、`new_path` | 重命名，并同步索引链接；不允许改名 `MEMORY.md` |
+| `rename` | `path`、`new_path` | 重命名，并同步索引链接；仍由旧文件名生成的标题随之更新；不允许改名 `MEMORY.md` |
 
 示例：
 
@@ -176,7 +177,7 @@ pnpm install --prefer-offline
 - [prefer-pnpm](prefer-pnpm.md) — 这个仓库只用 pnpm，不用 npm
 ```
 
-之后用 `str_replace` / `insert` 改了 `name` 或 `description`，索引行会跟着更新；但若这一行的标题或说明已被手改（不再等于旧值），那一部分保持不动。
+之后用 `str_replace` / `insert` 改了 `name` 或 `description`，索引行会跟着更新；但若这一行的标题或说明已被手改（不再等于旧值），那一部分保持不动。索引维护只解析行首的 `[标题](文件)` 链接，target 精确匹配；含空白的 target 写成 `<...>`，标题里的嵌套链接按括号配对处理，任务列表会被忽略。CRLF 索引在 create / edit / delete / rename 下都保留原有行尾。
 
 ## Rules（兼容 Claude Code）
 
@@ -251,7 +252,7 @@ paths:
 
 ```bash
 cd dsh-auto-memory
-node --test test/store.test.mjs test/render-paths.test.mjs test/rules.test.mjs
+node --test test/store.test.mjs test/memory-frontmatter.test.mjs test/render-paths.test.mjs test/rules.test.mjs
 ```
 
 插件装配与注入的集成测试需要一份 DSH 运行时。先解出安装包（默认写到 `/tmp/dsh-app`，原生模块会从 `app.asar.unpacked` 合并）：
@@ -271,19 +272,16 @@ DSH_APP_NODE_MODULES=/tmp/dsh-app/dsh/node_modules \
 - 没有后台 LLM 提炼：记忆完全由模型在会话中主动写入，和 Claude Code 的 auto memory 一致。
 - Rules 只实现 `paths` 一个 frontmatter 字段，没有完整 YAML、`@import`、托管策略或 `/rules` 面板。
 - `paths` 目前只由 `read` / `write` / `edit` 触发；用 `bash cat/head` 读文件不会触发。
-- 不是 bundle：不会出现在 Web 的 Plugins 市场页，只能按上面的 row 方式挂载。
 - 一个 profile 一个 root；跨项目共享要自己写 `AGENTS.md` 或另开配置。
-- 依赖 DSH `0.2.1-rc.3` 的内部接口（`agent/pre-step`、`agent.inbox`、`defineTool`、`systemPrompt.section`）。DSH 升级后若接口变动，需要跟着改。
+- 依赖 DSH `0.2.1-rc.3` 到 `0.2.1-rc.5` 的内部接口（`agent/pre-step`、`agent.inbox`、`defineTool`、`systemPrompt.section`）；peer 范围是 `^0.2.1-rc.3`。DSH 升级后若接口变动，需要跟着改。
 - `MEMORY.md` 超过注入预算时只注入前 N 行/字节；完整内容要用 `memory view`。
 
 ## 卸载
 
-1. 从 `cordis.patch.yml` 删掉 `auto-memory` 的 insert 行。
-2. 从 profile 的 `package.json` 删掉 `@y0shua1ee/dsh-auto-memory` 依赖，执行 `pnpm install`。
+1. 在 **插件 → 已安装插件** 里移除 `@y0shua1ee/dsh-auto-memory`；或手动从 profile 的 `package.json` 删掉该依赖和 `dsh.profile.bundles` 里的同名条目，再执行 `pnpm install`。
+2. 如果在 profile 的 `cordis.patch.yml` 里覆盖过 `dsh-auto-memory` 的配置，一并删掉。
 3. 可选：删除 `~/.dsh/auto-memory/`（记忆文件不会自动删除）。
 
-代码目录本身可以保留，删除 profile 里的引用后不会加载。
-
 ## 设计来源
 
 - Claude Code 的 auto memory：`MEMORY.md` 索引 + 一条一文件 + `name` / `description` / `type` frontmatter + `[[name]]` 互链 + 模型主动写。

package/lib/memory-frontmatter.js

@@ -75,21 +75,67 @@ export function parseMemory(content) {
   return result;
 }
 
+/**
+ * Describe each frontmatter problem as a stable code plus a readable message.
+ *
+ * Codes stay stable when only the offending value changes, so callers can tell
+ * "the same problem still exists" from "this edit introduced a new problem".
+ *
+ * @param {ReturnType<typeof parseMemory>} parsed - parsed memory file.
+ * @param {string} [fileStem] - file name without `.md`; `[[name]]` resolves to it.
+ * @param {string} [filePath] - project-relative path, used to detect subdirectories.
+ * @returns {Array<{code: string, message: string}>} problems; empty when well-formed.
+ */
+export function memoryFrontmatterIssues(parsed, fileStem, filePath) {
+  if (!parsed.frontmatter) {
+    return [{ code: "frontmatter-missing", message: "no frontmatter (name, description, metadata.type)" }];
+  }
+
+  const issues = [];
+  if (parsed.name === undefined) {
+    issues.push({ code: "name-missing", message: "missing name" });
+  } else if (!MEMORY_NAME.test(parsed.name)) {
+    issues.push({
+      code: "name-invalid",
+      message: `name ${JSON.stringify(parsed.name)} is not kebab-case`
+    });
+  } else if (fileStem !== undefined && parsed.name !== fileStem) {
+    const file = filePath ?? `${fileStem}.md`;
+    issues.push({
+      code: "name-unmatched",
+      message: `name ${JSON.stringify(parsed.name)} does not match the file name ${file}, so [[${parsed.name}]] will not resolve`
+    });
+  } else if (filePath !== undefined && filePath.includes("/")) {
+    issues.push({
+      code: "name-nested",
+      message:
+        `name ${JSON.stringify(parsed.name)} matches the file name, but the file is in a subdirectory; ` +
+        `[[${parsed.name}]] resolves to /memories/${parsed.name}.md, not this file`
+    });
+  }
+
+  if (parsed.description === undefined) {
+    issues.push({ code: "description-missing", message: "missing description" });
+  }
+  if (parsed.type === undefined) {
+    issues.push({ code: "type-missing", message: "missing metadata.type" });
+  } else if (!MEMORY_TYPES.includes(parsed.type)) {
+    issues.push({
+      code: "type-invalid",
+      message: `metadata.type ${JSON.stringify(parsed.type)} is not one of ${MEMORY_TYPES.join(", ")}`
+    });
+  }
+  return issues;
+}
+
 /**
  * List what a topic file's frontmatter is missing, for a non-blocking hint.
  *
  * @param {ReturnType<typeof parseMemory>} parsed - parsed memory file.
+ * @param {string} [fileStem] - file name without `.md`; `[[name]]` resolves to it.
+ * @param {string} [filePath] - project-relative path, used to detect subdirectories.
  * @returns {string[]} human-readable problems; empty when the file is well-formed.
  */
-export function memoryFrontmatterProblems(parsed) {
-  if (!parsed.frontmatter) return ["no frontmatter (name, description, metadata.type)"];
-  const problems = [];
-  if (parsed.name === undefined) problems.push("missing name");
-  else if (!MEMORY_NAME.test(parsed.name)) problems.push(`name ${JSON.stringify(parsed.name)} is not kebab-case`);
-  if (parsed.description === undefined) problems.push("missing description");
-  if (parsed.type === undefined) problems.push("missing metadata.type");
-  else if (!MEMORY_TYPES.includes(parsed.type)) {
-    problems.push(`metadata.type ${JSON.stringify(parsed.type)} is not one of ${MEMORY_TYPES.join(", ")}`);
-  }
-  return problems;
+export function memoryFrontmatterProblems(parsed, fileStem, filePath) {
+  return memoryFrontmatterIssues(parsed, fileStem, filePath).map((issue) => issue.message);
 }

package/lib/store.js

@@ -9,7 +9,7 @@ import {
   writeFile
 } from "node:fs/promises";
 import { basename, dirname, extname, join, resolve, sep } from "node:path";
-import { memoryFrontmatterProblems, parseMemory } from "./memory-frontmatter.js";
+import { MEMORY_NAME, memoryFrontmatterIssues, parseMemory } from "./memory-frontmatter.js";
 
 /** Name of the index file loaded into every session. */
 export const INDEX_FILE = "MEMORY.md";
@@ -27,6 +27,8 @@ const MAX_PATH_SEGMENTS = 4;
 const MAX_RELATIVE_PATH_LENGTH = 200;
 const MAX_LIST_DEPTH = MAX_PATH_SEGMENTS;
 const SAFE_SEGMENT = /^[^\\/\u0000-\u001f\u007f:*?"<>|#%\[\]()]+$/u;
+const INDEX_BULLET = /^(\s*[-*]\s*)/u;
+const CHECKBOX = /^\s*(?:[xX])?\s*$/u;
 
 /** A memory operation failed with a model-actionable reason. */
 export class MemoryError extends Error {
@@ -49,6 +51,142 @@ function lineCount(value) {
   return value.length === 0 ? 0 : value.split("\n").length;
 }
 
+function needsAngle(target) {
+  return /\s/u.test(target);
+}
+
+/**
+ * Read a Markdown link destination. A destination with whitespace is written
+ * as `<target>`; the bare form is kept for older index lines and for targets
+ * without whitespace.
+ *
+ * @param {string} line - index line without its trailing `\r`.
+ * @param {number} start - index of the first destination character or `<`.
+ * @returns {{target: string, end: number} | undefined} target and the index
+ *   after the closing `)`, or undefined when the link is malformed.
+ */
+function readTarget(line, start) {
+  if (line[start] === "<") {
+    const close = line.indexOf(">", start + 1);
+    if (close === -1 || line[close + 1] !== ")") return undefined;
+    return { target: line.slice(start + 1, close), end: close + 2 };
+  }
+  const close = line.indexOf(")", start);
+  if (close === -1) return undefined;
+  return { target: line.slice(start, close), end: close + 1 };
+}
+
+/**
+ * Find the title of the first link, matching nested brackets. This keeps a
+ * link embedded in a title from becoming the entry target.
+ *
+ * @param {string} line - index line without its trailing `\r`.
+ * @param {number} open - index of the opening `[`.
+ * @returns {{title: string, targetStart: number} | undefined} the title and
+ *   the index after `](`, or undefined when the bracket is not followed by a
+ *   destination.
+ */
+function leadingLink(line, open) {
+  let depth = 0;
+  for (let index = open; index < line.length; index += 1) {
+    const char = line[index];
+    if (char === "\\") {
+      index += 1;
+      continue;
+    }
+    if (char === "[") {
+      depth += 1;
+    } else if (char === "]") {
+      depth -= 1;
+      if (depth === 0) {
+        if (line[index + 1] !== "(") return undefined;
+        return { title: line.slice(open + 1, index), targetStart: index + 2 };
+      }
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Parse one index line that links `target`. Only the leading link counts, so
+ * links inside a hook never identify the line. A line whose title contains
+ * nested brackets is handled by bracket matching; v0.3.0 wrote unescaped
+ * names as titles, so a malformed legacy title can still be recognized by the
+ * first link after the opening `[`.
+ *
+ * @param {string} line - one `MEMORY.md` line, possibly ending in `\r`.
+ * @param {string} target - exact project-relative path to match.
+ * @returns {{bullet: string, title: string, target: string, rest: string, cr: string} | undefined}
+ */
+function parseIndexLine(line, target) {
+  const cr = line.endsWith("\r") ? "\r" : "";
+  const text = cr.length > 0 ? line.slice(0, -1) : line;
+  const bullet = INDEX_BULLET.exec(text);
+  if (bullet === null) return undefined;
+  const prefix = bullet[1];
+  const open = prefix.length;
+  if (text[open] !== "[") return undefined;
+
+  const leading = leadingLink(text, open);
+  if (leading !== undefined) {
+    const destination = readTarget(text, leading.targetStart);
+    if (destination === undefined || destination.target !== target) return undefined;
+    return {
+      bullet: prefix,
+      title: leading.title,
+      target: destination.target,
+      rest: text.slice(destination.end),
+      cr
+    };
+  }
+
+  // `- [ ] [name](target)` is a task list, not an index line.
+  const firstClose = text.indexOf("]", open + 1);
+  if (firstClose !== -1) {
+    const box = text.slice(open + 1, firstClose);
+    if (CHECKBOX.test(box) && text.indexOf("[", firstClose + 1) !== -1) return undefined;
+    if (text.slice(firstClose + 1).trimStart().startsWith("[")) return undefined;
+  }
+
+  // A legacy title such as `- [a]b](target)` lacks a bracket before the
+  // destination; fall back to the first link, which is still the entry link.
+  const firstLink = text.indexOf("](", open + 1);
+  if (firstLink === -1) return undefined;
+  const hookAt = text.indexOf(" — ", open + 1);
+  if (hookAt !== -1 && firstLink > hookAt) return undefined;
+  const destination = readTarget(text, firstLink + 2);
+  if (destination === undefined || destination.target !== target) return undefined;
+  return {
+    bullet: prefix,
+    title: text.slice(open + 1, firstLink),
+    target: destination.target,
+    rest: text.slice(destination.end),
+    cr
+  };
+}
+
+function formatIndexLine({ bullet, title, target, rest, cr }) {
+  const destination = needsAngle(target) ? `<${target}>` : target;
+  return `${bullet}[${title}](${destination})${rest}${cr}`;
+}
+
+function stem(relativePath) {
+  return basename(relativePath, extname(relativePath));
+}
+
+function frontmatterIssues(relativePath, content) {
+  return memoryFrontmatterIssues(parseMemory(content), stem(relativePath), relativePath);
+}
+
+/** Frontmatter problems present after an edit or rename that were not present before it. */
+function introducedProblems(relativePath, before, after, previousPath = relativePath) {
+  if (relativePath === INDEX_FILE) return [];
+  const known = new Set(frontmatterIssues(previousPath, before).map((issue) => issue.code));
+  return frontmatterIssues(relativePath, after)
+    .filter((issue) => !known.has(issue.code))
+    .map((issue) => issue.message);
+}
+
 function virtual(relativePath) {
   return relativePath.length === 0 ? VIRTUAL_ROOT : `${VIRTUAL_ROOT}/${relativePath}`;
 }
@@ -387,7 +525,7 @@ export class MemoryStore {
       let indexed = false;
       let frontmatterProblems = [];
       if (relativePath !== INDEX_FILE) {
-        frontmatterProblems = memoryFrontmatterProblems(parseMemory(next));
+        frontmatterProblems = frontmatterIssues(relativePath, next).map((issue) => issue.message);
         try {
           indexed = (await this.#linkIndex(relativePath, next)).updated;
         } catch (error) {
@@ -430,7 +568,12 @@ export class MemoryStore {
       const next = current.content.replace(oldStr, () => newStr);
       this.#assertWithinFileBudget(relativePath, next);
       const written = await this.#atomicWrite(relativePath, next);
-      return { path: virtual(relativePath), ...written, ...(await this.#syncIndex(relativePath, current.content, next)) };
+      return {
+        path: virtual(relativePath),
+        ...written,
+        ...(await this.#syncIndex(relativePath, current.content, next)),
+        frontmatterProblems: introducedProblems(relativePath, current.content, next)
+      };
     });
   }
 
@@ -463,7 +606,8 @@ export class MemoryStore {
         path: virtual(relativePath),
         ...written,
         insertedAt: at,
-        ...(await this.#syncIndex(relativePath, current.content, next))
+        ...(await this.#syncIndex(relativePath, current.content, next)),
+        frontmatterProblems: introducedProblems(relativePath, current.content, next)
       };
     });
   }
@@ -504,7 +648,8 @@ export class MemoryStore {
   }
 
   /**
-   * Rename one file. Links in the index follow the file.
+   * Rename one file. Links in the index follow the file, and a title still
+   * generated from the old file name follows the new one.
    *
    * @param {string} oldPath - existing file path.
    * @param {string} newPath - new file path.
@@ -534,22 +679,43 @@ export class MemoryStore {
       if (await this.#lstat(absoluteNew)) {
         throw new MemoryError(`${virtual(newPath)} already exists`, "MEMORY_ALREADY_EXISTS");
       }
+      const content = await this.#readText(oldPath).then(
+        (read) => read.content,
+        () => undefined
+      );
       await mkdir(dirname(absoluteNew), { recursive: true });
       await renameFile(absoluteOld, absoluteNew);
       let indexWarning;
       let indexed = false;
+      const previousFields = this.#indexFields(oldPath, content);
+      const nextFields = this.#indexFields(newPath, content);
       try {
-        indexed = await this.#relinkIndex(oldPath, newPath);
+        indexed = await this.#rewriteIndex(oldPath, (entry) => ({
+          ...entry,
+          target: newPath,
+          title:
+            entry.title === previousFields.title || entry.title === previousFields.legacyTitle
+              ? nextFields.title
+              : entry.title
+        }));
       } catch (error) {
         indexWarning = `renamed the file, but could not update MEMORY.md: ${error.message}`;
       }
-      return { path: virtual(newPath), previousPath: virtual(oldPath), changed: true, indexed, indexWarning };
+      const frontmatterProblems = content === undefined ? [] : introducedProblems(newPath, content, content, oldPath);
+      return {
+        path: virtual(newPath),
+        previousPath: virtual(oldPath),
+        changed: true,
+        indexed,
+        indexWarning,
+        frontmatterProblems
+      };
     });
   }
 
   #indexFields(relativePath, text) {
     const parsed = parseMemory(text ?? "");
-    const title = parsed.name ?? basename(relativePath, extname(relativePath));
+    const title = parsed.name !== undefined && MEMORY_NAME.test(parsed.name) ? parsed.name : stem(relativePath);
     const firstLine = parsed.body
       .split("\n")
       .map((line) => line.trim())
@@ -557,51 +723,83 @@ export class MemoryStore {
     const hook = (parsed.description ?? firstLine ?? "")
       .replace(/^#+\s*/u, "")
       .replace(/\s+/gu, " ")
+      .trim()
       .slice(0, 110);
-    return { title, hook };
+    return { title, hook, legacyTitle: parsed.name };
   }
 
   #indexEntry(relativePath, text) {
     const { title, hook } = this.#indexFields(relativePath, text);
-    return `- [${title}](${relativePath})${hook.length > 0 ? ` — ${hook}` : ""}`;
+    return formatIndexLine({
+      bullet: "- ",
+      title,
+      target: relativePath,
+      rest: hook.length > 0 ? ` — ${hook}` : "",
+      cr: ""
+    });
   }
 
   /**
-   * Refresh the index line of an edited topic file. A title or hook is
-   * replaced only while it still equals what the old content would have
-   * generated, so a line the model rewrote by hand is left alone.
+   * Rewrite the index lines that link `relativePath`.
+   *
+   * @param {string} relativePath - link target to match.
+   * @param {(entry: object) => object | null | undefined} update - returns the
+   *   replacement entry, `null` to drop the line, or `undefined` to keep it.
+   * @returns {Promise<boolean>} whether the index changed.
+   */
+  async #rewriteIndex(relativePath, update) {
+    const index = await this.index();
+    if (!index.exists) return false;
+    let changed = false;
+    const lines = [];
+    for (const line of index.content.split("\n")) {
+      const entry = parseIndexLine(line, relativePath);
+      const next = entry === undefined ? undefined : update(entry);
+      if (next === undefined) {
+        lines.push(line);
+      } else if (next !== null) {
+        const formatted = formatIndexLine(next);
+        changed ||= formatted !== line;
+        lines.push(formatted);
+      } else {
+        changed = true;
+      }
+    }
+    if (!changed) return false;
+    const content = lines.join("\n");
+    if (byteLength(content) > this.maxFileBytes) {
+      throw new MemoryError("MEMORY.md is full; remove or merge entries before adding more", "MEMORY_INDEX_FULL");
+    }
+    await this.#atomicWrite(INDEX_FILE, content);
+    return true;
+  }
+
+  /**
+   * Refresh the index line of an edited topic file. A title or hook is replaced
+   * only while it still equals what the old content would have generated, so a
+   * line the model rewrote by hand is left alone. An invalid name from v0.3.0
+   * was used as the title then; it is recognized as the legacy generated title
+   * and normalized to the current fallback.
    */
   async #syncIndex(relativePath, before, after) {
     if (relativePath === INDEX_FILE) return {};
     const previous = this.#indexFields(relativePath, before);
     const current = this.#indexFields(relativePath, after);
-    if (previous.title === current.title && previous.hook === current.hook) return {};
+    const legacyStale =
+      previous.legacyTitle !== undefined && previous.legacyTitle !== previous.title;
+    if (previous.title === current.title && previous.hook === current.hook && !legacyStale) return {};
     try {
-      const index = await this.index();
-      if (!index.exists) return { indexed: false };
-      const link = `](${relativePath})`;
-      let changed = false;
-      const lines = index.content.split("\n").map((line) => {
-        const at = line.indexOf(link);
-        const open = line.lastIndexOf("[", at);
-        if (at === -1 || open === -1 || !/^\s*-\s*$/u.test(line.slice(0, open))) return line;
-        const title = line.slice(open + 1, at);
-        const rest = line.slice(at + link.length);
-        const hook = rest.startsWith(" — ") ? rest.slice(3) : rest.length === 0 ? "" : undefined;
-        if (hook === undefined) return line;
-        const nextTitle = title === previous.title ? current.title : title;
+      const indexed = await this.#rewriteIndex(relativePath, (entry) => {
+        const hook = entry.rest.startsWith(" — ") ? entry.rest.slice(3) : entry.rest.length === 0 ? "" : undefined;
+        if (hook === undefined) return undefined;
+        const title =
+          entry.title === previous.title || entry.title === previous.legacyTitle
+            ? current.title
+            : entry.title;
         const nextHook = hook === previous.hook ? current.hook : hook;
-        if (nextTitle === title && nextHook === hook) return line;
-        changed = true;
-        return `${line.slice(0, open)}[${nextTitle}${link}${nextHook.length > 0 ? ` — ${nextHook}` : ""}`;
+        return { ...entry, title, rest: nextHook.length > 0 ? ` — ${nextHook}` : "" };
       });
-      if (!changed) return { indexed: false };
-      const next = lines.join("\n");
-      if (byteLength(next) > this.maxFileBytes) {
-        throw new MemoryError("MEMORY.md is full; remove or merge entries before adding more", "MEMORY_INDEX_FULL");
-      }
-      await this.#atomicWrite(INDEX_FILE, next);
-      return { indexed: true };
+      return { indexed };
     } catch (error) {
       return { indexed: false, indexWarning: `edited the file, but could not update MEMORY.md: ${error.message}` };
     }
@@ -609,12 +807,23 @@ export class MemoryStore {
 
   async #linkIndex(relativePath, text) {
     const index = await this.index();
-    const link = `](${relativePath})`;
-    if (index.exists && index.content.includes(link)) return { updated: false };
+    if (
+      index.exists &&
+      index.content.split("\n").some((line) => parseIndexLine(line, relativePath) !== undefined)
+    ) {
+      return { updated: false };
+    }
     const entry = this.#indexEntry(relativePath, text);
-    const next = index.exists
-      ? `${index.content.replace(/\n*$/u, "")}\n${entry}\n`
-      : `${INDEX_HEADER.replace(/\n*$/u, "")}\n\n${entry}\n`;
+    let next;
+    if (!index.exists || index.content.trim().length === 0) {
+      next = `${INDEX_HEADER.replace(/\n*$/u, "")}\n\n${entry}\n`;
+    } else {
+      const content = index.content.replace(/[ \t]+$/u, "");
+      const eol = content.endsWith("\r\n") ? "\r\n" : content.endsWith("\r") ? "\r" : "\n";
+      const separator =
+        content.length === 0 || content.endsWith("\n") || content.endsWith("\r") ? "" : eol;
+      next = `${content}${separator}${entry}${eol}`;
+    }
     if (byteLength(next) > this.maxFileBytes) {
       throw new MemoryError("MEMORY.md is full; remove or merge entries before adding more", "MEMORY_INDEX_FULL");
     }
@@ -623,24 +832,6 @@ export class MemoryStore {
   }
 
   async #unlinkIndex(relativePath) {
-    const index = await this.index();
-    if (!index.exists) return false;
-    const needle = `](${relativePath})`;
-    const lines = index.content.split("\n");
-    const kept = lines.filter((line) => !line.includes(needle));
-    if (kept.length === lines.length) return false;
-    const next = kept.join("\n");
-    await this.#atomicWrite(INDEX_FILE, next);
-    return true;
-  }
-
-  async #relinkIndex(oldPath, newPath) {
-    const index = await this.index();
-    if (!index.exists) return false;
-    const needle = `](${oldPath})`;
-    if (!index.content.includes(needle)) return false;
-    const next = index.content.split(needle).join(`](${newPath})`);
-    await this.#atomicWrite(INDEX_FILE, next);
-    return true;
+    return this.#rewriteIndex(relativePath, () => null);
   }
 }

package/lib/tool.js

@@ -38,6 +38,12 @@ function indexNote({ indexed, indexWarning, action }) {
   return `MEMORY.md already links this file (${action}).`;
 }
 
+function frontmatterNote(problems) {
+  return problems !== undefined && problems.length > 0
+    ? [`Frontmatter: ${problems.join("; ")}. Fix it with str_replace, or rename the file when the name and path disagree.`]
+    : [];
+}
+
 function editIndexNote({ indexed, indexWarning }) {
   if (indexWarning !== undefined) return [indexWarning];
   return indexed ? ["Updated its MEMORY.md line to match the new frontmatter."] : [];
@@ -183,9 +189,7 @@ export function buildMemoryToolOptions({ projectFor }) {
             (relativePath === INDEX_FILE
               ? "This is the index injected into future sessions."
               : indexNote({ ...result, action: "created" })),
-          ...(result.frontmatterProblems.length > 0
-            ? [`Frontmatter: ${result.frontmatterProblems.join("; ")}. Fix it with str_replace.`]
-            : [])
+          ...frontmatterNote(result.frontmatterProblems)
         ].join("\n");
         return { ok: true, output, path: result.path, changed: true, bytes: result.bytes, lines: result.lines };
       }
@@ -197,7 +201,8 @@ export function buildMemoryToolOptions({ projectFor }) {
           ok: true,
           output: [
             `Edited ${result.path} (${formatBytes(result.bytes)}, ${result.lines} lines).`,
-            ...editIndexNote(result)
+            ...editIndexNote(result),
+            ...frontmatterNote(result.frontmatterProblems)
           ].join("\n"),
           path: result.path,
           changed: true,
@@ -215,7 +220,8 @@ export function buildMemoryToolOptions({ projectFor }) {
           ok: true,
           output: [
             `Inserted text at line ${result.insertedAt} in ${result.path} (${formatBytes(result.bytes)}, ${result.lines} lines).`,
-            ...editIndexNote(result)
+            ...editIndexNote(result),
+            ...frontmatterNote(result.frontmatterProblems)
           ].join("\n"),
           path: result.path,
           changed: true,
@@ -236,7 +242,8 @@ export function buildMemoryToolOptions({ projectFor }) {
         const result = await store.rename(relativePath, MemoryStore.parseVirtualPath(newPath));
         const output = [
           `Renamed ${result.previousPath} to ${result.path}.`,
-          result.indexWarning ?? (result.indexed ? "Updated its MEMORY.md link." : "No MEMORY.md link referenced it.")
+          result.indexWarning ?? (result.indexed ? "Updated its MEMORY.md link." : "No MEMORY.md link referenced it."),
+          ...frontmatterNote(result.frontmatterProblems)
         ].join("\n");
         return { ok: true, output, path: result.path, changed: true };
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@y0shua1ee/dsh-auto-memory",
-  "version": "0.3.0",
+  "version": "0.3.3",
   "description": "Persistent project memory and Claude Code-compatible rules for DeepSeek Harness.",
   "type": "module",
   "main": "lib/index.js",
@@ -29,9 +29,9 @@
     "agent"
   ],
   "peerDependencies": {
-    "@deepseek-ai/dsh-home-paths": "0.2.1-rc.3",
-    "@deepseek-ai/dsh-llm": "0.2.1-rc.3",
-    "@deepseek-ai/dsh-tools": "0.2.1-rc.3",
+    "@deepseek-ai/dsh-home-paths": "^0.2.1-rc.3",
+    "@deepseek-ai/dsh-llm": "^0.2.1-rc.3",
+    "@deepseek-ai/dsh-tools": "^0.2.1-rc.3",
     "@deepseek-ai/schemastery": "~3.18.5"
   },
   "peerDependenciesMeta": {
@@ -48,6 +48,11 @@
       "optional": true
     }
   },
+  "scripts": {
+    "test": "node --test test/*.test.mjs",
+    "test:integration": "node --import ./test/register.mjs --test test/*.test.mjs",
+    "extract-runtime": "node scripts/extract-runtime.mjs"
+  },
   "author": "Ares Lee",
   "homepage": "https://github.com/y0shua1ee/dsh-auto-memory#readme",
   "repository": {
@@ -68,10 +73,5 @@
   },
   "publishConfig": {
     "access": "public"
-  },
-  "scripts": {
-    "test": "node --test test/*.test.mjs",
-    "test:integration": "node --import ./test/register.mjs --test test/*.test.mjs",
-    "extract-runtime": "node scripts/extract-runtime.mjs"
   }
-}
+}