memory-bank-skill 7.3.2 → 7.4.0

package/README.md

@@ -32,7 +32,7 @@ bunx memory-bank-skill install
 
 ### 自定义模型
 
-默认使用 `cliproxy/claude-opus-4-5-20251101`，可通过 `--model` 指定：
+默认使用 `cliproxy/claude-opus-4-6`，可通过 `--model` 指定：
 
 ```bash
 bunx memory-bank-skill install --model anthropic/claude-sonnet-4-5
@@ -50,7 +50,7 @@ bunx memory-bank-skill doctor
 |------|----------|
 | 复制 Skill 文件 | `~/.config/opencode/skills/memory-bank/`（含 `references/writer.md`） |
 | 配置 opencode.json | 添加 `permission.skill=allow`，注册插件和 agent |
-| 注册 Agent | 添加 `memory-bank-writer` agent（用于写入守卫） |
+| 注册 Agent | 添加 `memory-reader` agent（用于上下文读取） |
 | 写入 manifest | `~/.config/opencode/skills/memory-bank/.manifest.json` |
 
 ---
@@ -180,5 +180,5 @@ service=memory-bank Plugin initialized (unified) {"projectRoot":"..."}
 
 ## 版本
 
-- **版本**: 7.3.0
-- **主要更新**: Doc-First Gate 默认启用（warn），无 Memory Bank 项目自动提醒初始化
+- **版本**: 7.4.0
+- **主要更新**: Writer 轻量化 — 去掉 writer subagent，主 agent 直接写入 + Plugin 注入 writing guideline

package/dist/cli.js

@@ -27,7 +27,7 @@ import { fileURLToPath } from "url";
 // package.json
 var package_default = {
   name: "memory-bank-skill",
-  version: "7.3.2",
+  version: "7.4.0",
   description: "Memory Bank - \u9879\u76EE\u8BB0\u5FC6\u7CFB\u7EDF\uFF0C\u8BA9 AI \u52A9\u624B\u5728\u6BCF\u6B21\u5BF9\u8BDD\u4E2D\u90FD\u80FD\u5FEB\u901F\u7406\u89E3\u9879\u76EE\u4E0A\u4E0B\u6587",
   type: "module",
   main: "dist/plugin.js",
@@ -291,14 +291,8 @@ async function installPluginToConfig(undoStack, customModel) {
   if (!config.agent) {
     config.agent = {};
   }
-  const defaultModel = "cliproxy/claude-opus-4-5-20251101";
+  const defaultModel = "cliproxy/claude-opus-4-6";
   const installedBy = `memory-bank-skill@${VERSION}`;
-  const writerDefaults = {
-    description: "Memory Bank \u4E13\u7528\u5199\u5165\u4EE3\u7406",
-    model: customModel || defaultModel,
-    tools: { write: true, edit: true, bash: true },
-    "x-installed-by": installedBy
-  };
   const readerDefaults = {
     description: "Memory Bank \u5E76\u884C\u8BFB\u53D6\u4EE3\u7406\uFF0C\u8FD4\u56DE\u7ED3\u6784\u5316\u4E0A\u4E0B\u6587\u5305",
     model: customModel || defaultModel,
@@ -337,7 +331,9 @@ async function installPluginToConfig(undoStack, customModel) {
     }
     return agentModified;
   };
-  if (mergeAgent(config.agent["memory-bank-writer"], writerDefaults, "memory-bank-writer")) {
+  if (config.agent["memory-bank-writer"]) {
+    delete config.agent["memory-bank-writer"];
+    changes.push("Removed agent: memory-bank-writer (no longer needed)");
     modified = true;
   }
   if (mergeAgent(config.agent["memory-reader"], readerDefaults, "memory-reader")) {
@@ -359,7 +355,6 @@ async function installCommands(undoStack, manifestFiles) {
   const commandPath = join(commandsDir, "memory-bank-refresh.md");
   const commandContent = `---
 description: \u521D\u59CB\u5316\u3001\u5347\u7EA7\u3001\u8FC1\u79FB\u6216\u5237\u65B0 Memory Bank
-agent: memory-bank-writer
 ---
 
 \u6267\u884C Memory Bank \u7684 refresh \u6D41\u7A0B\uFF1A
@@ -441,7 +436,7 @@ Replace <<<USER_REQUEST>>> with the user's original message verbatim.
 
 ---
 
-AMENDMENT B \u2014 Final Step: Memory Bank Writer (Propose -> Confirm -> Execute)
+AMENDMENT B \u2014 Final Step: Memory Bank Write (Propose -> Confirm -> Execute)
 
 Step W0 Timing:
 - AFTER you finish main task output, RIGHT BEFORE final answer for this turn.
@@ -481,14 +476,7 @@ Ignore: User continues to next topic without addressing the prompt (treat as ski
 
 **Mixed intent**: If user confirms AND asks another question (e.g., "\u5199\u5427\uFF0C\u987A\u4FBF\u95EE\u4E00\u4E0B..."), execute the write first, then answer their question in the same response.
 
-On confirmation, execute writer synchronously:
-\`\`\`
-proxy_task({
-  subagent_type: "memory-bank-writer",
-  description: "Memory Bank write (confirmed)",
-  prompt: "You are updating Memory Bank.\\nConstraints:\\n- Edit ONLY the target file.\\n- Keep changes minimal and consistent with existing format.\\n- Do NOT invent facts.\\nInput:\\nTarget: <PASTE TARGET>\\nDraft:\\n1) <PASTE>\\n2) <PASTE>\\nOutput: Show what file changed + brief preview of changes."
-})
-\`\`\`
+On confirmation, directly use write/edit tools to update the target file(s). Plugin will auto-inject writing guidelines.
 
 Step W5 After execution:
 - Show which file(s) updated and brief preview.
@@ -808,8 +796,8 @@ Commands:
   doctor     Check installation status
 
 Options:
-  --model <model>  Specify model for memory-bank-writer agent
-                   Default: cliproxy/claude-opus-4-5-20251101
+  --model <model>  Specify model for memory-reader agent
+                   Default: cliproxy/claude-opus-4-6
 
 Examples:
   bunx memory-bank-skill install

package/dist/memory-bank.js

@@ -17,15 +17,10 @@ var MEMORY_BANK_FILES = [
 var SENTINEL_OPEN = "<memory-bank-bootstrap>";
 var SENTINEL_CLOSE = "</memory-bank-bootstrap>";
 var SERVICE_NAME = "memory-bank";
-var PLUGIN_PROMPT_VARIANT = "memory-bank-plugin";
 var rootStates = new Map;
 var sessionMetas = new Map;
 var memoryBankExistsCache = new Map;
 var fileCache = new Map;
-var WRITER_AGENT_NAME = "memory-bank-writer";
-var sessionsById = new Map;
-var writerSessionIDs = new Set;
-var agentBySessionID = new Map;
 function makeStateKey(sessionId, root) {
   return `${sessionId}::${root}`;
 }
@@ -34,44 +29,6 @@ function maxChars() {
   const n = raw ? Number(raw) : NaN;
   return Number.isFinite(n) && n > 0 ? Math.floor(n) : DEFAULT_MAX_CHARS;
 }
-function isPluginGeneratedPrompt(message, content) {
-  if (message?.variant === PLUGIN_PROMPT_VARIANT)
-    return true;
-  return content.includes("## [Memory Bank]") || content.includes("## [SYSTEM REMINDER - Memory Bank");
-}
-function getMessageKey(message, rawContent) {
-  const id = message?.id || message?.messageID;
-  if (id)
-    return String(id);
-  const created = message?.time?.created;
-  if (typeof created === "number")
-    return `ts:${created}`;
-  const trimmed = rawContent.trim();
-  if (trimmed)
-    return `content:${trimmed.slice(0, 200)}`;
-  return null;
-}
-function getOrCreateMessageKey(meta, message, rawContent) {
-  const directKey = getMessageKey(message, rawContent);
-  if (directKey && !directKey.startsWith("content:"))
-    return directKey;
-  const trimmed = rawContent.trim();
-  if (!trimmed)
-    return directKey ?? null;
-  const now = Date.now();
-  const digest = trimmed.slice(0, 200);
-  const sameAsLast = meta.lastUserMessageDigest === digest;
-  const withinWindow = typeof meta.lastUserMessageAt === "number" && now - meta.lastUserMessageAt < 2000;
-  if (sameAsLast && withinWindow && meta.lastUserMessageKey) {
-    return meta.lastUserMessageKey;
-  }
-  meta.userMessageSeq += 1;
-  const key = `seq:${meta.userMessageSeq}`;
-  meta.lastUserMessageDigest = digest;
-  meta.lastUserMessageAt = now;
-  meta.lastUserMessageKey = key;
-  return key;
-}
 function createLogger(client) {
   let pending = Promise.resolve();
   const formatArgs = (args) => {
@@ -123,20 +80,11 @@ function truncateToBudget(text, budget) {
     return TRUNCATION_NOTICE.slice(0, budget);
   return text.slice(0, budget - reserve) + TRUNCATION_NOTICE;
 }
-async function buildMemoryBankContextWithMeta(projectRoot) {
-  const fnStart = Date.now();
-  if (DEBUG)
-    console.error(`[MB-DEBUG] buildMemoryBankContextWithMeta START projectRoot=${projectRoot}`);
+async function buildMemoryBankContext(projectRoot) {
   const parts = [];
-  const files = [];
   for (const rel of MEMORY_BANK_FILES) {
-    const fileStart = Date.now();
     const abs = path.join(projectRoot, rel);
-    if (DEBUG)
-      console.error(`[MB-DEBUG] reading ${rel}...`);
     const content = await readTextCached(abs);
-    if (DEBUG)
-      console.error(`[MB-DEBUG] read ${rel} done, hasContent=${!!content}, elapsed=${Date.now() - fileStart}ms`);
     if (!content)
       continue;
     const trimmed = content.trim();
@@ -145,41 +93,14 @@ async function buildMemoryBankContextWithMeta(projectRoot) {
     parts.push(`## ${rel}
 
 ${trimmed}`);
-    files.push({ relPath: rel, chars: trimmed.length });
   }
-  if (DEBUG)
-    console.error(`[MB-DEBUG] all files read, parts=${parts.length}, totalElapsed=${Date.now() - fnStart}ms`);
   if (parts.length === 0)
     return null;
-  const fileList = files.map((f) => f.relPath.replace("memory-bank/", "")).join(", ");
-  const totalChars = files.reduce((sum, f) => sum + f.chars, 0);
   const header = `# Memory Bank Bootstrap (Auto-injected by OpenCode plugin)
 
 ` + `Use \`memory-bank/_index.md\` to locate additional context files.
 ` + `Read more files from \`memory-bank/\` as needed based on the task.
 
-` + `**AI 行为指令**：
-` + `- 每次回复末尾加一行确认：\`| \uD83D\uDCDA Memory Bank | ${fileList} (${totalChars.toLocaleString()} chars) |\`
-` + `- **Memory-first（核心原则）**：
-` + `  - 任何问题先查 _index.md 并打开相关文档（active.md/brief.md/tech.md/docs/requirements/learnings/patterns.md）
-` + `  - 找到答案 → 引用文件路径直接回答；_index.md 与对应目录检索无果或确认已过时 → 才读代码
-` + `  - 文档与代码不一致时以代码为准，但必须提议更新文档
-` + `  - 若因文档缺失而读了代码 → 这本身就是写入触发点，需点名要补的文件路径
-` + `- **文档驱动开发**：
-` + `  - 方案讨论完成后，**先写设计文档到 memory-bank/docs/，再写代码**
-` + `  - 设计文档是契约，代码实现要符合文档
-` + `  - 实现完成后回顾：如有偏差，决定是改文档还是改实现
-` + `- **写入触发场景**（语义判断，非关键词匹配）：
-` + `  - 方案讨论确定 / 设计变更（"重新设计"、"改一下设计"、"那就这样吧"）→ 检查 docs/design-*.md 是否已存在，存在则更新，否则创建
-` + `  - 用户描述新功能/需求（"我需要..."、"能不能加..."、"帮我做..."、"要实现..."）→ requirements/
-` + `  - 用户做出技术选型（"我们用 X 吧"、"决定采用..."、"选择..."）→ patterns.md
-` + `  - 修复了 bug 或踩坑经验（"原来问题是..."、"这个坑是..."、"发现..."）→ learnings/
-` + `  - AI 修改了代码/配置文件 → active.md（如涉及 bug 修复则同时 learnings/）
-` + `  - 当前任务完成，焦点切换 → active.md
-` + `- **Todo 创建规则（必须）**：
-` + `  - 方案讨论完成后开始落地：第一项必须是"写入设计文档到 memory-bank/docs/"
-` + `  - 最后一项必须是"更新 Memory Bank"（检查触发场景并更新相应文件）
-
 ` + `---
 
 `;
@@ -190,14 +111,7 @@ ${trimmed}`);
 
 `) + `
 ${SENTINEL_CLOSE}`;
-  const budget = maxChars();
-  const truncated = wrapped.length > budget;
-  const text = truncateToBudget(wrapped, budget);
-  return { text, files, totalChars, truncated };
-}
-async function buildMemoryBankContext(projectRoot) {
-  const result = await buildMemoryBankContextWithMeta(projectRoot);
-  return result?.text ?? null;
+  return truncateToBudget(wrapped, maxChars());
 }
 async function checkMemoryBankExists(root, log) {
   if (memoryBankExistsCache.has(root)) {
@@ -222,7 +136,7 @@ async function checkMemoryBankExists(root, log) {
 function getSessionMeta(sessionId, fallbackRoot) {
   let meta = sessionMetas.get(sessionId);
   if (!meta) {
-    meta = { rootsTouched: new Set, lastActiveRoot: fallbackRoot, notifiedMessageIds: new Set, planOutputted: false, promptInProgress: false, userMessageReceived: false, sessionNotified: false, userMessageSeq: 0 };
+    meta = { rootsTouched: new Set, lastActiveRoot: fallbackRoot };
     sessionMetas.set(sessionId, meta);
   }
   return meta;
@@ -351,70 +265,11 @@ var plugin = async ({ client, directory, worktree }) => {
   const projectRoot = worktree || directory;
   const log = createLogger(client);
   log.info("Plugin initialized (unified)", { projectRoot });
-  async function sendContextNotification(sessionId, messageKey, messageId) {
-    if (isDisabled())
-      return;
-    const meta = getSessionMeta(sessionId, projectRoot);
-    if (meta.promptInProgress) {
-      log.debug("Context notification skipped (prompt in progress)", { sessionId, messageId });
-      return;
-    }
-    if (meta.notifiedMessageIds.has(messageKey)) {
-      log.debug("Context notification skipped (already notified for this message)", { sessionId, messageKey, messageId });
-      return;
-    }
-    const result = await buildMemoryBankContextWithMeta(projectRoot);
-    if (!result) {
-      log.debug("Context notification skipped (no memory-bank)", { sessionId });
-      return;
-    }
-    const fileList = result.files.map((f) => f.relPath.replace("memory-bank/", "")).join(", ");
-    const truncatedNote = result.truncated ? " (truncated)" : "";
-    const text = `## [Memory Bank]
-
-**已读取 Memory Bank 文件**: ${fileList} (${result.totalChars.toLocaleString()} chars)${truncatedNote}
-
-**写入提醒**：如果本轮涉及以下事件，工作完成后输出更新计划：
-- 新需求 → requirements/
-- 技术决策 → patterns.md
-- Bug修复/踩坑 → learnings/
-- 焦点变更 → active.md
-
-操作：请加载 memory-bank skill，按规范输出更新计划或更新内容（无需 slash command）。`;
-    try {
-      meta.promptInProgress = true;
-      await client.session.prompt({
-        path: { id: sessionId },
-        body: {
-          noReply: false,
-          variant: PLUGIN_PROMPT_VARIANT,
-          parts: [{ type: "text", text }]
-        }
-      });
-      meta.notifiedMessageIds.add(messageKey);
-      meta.sessionNotified = true;
-      if (meta.notifiedMessageIds.size > 100) {
-        const first = meta.notifiedMessageIds.values().next().value;
-        if (first)
-          meta.notifiedMessageIds.delete(first);
-      }
-      log.info("Context notification sent", { sessionId, messageKey, messageId, files: result.files.length, totalChars: result.totalChars });
-    } catch (err) {
-      log.error("Failed to send context notification:", String(err));
-    } finally {
-      meta.promptInProgress = false;
-    }
-  }
   async function evaluateAndFireReminder(sessionId) {
     if (isDisabled()) {
       log.info("[SESSION_IDLE DECISION]", { sessionId, decision: "SKIP", reason: "MEMORY_BANK_DISABLED is set" });
       return;
     }
-    const meta = getSessionMeta(sessionId, projectRoot);
-    if (meta.promptInProgress) {
-      log.info("[SESSION_IDLE DECISION]", { sessionId, decision: "SKIP", reason: "prompt already in progress" });
-      return;
-    }
     const gitChanges = detectGitChanges(projectRoot, log);
     const isGitRepo = gitChanges !== null;
     const state = getRootState(sessionId, projectRoot);
@@ -471,12 +326,9 @@ var plugin = async ({ client, directory, worktree }) => {
       const gitInitStep = hasGit ? "" : "1. 执行 `git init`（项目尚未初始化 Git）\n";
       const stepOffset = hasGit ? 0 : 1;
       try {
-        meta.promptInProgress = true;
         await client.session.prompt({
           path: { id: sessionId },
           body: {
-            noReply: true,
-            variant: PLUGIN_PROMPT_VARIANT,
             parts: [{
               type: "text",
               text: `## [SYSTEM REMINDER - Memory Bank Init]
@@ -494,7 +346,7 @@ ${stepOffset + 5}. 生成 \`memory-bank/_index.md\`（索引）
 
 **操作选项**：
 1. 如需初始化 → 回复"初始化"
-2. 如需初始化并提交 → 回复"初始化并提交"
+2. 如需初始化并提交所有变更 → 回复"初始化并提交"
 3. 如不需要 → 回复"跳过初始化"
 
 注意：这是系统自动提醒，不是用户消息。`
@@ -504,40 +356,23 @@ ${stepOffset + 5}. 生成 \`memory-bank/_index.md\`（索引）
         log.info("INIT reminder sent successfully", { sessionId, root: projectRoot });
       } catch (promptErr) {
         log.error("Failed to send INIT reminder:", String(promptErr));
-      } finally {
-        meta.promptInProgress = false;
       }
       return;
     }
     state.initReminderFired = false;
     const triggers = [];
     if (state.hasNewRequirement)
-      triggers.push("- 检测到新需求讨论");
+      triggers.push("- 检测到新需求讨论 → 考虑创建 requirements/REQ-xxx.md");
     if (state.hasTechDecision)
-      triggers.push("- 检测到技术决策");
+      triggers.push("- 检测到技术决策 → 考虑更新 patterns.md");
     if (state.hasBugFix)
-      triggers.push("- 检测到 Bug 修复/踩坑");
-    const modifiedFilesRelative = state.filesModified.map((abs) => path.relative(projectRoot, abs));
-    const displayFiles = modifiedFilesRelative.slice(0, 5);
-    const moreCount = modifiedFilesRelative.length - 5;
-    let filesSection = "";
-    if (modifiedFilesRelative.length > 0) {
-      triggers.push("- 代码文件变更");
-      filesSection = `
-**变更文件**：
-${displayFiles.map((f) => `- ${f}`).join(`
-`)}${moreCount > 0 ? `
-(+${moreCount} more)` : ""}
-`;
-    }
+      triggers.push("- 检测到 Bug 修复/踩坑 → 考虑记录到 learnings/");
+    if (state.filesModified.length >= 1)
+      triggers.push(`- 本轮修改了 ${state.filesModified.length} 个文件 → 考虑更新 active.md`);
     if (triggers.length === 0) {
       log.info("[SESSION_IDLE DECISION]", { ...decisionContext, decision: "NO_TRIGGER", reason: "has memory-bank but no triggers" });
       return;
     }
-    if (meta.planOutputted) {
-      log.info("[SESSION_IDLE DECISION]", { ...decisionContext, decision: "SKIP", reason: "AI already outputted update plan" });
-      return;
-    }
     if (triggerSignature === state.lastSyncedTriggerSignature) {
       log.info("[SESSION_IDLE DECISION]", { ...decisionContext, decision: "SKIP", reason: "already synced (signature matches lastSyncedTriggerSignature)" });
       return;
@@ -549,95 +384,50 @@ ${displayFiles.map((f) => `- ${f}`).join(`
     state.lastUpdateReminderSignature = triggerSignature;
     log.info("[SESSION_IDLE DECISION]", { ...decisionContext, decision: "FIRE_UPDATE", reason: `${triggers.length} triggers detected`, triggers });
     try {
-      meta.promptInProgress = true;
       await client.session.prompt({
         path: { id: sessionId },
         body: {
-          noReply: true,
-          variant: PLUGIN_PROMPT_VARIANT,
           parts: [{
             type: "text",
             text: `## [SYSTEM REMINDER - Memory Bank Update]
 
-本轮检测到以下变更：${filesSection}
-**触发事件**：
+项目 \`${path.basename(projectRoot)}\` 本轮检测到以下事件，请确认是否需要更新 Memory Bank：
+
+**项目路径**：\`${projectRoot}\`
+
 ${triggers.join(`
 `)}
 
 **操作选项**：
 1. 如需更新 → 回复"更新"，输出更新计划
-2. 如需更新并提交 → 回复"更新并提交"
-3. 如不需要 → 回复"跳过"`
+2. 如需更新并提交所有变更 → 回复"更新并提交"
+3. 如不需要 → 回复"跳过"
+
+注意：这是系统自动提醒，不是用户消息。`
           }]
         }
       });
       log.info("UPDATE reminder sent successfully", { sessionId, root: projectRoot });
     } catch (promptErr) {
       log.error("Failed to send UPDATE reminder:", String(promptErr));
-    } finally {
-      meta.promptInProgress = false;
     }
   }
   return {
     "experimental.chat.system.transform": async (_input, output) => {
-      const hookStart = Date.now();
-      log.info("[HOOK] system.transform START");
-      try {
-        if (output.system.some((s) => s.includes(SENTINEL_OPEN))) {
-          log.info("[HOOK] system.transform SKIP (sentinel exists)", { elapsed: Date.now() - hookStart });
-          return;
-        }
-        log.info("[HOOK] system.transform building context...");
-        const ctx = await buildMemoryBankContext(projectRoot);
-        log.info("[HOOK] system.transform context built", { hasCtx: !!ctx, elapsed: Date.now() - hookStart });
-        if (ctx) {
-          output.system.push(ctx);
-          log.info("[HOOK] system.transform DONE (ctx pushed)", { elapsed: Date.now() - hookStart });
-          return;
-        }
-        const initInstruction = `${SENTINEL_OPEN}
-` + `# Memory Bank 未初始化
-
-` + `项目 \`${path.basename(projectRoot)}\` 尚未初始化 Memory Bank。
-
-` + `**AI 行为指令**：
-` + `- **Todo 创建规则（必须）**：创建 todo 时，第一项必须是"初始化 Memory Bank"（扫描项目结构，创建 brief.md + tech.md + _index.md），最后一项必须是"更新 Memory Bank"（更新 active.md）
-` + `${SENTINEL_CLOSE}`;
-        output.system.push(initInstruction);
-        log.info("[HOOK] system.transform DONE (init pushed)", { elapsed: Date.now() - hookStart });
-      } catch (err) {
-        log.error("[HOOK] system.transform ERROR", String(err), { elapsed: Date.now() - hookStart });
-      }
+      if (output.system.some((s) => s.includes(SENTINEL_OPEN)))
+        return;
+      const ctx = await buildMemoryBankContext(projectRoot);
+      if (!ctx)
+        return;
+      output.system.push(ctx);
     },
     "experimental.session.compacting": async (_input, output) => {
-      const hookStart = Date.now();
-      log.info("[HOOK] session.compacting START");
-      try {
-        if (output.context.some((s) => s.includes(SENTINEL_OPEN))) {
-          log.info("[HOOK] session.compacting SKIP (sentinel exists)", { elapsed: Date.now() - hookStart });
-          return;
-        }
-        log.info("[HOOK] session.compacting building context...");
-        const ctx = await buildMemoryBankContext(projectRoot);
-        log.info("[HOOK] session.compacting context built", { hasCtx: !!ctx, elapsed: Date.now() - hookStart });
-        if (ctx) {
-          output.context.push(ctx);
-          log.info("[HOOK] session.compacting DONE (ctx pushed)", { elapsed: Date.now() - hookStart });
-          return;
-        }
-        const initInstruction = `${SENTINEL_OPEN}
-` + `# Memory Bank 未初始化
-
-` + `项目 \`${path.basename(projectRoot)}\` 尚未初始化 Memory Bank。
-
-` + `**AI 行为指令**：
-` + `- **Todo 创建规则（必须）**：创建 todo 时，第一项必须是"初始化 Memory Bank"（扫描项目结构，创建 brief.md + tech.md + _index.md），最后一项必须是"更新 Memory Bank"（更新 active.md）
-` + `${SENTINEL_CLOSE}`;
-        output.context.push(initInstruction);
-        log.info("[HOOK] session.compacting DONE (init pushed)", { elapsed: Date.now() - hookStart });
-      } catch (err) {
-        log.error("[HOOK] session.compacting ERROR", String(err), { elapsed: Date.now() - hookStart });
-      }
+      if (output.context.some((s) => s.includes(SENTINEL_OPEN)))
+        return;
+      const ctx = await buildMemoryBankContext(projectRoot);
+      if (!ctx)
+        return;
+      output.context.push(ctx);
     },
     event: async ({ event }) => {
       try {
@@ -656,10 +446,8 @@ ${triggers.join(`
           return;
         }
         if (event.type === "session.created") {
-          sessionMetas.set(sessionId, { rootsTouched: new Set, lastActiveRoot: projectRoot, notifiedMessageIds: new Set, planOutputted: false, promptInProgress: false, userMessageReceived: false, sessionNotified: false, userMessageSeq: 0 });
-          const parentID = info?.parentID;
-          sessionsById.set(sessionId, { parentID });
-          log.info("Session created", { sessionId, parentID });
+          sessionMetas.set(sessionId, { rootsTouched: new Set, lastActiveRoot: projectRoot });
+          log.info("Session created", { sessionId });
         }
         if (event.type === "session.deleted") {
           const meta = sessionMetas.get(sessionId);
@@ -669,34 +457,13 @@ ${triggers.join(`
             }
           }
           sessionMetas.delete(sessionId);
-          sessionsById.delete(sessionId);
-          writerSessionIDs.delete(sessionId);
-          agentBySessionID.delete(sessionId);
           log.info("Session deleted", { sessionId });
         }
         if (event.type === "message.updated") {
           const message = info;
-          const meta = getSessionMeta(sessionId, projectRoot);
-          const rawContent = JSON.stringify(message?.content || "");
-          if (DEBUG) {
-            log.debug("message.updated received", {
-              sessionId,
-              role: message?.role,
-              agent: message?.agent,
-              variant: message?.variant,
-              messageId: message?.id || message?.messageID
-            });
-          }
-          if (isPluginGeneratedPrompt(message, rawContent)) {
-            log.debug("message.updated skipped (plugin prompt)", { sessionId });
-            return;
-          }
           if (message?.role === "user") {
-            if (meta.promptInProgress) {
-              log.debug("message.updated skipped (prompt in progress)", { sessionId });
-              return;
-            }
-            const content = rawContent.toLowerCase();
+            const content = JSON.stringify(message.content || "").toLowerCase();
+            const meta = getSessionMeta(sessionId, projectRoot);
             const targetRoot = meta.lastActiveRoot || projectRoot;
             const state = getRootState(sessionId, targetRoot);
             if (/新需求|new req|feature request|需要实现|要做一个/.test(content)) {
@@ -718,124 +485,22 @@ ${triggers.join(`
               state.memoryBankReviewed = true;
               log.info("Escape valve triggered: memoryBankReviewed", { sessionId, root: targetRoot });
             }
-            const messageId = message.id || message.messageID;
-            const messageKey = getOrCreateMessageKey(meta, message, rawContent);
-            if (!messageKey) {
-              log.debug("Context notification skipped (no message key)", { sessionId, messageId });
-              return;
-            }
-            log.debug("Context notification disabled (using system prompt instruction instead)", { sessionId, messageKey, messageId });
-            meta.userMessageReceived = true;
-            meta.planOutputted = false;
           }
-          if (message?.role === "assistant") {
-            const content = JSON.stringify(message.content || "");
-            const meta2 = getSessionMeta(sessionId, projectRoot);
-            if (/Memory Bank 更新计划|\[Memory Bank 更新计划\]/.test(content)) {
-              meta2.planOutputted = true;
-              log.info("Plan outputted detected", { sessionId });
-            }
-            const agentName = message?.agent;
-            if (agentName) {
-              agentBySessionID.set(sessionId, agentName);
-              const sessionInfo = sessionsById.get(sessionId);
-              if (agentName === WRITER_AGENT_NAME && sessionInfo?.parentID) {
-                writerSessionIDs.add(sessionId);
-                log.info("Writer agent session registered", { sessionId, agentName, parentID: sessionInfo.parentID });
-              }
-            }
+        }
+        if (event.type === "session.idle") {
+          log.info("Session idle event received", { sessionId });
+          await evaluateAndFireReminder(sessionId);
+        }
+        if (event.type === "session.status") {
+          const status = event.properties?.status;
+          if (status?.type === "idle") {
+            log.info("Session status idle received", { sessionId });
+            await evaluateAndFireReminder(sessionId);
           }
         }
       } catch (err) {
         log.error("event handler error:", String(err));
       }
-    },
-    "tool.execute.before": async (input, output) => {
-      const { tool, sessionID } = input;
-      const isMemoryBankPath = (targetPath) => {
-        const absPath = path.isAbsolute(targetPath) ? targetPath : path.resolve(projectRoot, targetPath);
-        const relativePath = path.relative(projectRoot, absPath);
-        if (relativePath === ".." || relativePath.startsWith(".." + path.sep))
-          return false;
-        return relativePath === "memory-bank" || relativePath.startsWith("memory-bank" + path.sep) || relativePath.startsWith("memory-bank/");
-      };
-      const isWriterAllowed = (sid) => {
-        if (writerSessionIDs.has(sid))
-          return true;
-        const sessionInfo = sessionsById.get(sid);
-        const agentName = agentBySessionID.get(sid);
-        if (agentName === WRITER_AGENT_NAME && sessionInfo?.parentID) {
-          writerSessionIDs.add(sid);
-          log.info("Writer agent late-registered", { sessionID: sid, agentName });
-          return true;
-        }
-        return false;
-      };
-      const blockWrite = (reason, context) => {
-        log.warn("Memory Bank write blocked", { sessionID, tool, reason, ...context });
-        throw new Error(`[Memory Bank Guard] 写入 memory-bank/ 受限。
-` + `请使用 delegate_task 调用 memory-bank-writer agent 来更新 Memory Bank。
-` + `示例: delegate_task(subagent_type="memory-bank-writer", load_skills=["memory-bank-writer"], prompt="更新...")`);
-      };
-      if (tool === "Write" || tool === "Edit") {
-        const targetPath = output.args?.filePath ?? output.args?.path ?? output.args?.filename;
-        if (!targetPath)
-          return;
-        if (!isMemoryBankPath(targetPath))
-          return;
-        if (!targetPath.endsWith(".md")) {
-          blockWrite("only .md files allowed", { targetPath });
-        }
-        if (isWriterAllowed(sessionID)) {
-          log.debug("Writer agent write allowed", { sessionID, tool, targetPath });
-          return;
-        }
-        blockWrite("not writer agent", {
-          targetPath,
-          isSubAgent: !!sessionsById.get(sessionID)?.parentID,
-          agentName: agentBySessionID.get(sessionID)
-        });
-      }
-      if (tool.toLowerCase() === "bash") {
-        const command = output.args?.command;
-        if (!command || typeof command !== "string")
-          return;
-        if (!/(?:^|[^A-Za-z0-9_-])memory-bank(?:$|[^A-Za-z0-9_-])/.test(command) && !command.startsWith("memory-bank"))
-          return;
-        const hasShellOperators = /[;&|]|\$\(|`/.test(command);
-        if (!hasShellOperators) {
-          const readOnlyPatterns = [
-            /^\s*(ls|cat|head|tail|less|more|grep|rg|ag|find|tree|wc|file|stat)\b/,
-            /^\s*git\s+(status|log|diff|show|blame)\b/
-          ];
-          if (readOnlyPatterns.some((p) => p.test(command)))
-            return;
-        }
-        const writePatterns = [
-          /(?:^|[^2])>/,
-          />>/,
-          /<</,
-          /\|/,
-          /\btee\b/,
-          /\bsed\s+-i/,
-          /\bperl\s+-[ip]/,
-          /\bcp\b/,
-          /\bmv\b/,
-          /\brm\b/,
-          /\bmkdir\b/,
-          /\btouch\b/,
-          /\bgit\s+(add|rm|mv|apply|checkout|restore|reset|clean|stash|commit)\b/,
-          /\bpython\b.*\bopen\b/
-        ];
-        const isWriteOperation = writePatterns.some((p) => p.test(command));
-        if (!isWriteOperation)
-          return;
-        if (isWriterAllowed(sessionID)) {
-          log.debug("Writer agent bash write allowed", { sessionID, command: command.slice(0, 100) });
-          return;
-        }
-        blockWrite("bash write operation", { command: command.slice(0, 200) });
-      }
     }
   };
 };

package/dist/plugin.js

@@ -45,10 +45,7 @@ var rootStates = new Map;
 var sessionMetas = new Map;
 var memoryBankExistsCache = new Map;
 var fileCache = new Map;
-var WRITER_AGENT_NAME = "memory-bank-writer";
 var sessionsById = new Map;
-var writerSessionIDs = new Set;
-var agentBySessionID = new Map;
 var messageGatingStates = new Map;
 var sessionAnchorStates = new Map;
 function makeStateKey(sessionId, root) {
@@ -213,7 +210,7 @@ drill_down: Step1 direct-read 1-3 details/*; Step2 \u9700\u8981\u8BC1\u636E/\u51
 output: \u56DE\u7B54\u5FC5\u987B\u7ED9\u5F15\u7528\u6307\u9488
 gating: \u9AD8\u98CE\u9669\u5199\u524D\u9700\u5DF2\u8BFB patterns.md \u6216\u8C03\u7528\u8FC7 memory-reader
 
-write: proxy_task(subagent_type="memory-bank-writer", prompt="Target:...\\nDraft:...")
+write: \u4E3B agent \u76F4\u63A5 write/edit \u5199\u5165 memory-bank/\u3002\u5199\u5165\u524D Proposal \u2192 \u7528\u6237\u786E\u8BA4\u3002Plugin \u6CE8\u5165 writing guide\uFF08advisory\uFF09\u3002
 more: \u5B8C\u6574\u89C4\u8303\u89C1 /memory-bank skill
 `;
     } else {
@@ -228,7 +225,7 @@ drill_down: Step1 direct-read 1-3 details/*; Step2 \u9700\u8981\u8BC1\u636E/\u51
 output: \u56DE\u7B54\u5FC5\u987B\u7ED9\u5F15\u7528\u6307\u9488
 gating: \u9AD8\u98CE\u9669\u5199\u524D\u9700\u5DF2\u8BFB patterns.md \u6216\u8C03\u7528\u8FC7 memory-reader
 
-write: proxy_task(subagent_type="memory-bank-writer", prompt="Target:...\\nDraft:...")
+write: \u4E3B agent \u76F4\u63A5 write/edit \u5199\u5165 memory-bank/\u3002\u5199\u5165\u524D Proposal \u2192 \u7528\u6237\u786E\u8BA4\u3002Plugin \u6CE8\u5165 writing guide\uFF08advisory\uFF09\u3002
 more: \u5B8C\u6574\u89C4\u8303\u89C1 /memory-bank skill
 `;
     }
@@ -963,8 +960,6 @@ ${triggers.join(`
           }
           sessionMetas.delete(sessionId);
           sessionsById.delete(sessionId);
-          writerSessionIDs.delete(sessionId);
-          agentBySessionID.delete(sessionId);
           sessionAnchorStates.delete(sessionId);
           log.info("Session deleted", { sessionId });
         }
@@ -1029,15 +1024,6 @@ ${triggers.join(`
               meta2.planOutputted = true;
               log.info("Plan outputted detected", { sessionId });
             }
-            const agentName = message?.agent;
-            if (agentName) {
-              agentBySessionID.set(sessionId, agentName);
-              const sessionInfo = sessionsById.get(sessionId);
-              if (agentName === WRITER_AGENT_NAME && sessionInfo?.parentID) {
-                writerSessionIDs.add(sessionId);
-                log.info("Writer agent session registered", { sessionId, agentName, parentID: sessionInfo.parentID });
-              }
-            }
           }
         }
       } catch (err) {
@@ -1351,7 +1337,7 @@ Or call: proxy_task({ subagent_type: "memory-reader", ... })`);
 ` + `  - \u91CD\u6784 / \u4F18\u5316 \u2192 design/design-xxx.md
 ` + `  - \u7B80\u5355\u53D8\u66F4 \u2192 \u8FFD\u52A0\u5230 progress.md
 
-` + `\u8C03\u7528\u65B9\u5F0F: proxy_task({ subagent_type: "memory-bank-writer", ... })
+` + `\u4F7F\u7528 write/edit \u5DE5\u5177\u76F4\u63A5\u5199\u5165 memory-bank/ \u4E0B\u5BF9\u5E94\u6587\u4EF6
 ` + `\u786E\u8BA4\u6587\u6863\u65E0\u8BEF\u540E\u518D\u6267\u884C\u4EE3\u7801\u4FEE\u6539\u3002`);
             } else {
               dfState.docFirstWarned = true;
@@ -1381,7 +1367,7 @@ Or call: proxy_task({ subagent_type: "memory-reader", ... })`);
 ` + `  - \u91CD\u6784 / \u4F18\u5316 \u2192 design/design-xxx.md
 ` + `  - \u7B80\u5355\u53D8\u66F4 \u2192 \u8FFD\u52A0\u5230 progress.md
 
-` + `\u8C03\u7528\u65B9\u5F0F: \`proxy_task({ subagent_type: "memory-bank-writer", ... })\``
+` + `\u4F7F\u7528 write/edit \u5DE5\u5177\u76F4\u63A5\u5199\u5165 memory-bank/ \u4E0B\u5BF9\u5E94\u6587\u4EF6`
                   }]
                 }
               }).catch((err) => log.error("Failed to send doc-first warning:", String(err)));
@@ -1389,43 +1375,30 @@ Or call: proxy_task({ subagent_type: "memory-reader", ... })`);
           }
         }
       }
-      const markParentDocFirstSatisfied = (writerSessionID) => {
-        const parentID = sessionsById.get(writerSessionID)?.parentID;
-        if (!parentID)
-          return;
-        const parentMeta = getSessionMeta(parentID, projectRoot);
-        const parentMsgKey = parentMeta.lastUserMessageKey;
-        if (parentMsgKey) {
-          const parentGatingKey = `${parentID}::${parentMsgKey}`;
-          const parentGating = getMessageGatingState(parentGatingKey, parentID, projectRoot);
-          parentGating.docFirstSatisfied = true;
-          log.debug("Doc-First: parent satisfied via writer write", { writerSessionID, parentID, parentGatingKey });
-        }
-        const defaultGatingKey = `${parentID}::default`;
-        const defaultState = messageGatingStates.get(defaultGatingKey);
-        if (defaultState) {
-          defaultState.docFirstSatisfied = true;
-        }
-        parentMeta.pendingDocFirstSatisfied = true;
-      };
-      const isWriterAllowed = (sid) => {
-        if (writerSessionIDs.has(sid))
-          return true;
-        const sessionInfo = sessionsById.get(sid);
-        const agentName = agentBySessionID.get(sid);
-        if (agentName === WRITER_AGENT_NAME && sessionInfo?.parentID) {
-          writerSessionIDs.add(sid);
-          log.info("Writer agent late-registered", { sessionID: sid, agentName });
-          return true;
-        }
-        return false;
-      };
-      const blockWrite = (reason, context) => {
-        log.warn("Memory Bank write blocked", { sessionID, tool, reason, ...context });
-        throw new Error(`[Memory Bank Guard] \u5199\u5165 memory-bank/ \u53D7\u9650\u3002
-` + `\u8BF7\u4F7F\u7528 proxy_task \u8C03\u7528 memory-bank-writer agent \u6765\u66F4\u65B0 Memory Bank\u3002
-` + `\u793A\u4F8B: proxy_task({ subagent_type: "memory-bank-writer", description: "Memory Bank write", prompt: "Target: memory-bank/details/patterns.md\\nDraft:\\n1) ..." })`);
-      };
+      async function injectWritingGuideline(sid) {
+        client.session.prompt({
+          path: { id: sid },
+          body: {
+            noReply: true,
+            variant: PLUGIN_PROMPT_VARIANT,
+            parts: [{
+              type: "text",
+              text: `## [Memory Bank Writing Guide]
+
+` + `\u6B63\u5728\u5199\u5165 memory-bank/\uFF0C\u8BF7\u5148\u52A0\u8F7D\u5199\u5165\u89C4\u8303\uFF1A
+` + `read({ filePath: "~/.config/opencode/skills/memory-bank/references/writer.md" })`
+            }]
+          }
+        }).catch((err) => log.error("Failed to send writing guideline:", String(err)));
+      }
+      function markDocFirstSatisfied(sid) {
+        const meta = getSessionMeta(sid, projectRoot);
+        const messageKey = meta.lastUserMessageKey || "default";
+        const gatingKey = `${sid}::${messageKey}`;
+        const gatingState = getMessageGatingState(gatingKey, sid, projectRoot);
+        gatingState.docFirstSatisfied = true;
+        log.debug("Doc-First: satisfied via direct memory-bank write", { sessionID: sid, gatingKey });
+      }
       const extractPaths = (toolName, args) => {
         const paths = [];
         const pathArgs = ["filePath", "path", "filename", "file", "dest", "destination", "target"];
@@ -1470,18 +1443,13 @@ Or call: proxy_task({ subagent_type: "memory-reader", ... })`);
           if (!await isMemoryBankPath(targetPath))
             continue;
           if (!targetPath.toLowerCase().endsWith(".md")) {
-            blockWrite("only .md files allowed", { targetPath });
-          }
-          if (isWriterAllowed(sessionID)) {
-            log.debug("Writer agent write allowed", { sessionID, tool, targetPath });
-            markParentDocFirstSatisfied(sessionID);
-            return;
+            log.warn("Memory Bank write blocked (non-.md file)", { sessionID, tool, targetPath });
+            throw new Error(`[Memory Bank Guard] memory-bank/ \u4E0B\u53EA\u5141\u8BB8\u5199\u5165 .md \u6587\u4EF6\u3002
+` + `\u76EE\u6807\u6587\u4EF6: ${targetPath}`);
           }
-          blockWrite("not writer agent", {
-            targetPath,
-            isSubAgent: !!sessionsById.get(sessionID)?.parentID,
-            agentName: agentBySessionID.get(sessionID)
-          });
+          await injectWritingGuideline(sessionID);
+          markDocFirstSatisfied(sessionID);
+          log.debug("Memory Bank write allowed", { sessionID, tool, targetPath });
         }
       }
       if (tool.toLowerCase() === "bash") {
@@ -1623,13 +1591,8 @@ Or call: proxy_task({ subagent_type: "memory-reader", ... })`);
           if (redirectTarget && redirectTarget.includes("memory-bank")) {
             const resolvedTarget = path.resolve(projectRoot, redirectTarget);
             if (await isMemoryBankPath(resolvedTarget)) {
-              if (isWriterAllowed(sessionID)) {
-                log.debug("Writer agent bash redirect allowed", { sessionID, command: command.slice(0, 100) });
-                markParentDocFirstSatisfied(sessionID);
-                return;
-              }
-              blockWrite("bash redirect to memory-bank", { command: command.slice(0, 200), segment: segment.slice(0, 100) });
-              return;
+              log.warn("Memory Bank bash redirect blocked", { sessionID, command: command.slice(0, 200) });
+              throw new Error("[Memory Bank Guard] \u8BF7\u4F7F\u7528 write/edit \u5DE5\u5177\u5199\u5165 memory-bank/\uFF0C\u4E0D\u652F\u6301 bash \u5199\u5165\u3002");
             }
           }
           if (readOnlyPatterns.some((p) => p.test(segment))) {
@@ -1639,13 +1602,8 @@ Or call: proxy_task({ subagent_type: "memory-reader", ... })`);
               for (const pathArg of pathArgs2) {
                 const resolved = path.resolve(projectRoot, pathArg);
                 if (await isMemoryBankPath(resolved)) {
-                  if (isWriterAllowed(sessionID)) {
-                    log.debug("Writer agent find with dangerous flags allowed", { sessionID });
-                    markParentDocFirstSatisfied(sessionID);
-                    return;
-                  }
-                  blockWrite("find with dangerous flags on memory-bank", { command: command.slice(0, 200), segment: segment.slice(0, 100) });
-                  return;
+                  log.warn("Memory Bank bash find-write blocked", { sessionID, command: command.slice(0, 200) });
+                  throw new Error("[Memory Bank Guard] \u8BF7\u4F7F\u7528 write/edit \u5DE5\u5177\u5199\u5165 memory-bank/\uFF0C\u4E0D\u652F\u6301 bash \u5199\u5165\u3002");
                 }
               }
             }
@@ -1656,13 +1614,8 @@ Or call: proxy_task({ subagent_type: "memory-reader", ... })`);
           for (const pathArg of pathArgs) {
             const resolved = path.resolve(projectRoot, pathArg);
             if (await isMemoryBankPath(resolved)) {
-              if (isWriterAllowed(sessionID)) {
-                log.debug("Writer agent bash write allowed", { sessionID, command: command.slice(0, 100) });
-                markParentDocFirstSatisfied(sessionID);
-                return;
-              }
-              blockWrite("bash write to memory-bank", { command: command.slice(0, 200), pathArg, resolved });
-              return;
+              log.warn("Memory Bank bash write blocked", { sessionID, command: command.slice(0, 200), pathArg });
+              throw new Error("[Memory Bank Guard] \u8BF7\u4F7F\u7528 write/edit \u5DE5\u5177\u5199\u5165 memory-bank/\uFF0C\u4E0D\u652F\u6301 bash \u5199\u5165\u3002");
             }
           }
           log.debug("Bash command allowed (path not under root memory-bank/)", { segment: segment.slice(0, 100) });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memory-bank-skill",
-  "version": "7.3.2",
+  "version": "7.4.0",
   "description": "Memory Bank - 项目记忆系统，让 AI 助手在每次对话中都能快速理解项目上下文",
   "type": "module",
   "main": "dist/plugin.js",

package/skills/memory-bank/SKILL.md

@@ -121,12 +121,16 @@ proxy_task({
 
 ### 写入阶段
 
-**核心约束**：主 Agent **禁止直接写入** `memory-bank/`，必须 delegate 给 `memory-bank-writer`。
+**写入方式**：主 Agent 直接使用 `write`/`edit` 工具写入 `memory-bank/`。Plugin 会自动注入 writing guideline（advisory）。
 
 流程（跨 turn）：
 1. 主 Agent 检测到写入时机，用自然语言询问是否写入（含目标文件 + 要点）
 2. 用户自然语言确认（"好"/"写"/"确认"）或跳过（"不用"/"跳过"/继续下一话题）
-3. 下一 turn 调用：`proxy_task({ subagent_type: "memory-bank-writer", description: "Memory Bank write", prompt: "Target: ...\nDraft: ..." })`
+3. 主 Agent 直接使用 `write`/`edit` 工具写入目标文件
+
+**硬限制**：
+- 只允许写入 `.md` 文件（Plugin 强制）
+- 不允许通过 bash 写入（必须使用 write/edit 等结构化工具）
 
 详见 [writer.md](references/writer.md)
 

package/skills/memory-bank/references/writer.md

@@ -1,20 +1,32 @@
-# Memory Bank Writer 规则
+# Memory Bank 写入规则
 
-> 此文档定义 Memory Bank 的写入规则，由 Writer Agent 执行。
+> 此文档定义 Memory Bank 的写入规则。主 Agent 直接执行写入，Plugin 注入 writing guideline（advisory）。
 
-## 调用方式
+## 写入方式
 
-使用 `proxy_task`（Task tool）同步调用 memory-bank-writer：
+主 Agent 直接使用 `write`/`edit` 工具写入 `memory-bank/` 下的 `.md` 文件：
 
 ```typescript
-proxy_task({
-  subagent_type: "memory-bank-writer",
-  description: "Memory Bank write (confirmed)",
-  prompt: "You are updating Memory Bank.\nConstraints:\n- Edit ONLY the target file.\n- Keep changes minimal and consistent with existing format.\n- Do NOT invent facts.\nInput:\nTarget: {target_file}\nDraft:\n1) {bullet_1}\n2) {bullet_2}\nOutput: Show what file changed + brief preview of changes."
+// 示例：更新 patterns.md
+edit({
+  filePath: "memory-bank/details/patterns.md",
+  oldString: "...",
+  newString: "..."
+})
+
+// 示例：创建新需求文档
+write({
+  filePath: "memory-bank/details/requirements/REQ-007-xxx.md",
+  content: "# REQ-007: ...\n\n..."
 })
 ```
 
-## Writer 自动触发流程（跨 turn）
+**Plugin 保护**：
+- 只允许 `.md` 文件写入（非 `.md` 会被阻止）
+- 不允许通过 bash 写入（必须使用 write/edit 等结构化工具）
+- 写入时 Plugin 自动注入 writing guideline 提示
+
+## 写入触发流程（跨 turn）
 
 ### 触发时机
 
@@ -58,9 +70,9 @@ proxy_task({
 
 **混合意图**：如果用户确认同时问了其他问题（如"写吧，顺便问一下..."），先执行写入，再回答问题。
 
-**Step 3: 执行（下一 turn）**
+**Step 3: 执行（本 turn 或下一 turn）**
 
-收到确认后，调用 memory-bank-writer 执行写入，然后展示变更预览。
+收到确认后，直接使用 `write`/`edit` 工具写入，然后展示变更预览。
 
 ## Refresh 流程（/memory-bank-refresh）
 
@@ -297,34 +309,22 @@ USER_BLOCK 将保持不变。
 
 ---
 
-## 职责分离（Auto-Trigger 模式）
+## 写入流程
 
-**Proposal 流程**：主 Agent 提供 Target + Draft，用户确认后 Writer 执行。
+**Proposal 流程**：主 Agent 提议 → 用户确认 → 主 Agent 直接执行写入。
 
 | 步骤 | 负责方 | 动作 |
 |------|--------|------|
 | 1 | 主 Agent | 检测写入时机，自然语言询问是否写入 |
 | 2 | 用户 | 自然语言确认（"好"/"写"）或拒绝（"不用"/"跳过"） |
-| 3 | 主 Agent | 调用 `proxy_task({ subagent_type: "memory-bank-writer", ... })` |
-| 4 | **Writer** | 执行写入（可顺带更新 index.md / MEMORY.md） |
-
-### 主 Agent 的 prompt 格式（调用 Writer 时）
-
-```
-Target: memory-bank/details/patterns.md
-Draft:
-1) {bullet 1}
-2) {bullet 2}
-```
-
-**说明**：Auto-Trigger 模式下，主 Agent 在 Proposal 中明确指定 Target 文件，用户确认后 Writer 按指定目标执行。
+| 3 | 主 Agent | 直接使用 `write`/`edit` 工具写入目标文件 |
 
 ---
 
 ## 执行输出格式
 
 ```
-[Memory Bank Writer 执行完成]
+[Memory Bank 写入完成]
 
 已执行：
 - 创建: memory-bank/details/design/xxx.md
@@ -339,9 +339,10 @@ Draft:
 ## 守卫机制
 
 Plugin 层面强制执行：
-- 只有 `memory-bank-writer` agent 能写入 `memory-bank/`
-- 只允许写入 `.md` 文件
-- 主 agent 直接写入会被阻止
+- 主 Agent 直接使用 `write`/`edit` 写入 `memory-bank/`
+- 只允许写入 `.md` 文件（非 `.md` 会被阻止）
+- 不允许通过 bash 写入（必须使用结构化工具）
+- 写入时 Plugin 自动注入 writing guideline 提示
 
 ---
 
@@ -364,10 +365,8 @@ Plugin 层面强制执行：
 ## 禁止行为
 
 - 不要跳过 Glob 检查
-- 不要等待用户确认（确认已由主 Agent 前置完成）
 - 不要修改 `memory-bank/` 以外的文件
 - 不要删除文件（除非迁移流程明确要求）
-- 不要自行决定写入内容（内容由主 Agent 提供）
 
 ---