finch-markdown-editor 0.1.8 → 0.2.0

package/dist/index.js

@@ -1,11 +1,186 @@
 // src/index.ts
-import { createHash } from "node:crypto";
-import { mkdir, readFile, realpath, rm, stat, writeFile } from "node:fs/promises";
+import { createHash as createHash3 } from "node:crypto";
+import { mkdir as mkdir2, readFile as readFile2, realpath, stat, writeFile as writeFile2 } from "node:fs/promises";
 import { watch } from "node:fs";
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
+import path3 from "node:path";
+import os from "node:os";
+
+// src/document.ts
 import path from "node:path";
+function unwrapTextEnvelope(content) {
+  const bom = content.startsWith("\uFEFF") ? "\uFEFF" : "";
+  const text = bom ? content.slice(1) : content;
+  const firstCrLf = text.indexOf("\r\n");
+  const firstLf = text.indexOf("\n");
+  const lineEnding = firstCrLf !== -1 && (firstLf === -1 || firstCrLf <= firstLf) ? "\r\n" : "\n";
+  return { bom, lineEnding, text: text.replace(/\r\n/g, "\n").replace(/\r/g, "\n") };
+}
+function normalizeToLf(text) {
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function rewrapTextEnvelope(envelope, normalizedText) {
+  const restored = envelope.lineEnding === "\r\n" ? normalizedText.replace(/\n/g, "\r\n") : normalizedText;
+  return envelope.bom + restored;
+}
+function preserveTextEnvelope(existingContent, replacement) {
+  const envelope = unwrapTextEnvelope(existingContent);
+  return rewrapTextEnvelope(envelope, normalizeToLf(replacement.replace(/^\ufeff/, "")));
+}
+function applyEditSpecs(content, edits) {
+  const envelope = unwrapTextEnvelope(content);
+  let working = envelope.text;
+  for (let i = 0; i < edits.length; i++) {
+    const { old_string: rawOldString, new_string: rawNewString, replace_all: replaceAll } = edits[i];
+    if (typeof rawOldString !== "string" || rawOldString.length === 0) {
+      return { ok: false, error: `edits[${i}]: 'old_string' must be a non-empty string.` };
+    }
+    if (typeof rawNewString !== "string") {
+      return { ok: false, error: `edits[${i}]: 'new_string' must be a string.` };
+    }
+    const oldString = normalizeToLf(rawOldString);
+    const newString = normalizeToLf(rawNewString);
+    if (oldString === newString) {
+      return { ok: false, error: `edits[${i}]: 'old_string' and 'new_string' are identical \u2014 nothing to change.` };
+    }
+    const occurrences = working.split(oldString).length - 1;
+    if (occurrences === 0) {
+      return { ok: false, error: `edits[${i}]: 'old_string' was not found in the file's current content. Check the exact text (including whitespace/line breaks) \u2014 the file may differ from what you last saw.` };
+    }
+    if (occurrences > 1 && !replaceAll) {
+      return { ok: false, error: `edits[${i}]: 'old_string' matches ${occurrences} places in the file. Include more surrounding context to make it unique, or set 'replace_all: true' to replace every match.` };
+    }
+    if (replaceAll) {
+      working = working.split(oldString).join(newString);
+    } else {
+      const index = working.indexOf(oldString);
+      working = working.slice(0, index) + newString + working.slice(index + oldString.length);
+    }
+  }
+  return { ok: true, content: rewrapTextEnvelope(envelope, working) };
+}
+function documentTitle(markdown, filePath) {
+  const heading = markdown.match(/^#\s+(.+)$/m)?.[1]?.trim();
+  return heading || (filePath ? path.basename(filePath, path.extname(filePath)) : "Untitled article");
+}
+
+// src/drafts.ts
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import path2 from "node:path";
+function draftPathFor(ctx, sourcePath) {
+  const digest = createHash("sha256").update(sourcePath).digest("hex").slice(0, 32);
+  return path2.join(ctx.storagePath, "drafts", `${digest}.json`);
+}
+function hashText(text) {
+  return createHash("sha256").update(text).digest("hex");
+}
+async function readDraft(ctx, sourcePath) {
+  try {
+    const raw = JSON.parse(await readFile(draftPathFor(ctx, sourcePath), "utf8"));
+    return raw && raw.path === sourcePath && typeof raw.markdown === "string" ? raw : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function writeDraft(ctx, sourcePath, markdown, base) {
+  try {
+    const file = draftPathFor(ctx, sourcePath);
+    await mkdir(path2.dirname(file), { recursive: true });
+    const entry = { path: sourcePath, markdown, savedAt: Date.now() };
+    if (typeof base === "string") entry.baseHash = hashText(base);
+    await writeFile(file, JSON.stringify(entry), "utf8");
+  } catch (error) {
+    ctx.logger.warn(`Could not persist draft for ${sourcePath}: ${String(error)}`);
+  }
+}
+async function deleteDraft(ctx, sourcePath) {
+  await rm(draftPathFor(ctx, sourcePath), { force: true }).catch(() => {
+  });
+}
+var DRAFT_WRITE_DEBOUNCE_MS = 600;
+var pendingDraftWrites = /* @__PURE__ */ new Map();
+function scheduleDraftWrite(ctx, panelId, sourcePath, markdown, base) {
+  const existing = pendingDraftWrites.get(panelId);
+  if (existing?.timer) clearTimeout(existing.timer);
+  const entry = { path: sourcePath, markdown, base, timer: null };
+  entry.timer = setTimeout(() => {
+    entry.timer = null;
+    pendingDraftWrites.delete(panelId);
+    void writeDraft(ctx, sourcePath, markdown, base);
+  }, DRAFT_WRITE_DEBOUNCE_MS);
+  pendingDraftWrites.set(panelId, entry);
+}
+function flushPendingDraftWrite(ctx, panelId) {
+  const entry = pendingDraftWrites.get(panelId);
+  if (!entry) return;
+  if (entry.timer) clearTimeout(entry.timer);
+  pendingDraftWrites.delete(panelId);
+  void writeDraft(ctx, entry.path, entry.markdown, entry.base);
+}
+function cancelPendingDraftWrite(panelId) {
+  const entry = pendingDraftWrites.get(panelId);
+  if (entry?.timer) clearTimeout(entry.timer);
+  pendingDraftWrites.delete(panelId);
+}
+async function readFileWithDraft(ctx, sourcePath) {
+  const diskMarkdown = await readFile(sourcePath, "utf8");
+  const draft = await readDraft(ctx, sourcePath);
+  if (!draft || draft.markdown === diskMarkdown) return { markdown: diskMarkdown, diskMarkdown, draftRestored: false, draftConflict: false };
+  const diskMatchesBaseline = draft.baseHash === void 0 || draft.baseHash === hashText(diskMarkdown);
+  if (diskMatchesBaseline) return { markdown: draft.markdown, diskMarkdown, draftRestored: true, draftConflict: false };
+  return { markdown: diskMarkdown, diskMarkdown, draftRestored: false, draftConflict: true };
+}
+
+// src/renderer.ts
+import { createHash as createHash2 } from "node:crypto";
+import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import os from "node:os";
+var BMMD_BIN_PATH = fileURLToPath(new URL("./bmmd/bin/bmmd.mjs", import.meta.url));
+async function runBmmd(args, input) {
+  const binPath = BMMD_BIN_PATH;
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [binPath, ...args], { stdio: ["pipe", "pipe", "pipe"] });
+    let output = "";
+    let errors = "";
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      output += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      errors += chunk;
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve(output);
+      else reject(new Error(errors.trim() || `bmmd exited with code ${code}`));
+    });
+    child.stdin.end(input, "utf8");
+  });
+}
+var FINCH_FILE_IMAGE_RE = /finch-file:\/\/local\?path=[^\s)"']+/g;
+var FINCH_IMAGE_PLACEHOLDER_ORIGIN = "https://finch-local.invalid/markdown-image/";
+function substituteFinchFileImagesForBm(markdown) {
+  const urls = /* @__PURE__ */ new Map();
+  let sequence = 0;
+  const substituted = markdown.replace(FINCH_FILE_IMAGE_RE, (originalUrl) => {
+    const placeholder = `${FINCH_IMAGE_PLACEHOLDER_ORIGIN}${createHash2("sha256").update(`${originalUrl}:${sequence++}`).digest("hex")}`;
+    urls.set(placeholder, originalUrl);
+    return placeholder;
+  });
+  return { markdown: substituted, urls };
+}
+async function renderWithBm(markdown, markdownStyle, customCss) {
+  const args = ["render", "--platform", "wechat", "--markdown-style", markdownStyle || "kami"];
+  if (customCss && customCss.trim()) args.push("--custom-css", customCss);
+  const prepared = substituteFinchFileImagesForBm(markdown);
+  let html = await runBmmd(args, prepared.markdown);
+  for (const [placeholder, originalUrl] of prepared.urls) html = html.split(placeholder).join(originalUrl);
+  return html;
+}
+
+// src/index.ts
 var PASTE_IMAGE_EXT = {
   "image/png": "png",
   "image/jpeg": "jpg",
@@ -27,19 +202,19 @@ var IMAGE_MIME_BY_EXT = {
 var MAX_CLIPBOARD_INLINE_IMAGE_BYTES = 20 * 1024 * 1024;
 async function readClipboardImageDataUrls(ctx, urls) {
   const result2 = {};
-  const assetsRoot = await realpath(path.join(ctx.storagePath, "assets"));
+  const assetsRoot = await realpath(path3.join(ctx.storagePath, "assets"));
   for (const originalUrl of urls.slice(0, 30)) {
     try {
       const parsed = new URL(originalUrl);
       const requested = parsed.protocol === "finch-file:" && parsed.hostname === "local" ? parsed.searchParams.get("path") : null;
       if (!requested) continue;
       const target = await realpath(requested);
-      const relative = path.relative(assetsRoot, target);
-      const mimeType = IMAGE_MIME_BY_EXT[path.extname(target).toLowerCase()];
-      if ((!relative || !relative.startsWith(".." + path.sep) && relative !== "..") && mimeType) {
+      const relative = path3.relative(assetsRoot, target);
+      const mimeType = IMAGE_MIME_BY_EXT[path3.extname(target).toLowerCase()];
+      if ((!relative || !relative.startsWith(".." + path3.sep) && relative !== "..") && mimeType) {
         const info = await stat(target);
         if (info.size > MAX_CLIPBOARD_INLINE_IMAGE_BYTES) continue;
-        result2[originalUrl] = `data:${mimeType};base64,${(await readFile(target)).toString("base64")}`;
+        result2[originalUrl] = `data:${mimeType};base64,${(await readFile2(target)).toString("base64")}`;
       }
     } catch {
     }
@@ -47,7 +222,7 @@ async function readClipboardImageDataUrls(ctx, urls) {
   return result2;
 }
 async function openLocalImagePreview(ctx, filePath) {
-  if (!path.isAbsolute(filePath) || !IMAGE_MIME_BY_EXT[path.extname(filePath).toLowerCase()]) {
+  if (!path3.isAbsolute(filePath) || !IMAGE_MIME_BY_EXT[path3.extname(filePath).toLowerCase()]) {
     throw new Error("Unsupported local image file.");
   }
   await ctx.ui.openFilePreview(filePath);
@@ -64,15 +239,11 @@ var STYLE_SLOT_COUNT = 3;
 function result(message, isError = false) {
   return { content: [{ type: "text", text: message }], isError };
 }
-function documentTitle(markdown, filePath) {
-  const heading = markdown.match(/^#\s+(.+)$/m)?.[1]?.trim();
-  return heading || (filePath ? path.basename(filePath, path.extname(filePath)) : "Untitled article");
-}
 function stateFile(ctx) {
-  return path.join(ctx.storagePath, "state.json");
+  return path3.join(ctx.storagePath, "state.json");
 }
 function styleSlotsFile(ctx) {
-  return path.join(ctx.storagePath, "style-slots.json");
+  return path3.join(ctx.storagePath, "style-slots.json");
 }
 function normalizeStyleSlots(raw) {
   const arr = Array.isArray(raw) ? raw : [];
@@ -89,7 +260,7 @@ function normalizeStyleSlots(raw) {
 }
 async function readStyleSlots(ctx) {
   try {
-    const raw = await readFile(styleSlotsFile(ctx), "utf8");
+    const raw = await readFile2(styleSlotsFile(ctx), "utf8");
     return normalizeStyleSlots(JSON.parse(raw));
   } catch {
     return normalizeStyleSlots([]);
@@ -98,97 +269,104 @@ async function readStyleSlots(ctx) {
 async function writeStyleSlot(ctx, slot, value) {
   const slots = await readStyleSlots(ctx);
   slots[slot] = value;
-  await mkdir(ctx.storagePath, { recursive: true });
-  await writeFile(styleSlotsFile(ctx), JSON.stringify(slots), "utf8");
+  await mkdir2(ctx.storagePath, { recursive: true });
+  await writeFile2(styleSlotsFile(ctx), JSON.stringify(slots), "utf8");
   return slots;
 }
-function draftPathFor(ctx, sourcePath) {
-  const digest = createHash("sha256").update(sourcePath).digest("hex").slice(0, 32);
-  return path.join(ctx.storagePath, "drafts", `${digest}.json`);
-}
-function hashText(text) {
-  return createHash("sha256").update(text).digest("hex");
+function sessionBucketKey(panel) {
+  return panel.sessionId || "__global__";
 }
-async function readDraft(ctx, sourcePath) {
+async function readLastPathState(ctx) {
   try {
-    const raw = JSON.parse(await readFile(draftPathFor(ctx, sourcePath), "utf8"));
-    return raw && raw.path === sourcePath && typeof raw.markdown === "string" ? raw : void 0;
+    const raw = await readFile2(stateFile(ctx), "utf8");
+    return JSON.parse(raw);
   } catch {
-    return void 0;
+    return {};
   }
 }
-async function writeDraft(ctx, sourcePath, markdown, base) {
-  try {
-    const file = draftPathFor(ctx, sourcePath);
-    await mkdir(path.dirname(file), { recursive: true });
-    const entry = { path: sourcePath, markdown, savedAt: Date.now() };
-    if (typeof base === "string") entry.baseHash = hashText(base);
-    await writeFile(file, JSON.stringify(entry), "utf8");
-  } catch (error) {
-    ctx.logger.warn(`Could not persist draft for ${sourcePath}: ${String(error)}`);
+function resolveRecentScope(state, cwd, sessionId, spaceId) {
+  if (path3.isAbsolute(cwd)) {
+    if (sessionId && !spaceId) state.homePath = cwd;
+    return { scope: cwd };
   }
+  if (!cwd && !sessionId && !spaceId && path3.isAbsolute(state.homePath ?? "")) {
+    return { scope: state.homePath, fallbackCwd: state.homePath };
+  }
+  return {};
 }
-async function deleteDraft(ctx, sourcePath) {
-  await rm(draftPathFor(ctx, sourcePath), { force: true }).catch(() => {
-  });
-}
-var DRAFT_WRITE_DEBOUNCE_MS = 600;
-var pendingDraftWrites = /* @__PURE__ */ new Map();
-function scheduleDraftWrite(ctx, panelId, sourcePath, markdown, base) {
-  const existing = pendingDraftWrites.get(panelId);
-  if (existing?.timer) clearTimeout(existing.timer);
-  const entry = { path: sourcePath, markdown, base, timer: null };
-  entry.timer = setTimeout(() => {
-    entry.timer = null;
-    pendingDraftWrites.delete(panelId);
-    void writeDraft(ctx, sourcePath, markdown, base);
-  }, DRAFT_WRITE_DEBOUNCE_MS);
-  pendingDraftWrites.set(panelId, entry);
+function addRecentPath(state, scope, sourcePath) {
+  const existing = state.recentPathsByScope?.[scope] ?? [];
+  state.recentPathsByScope = {
+    ...state.recentPathsByScope,
+    [scope]: [sourcePath, ...existing].filter((value, index, values) => path3.isAbsolute(value) && values.indexOf(value) === index).slice(0, 50)
+  };
 }
-function flushPendingDraftWrite(ctx, panelId) {
-  const entry = pendingDraftWrites.get(panelId);
-  if (!entry) return;
-  if (entry.timer) clearTimeout(entry.timer);
-  pendingDraftWrites.delete(panelId);
-  void writeDraft(ctx, entry.path, entry.markdown, entry.base);
+function pathBelongsTo(root, target) {
+  const relative = path3.relative(root, target);
+  return relative === "" || !relative.startsWith(`..${path3.sep}`) && relative !== ".." && !path3.isAbsolute(relative);
 }
-function cancelPendingDraftWrite(panelId) {
-  const entry = pendingDraftWrites.get(panelId);
-  if (entry?.timer) clearTimeout(entry.timer);
-  pendingDraftWrites.delete(panelId);
-}
-async function readFileWithDraft(ctx, sourcePath) {
-  const diskMarkdown = await readFile(sourcePath, "utf8");
-  const draft = await readDraft(ctx, sourcePath);
-  if (!draft || draft.markdown === diskMarkdown) return { markdown: diskMarkdown, diskMarkdown, draftRestored: false, draftConflict: false };
-  const diskMatchesBaseline = draft.baseHash === void 0 || draft.baseHash === hashText(diskMarkdown);
-  if (diskMatchesBaseline) return { markdown: draft.markdown, diskMarkdown, draftRestored: true, draftConflict: false };
-  return { markdown: diskMarkdown, diskMarkdown, draftRestored: false, draftConflict: true };
-}
-function sessionBucketKey(panel) {
-  return panel.sessionId || "__global__";
+async function resolveDocumentScope(ctx, sourcePath, fallbackCwd) {
+  const spaces = await ctx.spaces.list().catch(() => []);
+  const matches = spaces.filter((space2) => path3.isAbsolute(space2.directoryPath ?? "") && pathBelongsTo(space2.directoryPath, sourcePath)).sort((a, b) => (b.directoryPath?.length ?? 0) - (a.directoryPath?.length ?? 0));
+  const space = matches[0];
+  if (space?.directoryPath) {
+    const spaceName = space.name || space.alias || path3.basename(space.directoryPath);
+    return { scope: space.directoryPath, spaceId: space.id, spaceName, scopeLabel: spaceName, scopeKind: "space" };
+  }
+  const workspaceRoot = ctx.workspace.projectPath;
+  if (workspaceRoot && pathBelongsTo(workspaceRoot, sourcePath)) {
+    return { scope: workspaceRoot, scopeKind: "workspace" };
+  }
+  if (fallbackCwd && path3.isAbsolute(fallbackCwd) && pathBelongsTo(fallbackCwd, sourcePath)) {
+    return { scope: fallbackCwd, scopeKind: "workspace" };
+  }
+  return { scope: path3.dirname(sourcePath), scopeKind: "external" };
 }
-async function readLastPathState(ctx) {
+async function rememberPanelRecentScope(ctx, panel, cwd, sessionId, spaceId) {
   try {
-    const raw = await readFile(stateFile(ctx), "utf8");
-    return JSON.parse(raw);
-  } catch {
+    await mkdir2(ctx.storagePath, { recursive: true });
+    const state = await readLastPathState(ctx);
+    const resolved = resolveRecentScope(state, cwd, sessionId, spaceId);
+    if (resolved.scope) {
+      state.panelRecentScopes = { ...state.panelRecentScopes, [panel.id]: resolved.scope };
+      const panelPath = state.panels?.[panel.id];
+      if (panelPath) addRecentPath(state, resolved.scope, panelPath);
+    }
+    await writeFile2(stateFile(ctx), JSON.stringify(state), "utf8");
+    return resolved;
+  } catch (error) {
+    ctx.logger.warn(`Could not persist panel recent scope: ${String(error)}`);
     return {};
   }
 }
 async function rememberLastPath(ctx, panel, sourcePath) {
   try {
-    await mkdir(ctx.storagePath, { recursive: true });
+    await mkdir2(ctx.storagePath, { recursive: true });
     const state = await readLastPathState(ctx);
-    const legacyPaths = [...Object.values(state.panels ?? {}), ...Object.values(state.sessions ?? {})];
-    state.recentPaths = [sourcePath, ...state.recentPaths ?? [], ...legacyPaths].filter((value, index, values) => path.isAbsolute(value) && values.indexOf(value) === index).slice(0, 50);
     state.panels = { ...state.panels, [panel.id]: sourcePath };
     state.sessions = { ...state.sessions, [sessionBucketKey(panel)]: sourcePath };
-    await writeFile(stateFile(ctx), JSON.stringify(state), "utf8");
+    let scope = state.panelRecentScopes?.[panel.id];
+    if (!scope && panel.view === "appView") {
+      scope = (await resolveDocumentScope(ctx, sourcePath)).scope;
+      state.panelRecentScopes = { ...state.panelRecentScopes, [panel.id]: scope };
+    }
+    if (scope) addRecentPath(state, scope, sourcePath);
+    await writeFile2(stateFile(ctx), JSON.stringify(state), "utf8");
   } catch (error) {
     ctx.logger.warn(`Could not persist last-opened path: ${String(error)}`);
   }
 }
+async function rememberRecentPath(ctx, sourcePath, panel) {
+  try {
+    await mkdir2(ctx.storagePath, { recursive: true });
+    const state = await readLastPathState(ctx);
+    const scope = panel ? state.panelRecentScopes?.[panel.id] : resolveRecentScope(state, ctx.session.cwd ?? "", ctx.session.id ?? "", ctx.session.spaceId ?? "").scope;
+    if (scope) addRecentPath(state, scope, sourcePath);
+    await writeFile2(stateFile(ctx), JSON.stringify(state), "utf8");
+  } catch (error) {
+    ctx.logger.warn(`Could not persist recent path: ${String(error)}`);
+  }
+}
 async function readLastPath(ctx, panel) {
   const state = await readLastPathState(ctx);
   const perPanel = state.panels?.[panel.id];
@@ -204,10 +382,6 @@ var RECENT_PREVIEW_CHARS = 220;
 function isMarkdownPath(filePath) {
   return /\.(md|markdown|mdown|mkd)$/i.test(filePath);
 }
-function isInsideDirectory(filePath, directory) {
-  const relative = path.relative(directory, filePath);
-  return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative);
-}
 function deriveTitle(markdown, fallback) {
   for (const line of markdown.split("\n", 60)) {
     const heading = line.match(/^\s{0,3}#{1,6}\s+(.*\S)\s*$/);
@@ -222,26 +396,25 @@ function deriveTitle(markdown, fallback) {
 function derivePreview(markdown) {
   return markdown.replace(/^---\n[\s\S]*?\n---\n/, "").replace(/```[\s\S]*?```/g, " ").replace(/!\[[^\]]*\]\([^)]*\)/g, " ").replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/^\s{0,3}#{1,6}\s+/gm, "").replace(/[*_`>~]/g, "").replace(/\s+/g, " ").trim().slice(0, RECENT_PREVIEW_CHARS);
 }
-async function collectRecentDocuments(ctx, cwd) {
-  if (!cwd || !path.isAbsolute(cwd)) return [];
+async function collectRecentDocuments(ctx, requestedCwd, sessionId, spaceId) {
+  const cwd = requestedCwd;
   const state = await readLastPathState(ctx);
-  const candidates = [
-    ...state.recentPaths ?? [],
-    ...Object.values(state.panels ?? {}),
-    ...Object.values(state.sessions ?? {})
-  ].filter(
-    (value, index, values) => typeof value === "string" && path.isAbsolute(value) && isMarkdownPath(value) && isInsideDirectory(value, cwd) && values.indexOf(value) === index
+  const resolved = resolveRecentScope(state, cwd, sessionId, spaceId);
+  if (!resolved.scope) return { documents: [] };
+  const scope = resolved.scope;
+  const candidates = (state.recentPathsByScope?.[scope] ?? []).filter(
+    (value, index, values) => typeof value === "string" && path3.isAbsolute(value) && isMarkdownPath(value) && values.indexOf(value) === index
   );
   const documents = await Promise.all(
     candidates.map(async (filePath) => {
       try {
         const info = await stat(filePath);
         if (!info.isFile()) return void 0;
-        const markdown = await readFile(filePath, "utf8");
-        const fileName = path.basename(filePath);
+        const markdown = await readFile2(filePath, "utf8");
+        const fileName = path3.basename(filePath);
         return {
           path: filePath,
-          relativePath: path.relative(cwd, filePath),
+          relativePath: path3.relative(scope, filePath),
           fileName,
           title: deriveTitle(markdown, fileName.replace(/\.[^.]+$/, "")),
           preview: derivePreview(markdown),
@@ -252,6 +425,35 @@ async function collectRecentDocuments(ctx, cwd) {
       }
     })
   );
+  return {
+    documents: documents.filter((entry) => Boolean(entry)).sort((a, b) => b.modifiedAt - a.modifiedAt).slice(0, RECENT_LIMIT),
+    fallbackCwd: resolved.fallbackCwd
+  };
+}
+async function collectLibraryDocuments(ctx) {
+  const state = await readLastPathState(ctx);
+  const candidates = Object.values(state.recentPathsByScope ?? {}).flat().concat(Object.values(state.panels ?? {})).filter((value, index, values) => path3.isAbsolute(value) && isMarkdownPath(value) && values.indexOf(value) === index);
+  const documents = await Promise.all(candidates.map(async (filePath) => {
+    try {
+      const [info, markdown, scope] = await Promise.all([stat(filePath), readFile2(filePath, "utf8"), resolveDocumentScope(ctx, filePath, state.homePath)]);
+      if (!info.isFile()) return void 0;
+      const fileName = path3.basename(filePath);
+      return {
+        path: filePath,
+        relativePath: path3.relative(scope.scope, filePath),
+        fileName,
+        title: deriveTitle(markdown, fileName.replace(/\.[^.]+$/, "")),
+        preview: derivePreview(markdown),
+        modifiedAt: info.mtimeMs,
+        spaceId: scope.spaceId,
+        spaceName: scope.spaceName,
+        scopeLabel: scope.scopeLabel,
+        scopeKind: scope.scopeKind
+      };
+    } catch {
+      return void 0;
+    }
+  }));
   return documents.filter((entry) => Boolean(entry)).sort((a, b) => b.modifiedAt - a.modifiedAt).slice(0, RECENT_LIMIT);
 }
 var livePanelDocuments = /* @__PURE__ */ new Map();
@@ -260,7 +462,7 @@ async function sendDocument(panel, state) {
   await panel.postMessage({ type: "document", ...state });
 }
 async function sendLiveDocument(ctx, panel, liveDocument) {
-  if (liveDocument.path && path.isAbsolute(liveDocument.path)) {
+  if (liveDocument.path && path3.isAbsolute(liveDocument.path)) {
     try {
       const { markdown, diskMarkdown, draftRestored, draftConflict } = await readFileWithDraft(ctx, liveDocument.path);
       await sendDocument(panel, { ...liveDocument, markdown, title: documentTitle(markdown, liveDocument.path), draftRestored, draftConflict, diskMarkdown });
@@ -275,10 +477,10 @@ function payloadPath(panel) {
   const payload = panel.payload;
   if (!payload || typeof payload !== "object" || Array.isArray(payload)) return void 0;
   const value = payload.path;
-  return typeof value === "string" && path.isAbsolute(value) ? value : void 0;
+  return typeof value === "string" && path3.isAbsolute(value) ? value : void 0;
 }
 async function restoreDocument(ctx, panel) {
-  if (!panel.sessionId) return false;
+  if (!panel.sessionId && panel.view !== "appView") return false;
   const sourcePath = await readLastPath(ctx, panel) ?? payloadPath(panel);
   if (!sourcePath) return false;
   try {
@@ -292,49 +494,6 @@ async function restoreDocument(ctx, panel) {
     return false;
   }
 }
-var BMMD_BIN_PATH = fileURLToPath(new URL("./bmmd/bin/bmmd.mjs", import.meta.url));
-async function runBmmd(args, input) {
-  const binPath = BMMD_BIN_PATH;
-  return new Promise((resolve, reject) => {
-    const child = spawn(process.execPath, [binPath, ...args], { stdio: ["pipe", "pipe", "pipe"] });
-    let output = "";
-    let errors = "";
-    child.stdout.setEncoding("utf8");
-    child.stderr.setEncoding("utf8");
-    child.stdout.on("data", (chunk) => {
-      output += chunk;
-    });
-    child.stderr.on("data", (chunk) => {
-      errors += chunk;
-    });
-    child.on("error", reject);
-    child.on("close", (code) => {
-      if (code === 0) resolve(output);
-      else reject(new Error(errors.trim() || `bmmd exited with code ${code}`));
-    });
-    child.stdin.end(input, "utf8");
-  });
-}
-var FINCH_FILE_IMAGE_RE = /finch-file:\/\/local\?path=[^\s)"']+/g;
-var FINCH_IMAGE_PLACEHOLDER_ORIGIN = "https://finch-local.invalid/markdown-image/";
-function substituteFinchFileImagesForBm(markdown) {
-  const urls = /* @__PURE__ */ new Map();
-  let sequence = 0;
-  const substituted = markdown.replace(FINCH_FILE_IMAGE_RE, (originalUrl) => {
-    const placeholder = `${FINCH_IMAGE_PLACEHOLDER_ORIGIN}${createHash("sha256").update(`${originalUrl}:${sequence++}`).digest("hex")}`;
-    urls.set(placeholder, originalUrl);
-    return placeholder;
-  });
-  return { markdown: substituted, urls };
-}
-async function renderWithBm(markdown, markdownStyle, customCss) {
-  const args = ["render", "--platform", "wechat", "--markdown-style", markdownStyle || "kami"];
-  if (customCss && customCss.trim()) args.push("--custom-css", customCss);
-  const prepared = substituteFinchFileImagesForBm(markdown);
-  let html = await runBmmd(args, prepared.markdown);
-  for (const [placeholder, originalUrl] of prepared.urls) html = html.split(placeholder).join(originalUrl);
-  return html;
-}
 var panelWatchers = /* @__PURE__ */ new Map();
 var lastPanel;
 function stopWatching(panelId) {
@@ -353,7 +512,7 @@ function watchSource(ctx, panel, sourcePath) {
       if (entry.timer) clearTimeout(entry.timer);
       entry.timer = setTimeout(async () => {
         try {
-          const markdown = await readFile(sourcePath, "utf8");
+          const markdown = await readFile2(sourcePath, "utf8");
           await sendDocument(panel, { path: sourcePath, markdown, title: documentTitle(markdown, sourcePath) });
         } catch (error) {
           ctx.logger.warn(`Source refresh failed: ${String(error)}`);
@@ -402,16 +561,98 @@ async function revealInFileManager(ctx, targetPath) {
     const info = await stat(targetPath).catch(() => void 0);
     const isFile = info?.isFile() ?? false;
     if (process.platform === "darwin") {
-      spawn("open", isFile ? ["-R", targetPath] : [targetPath], { stdio: "ignore", detached: true }).unref();
+      spawn2("open", isFile ? ["-R", targetPath] : [targetPath], { stdio: "ignore", detached: true }).unref();
     } else if (process.platform === "win32") {
-      spawn("explorer", isFile ? [`/select,${targetPath}`] : [targetPath], { stdio: "ignore", detached: true }).unref();
+      spawn2("explorer", isFile ? [`/select,${targetPath}`] : [targetPath], { stdio: "ignore", detached: true }).unref();
     } else {
-      spawn("xdg-open", [isFile ? path.dirname(targetPath) : targetPath], { stdio: "ignore", detached: true }).unref();
+      spawn2("xdg-open", [isFile ? path3.dirname(targetPath) : targetPath], { stdio: "ignore", detached: true }).unref();
     }
   } catch (error) {
     ctx.logger.warn(`Could not open file manager for ${targetPath}: ${String(error)}`);
   }
 }
+async function readRewriteSession(ctx, sourcePath) {
+  const state = await readLastPathState(ctx);
+  const id = state.rewriteSessions?.[sourcePath];
+  if (!id) return void 0;
+  const session = await ctx.sessions.get(id).catch(() => void 0);
+  return session ? id : void 0;
+}
+async function rememberRewriteSession(ctx, sourcePath, sessionId) {
+  try {
+    const state = await readLastPathState(ctx);
+    state.rewriteSessions = { ...state.rewriteSessions, [sourcePath]: sessionId };
+    await writeFile2(stateFile(ctx), JSON.stringify(state), "utf8");
+  } catch (error) {
+    ctx.logger.warn(`Could not persist rewrite session: ${String(error)}`);
+  }
+}
+async function startRewriteSession(ctx, panel, message) {
+  const sourcePath = String(message.path ?? "").trim();
+  const selectedText = String(message.selectedText ?? "").trim();
+  const rewriteMode = message.rewriteMode === "continue" ? "continue" : "replace";
+  const requirement = String(message.requirement ?? "").trim() || (rewriteMode === "continue" ? "\u81EA\u7136\u5730\u627F\u63A5\u4E0A\u4E0B\u6587\u7EE7\u7EED\u5199\u4F5C" : "\u8BA9\u8868\u8FBE\u66F4\u6E05\u6670\u3001\u81EA\u7136\uFF0C\u5E76\u4FDD\u6301\u539F\u610F");
+  const hasTarget = rewriteMode === "continue" ? !!message.startLine : !!selectedText;
+  if (panel.view !== "appView" || !path3.isAbsolute(sourcePath) || !hasTarget) {
+    await panel.postMessage({ type: "rewriteSessionFailed", message: "\u6539\u5199\u9700\u8981 App View \u4E2D\u5DF2\u4FDD\u5B58\u7684\u672C\u5730\u6587\u6863\u548C\u9009\u4E2D\u6587\u672C\u6216\u7EED\u5199\u4F4D\u7F6E\u3002" });
+    return;
+  }
+  const scope = await resolveDocumentScope(ctx, sourcePath);
+  let sessionId = await readRewriteSession(ctx, sourcePath);
+  if (!sessionId) {
+    const session = await ctx.sessions.create({
+      ...scope.spaceId ? { space: { spaceId: scope.spaceId } } : {},
+      title: `\u6539\u5199\uFF1A${path3.basename(sourcePath)}`,
+      activity: "interactive",
+      permissionMode: "acceptCalls"
+    });
+    sessionId = session.sessionId;
+    await rememberRewriteSession(ctx, sourcePath, sessionId);
+  }
+  const lineText = message.startLine ? `\u4F4D\u7F6E\uFF1A\u7B2C ${message.startLine}${message.endLine && message.endLine !== message.startLine ? `\u2013${message.endLine}` : ""} \u884C\u3002` : "";
+  const prompt = rewriteMode === "continue" ? `\u8BF7\u5728\u4E0B\u9762\u8FD9\u4EFD Markdown \u6587\u4EF6\u7684\u6307\u5B9A\u4F4D\u7F6E\u7EED\u5199\u5185\u5BB9\uFF0C\u5E76\u628A\u7ED3\u679C\u5199\u56DE\u6587\u4EF6\u3002
+
+\u6587\u4EF6\uFF1A${sourcePath}
+${lineText}
+\u8981\u6C42\uFF1A${requirement}
+
+\u8BF7\u8BFB\u53D6\u6587\u4EF6\u5F53\u524D\u5185\u5BB9\uFF1A\u7B2C ${message.startLine} \u884C\u5F53\u524D\u662F\u4E00\u4E2A\u7A7A\u884C\uFF0C\u8BF7\u628A\u7EED\u5199\u7684\u65B0\u5185\u5BB9\u76F4\u63A5\u5199\u5165\u8FD9\u4E00\u884C\u672C\u8EAB\uFF08\u628A\u8FD9\u4E2A\u7A7A\u884C\u66FF\u6362\u6210\u65B0\u5185\u5BB9\uFF09\uFF0C\u4E0D\u8981\u5728\u5B83\u524D\u540E\u989D\u5916\u63D2\u5165\u65B0\u7684\u7A7A\u884C\uFF0C\u4E5F\u4E0D\u8981\u6539\u52A8\u7B2C ${message.startLine} \u884C\u4E4B\u5916\u7684\u539F\u6709\u5185\u5BB9\uFF1B\u8C03\u7528 markdown_editor_document \u7684 apply\uFF0C\u4EE5 edits \u505A\u7CBE\u786E\u7684\u5C40\u90E8\u66FF\u6362\u3002\u4E0D\u8981\u53EA\u7ED9\u5EFA\u8BAE\uFF0C\u4E0D\u8981\u91CD\u53D1\u5168\u6587\uFF1B\u5B8C\u6210\u5199\u56DE\u540E\u7B80\u77ED\u8BF4\u660E\u3002` : `\u8BF7\u76F4\u63A5\u6539\u5199\u4E0B\u9762\u8FD9\u6BB5 Markdown\uFF0C\u5E76\u628A\u7ED3\u679C\u5199\u56DE\u6587\u4EF6\u3002
+
+\u6587\u4EF6\uFF1A${sourcePath}
+${lineText}
+\u8981\u6C42\uFF1A${requirement}
+
+\u539F\u6587\uFF1A
+${selectedText}
+
+\u8BF7\u8BFB\u53D6\u6587\u4EF6\u5F53\u524D\u5185\u5BB9\uFF0C\u8C03\u7528 markdown_editor_document \u7684 apply\uFF0C\u4EE5 edits \u505A\u552F\u4E00\u3001\u7CBE\u786E\u7684\u5C40\u90E8\u66FF\u6362\u3002\u4E0D\u8981\u53EA\u7ED9\u5EFA\u8BAE\uFF0C\u4E0D\u8981\u91CD\u53D1\u5168\u6587\uFF1B\u5B8C\u6210\u5199\u56DE\u540E\u7B80\u77ED\u8BF4\u660E\u3002`;
+  const receipt = await ctx.sessions.send(sessionId, {
+    text: prompt,
+    idempotencyKey: `rewrite-${createHash3("sha256").update(`${sourcePath}:${rewriteMode}:${selectedText}:${requirement}:${message.startLine ?? ""}:${Date.now()}`).digest("hex")}`
+  });
+  if (receipt.state === "rejected") {
+    await panel.postMessage({ type: "rewriteSessionFailed", message: "\u6539\u5199\u4F1A\u8BDD\u961F\u5217\u7E41\u5FD9\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002" });
+    return;
+  }
+  await panel.postMessage({
+    type: "rewriteSessionStarted",
+    sessionId,
+    spaceName: scope.spaceName,
+    title: `${rewriteMode === "continue" ? "\u7EED\u5199" : "\u6539\u5199"}\uFF1A${path3.basename(sourcePath)}`,
+    startLine: message.startLine,
+    endLine: message.endLine ?? message.startLine,
+    rewriteMode
+  });
+  void ctx.sessions.waitForTurn(sessionId, receipt.turnId, { timeoutMs: 6e5 }).then(async (result2) => {
+    const verb = rewriteMode === "continue" ? "\u7EED\u5199" : "\u6539\u5199";
+    await panel.postMessage({
+      type: result2.state === "completed" ? "rewriteSessionFinished" : "rewriteSessionFailed",
+      sessionId,
+      message: result2.state === "completed" ? `${verb}\u5DF2\u5B8C\u6210\u3002` : result2.state === "timeout" ? `${verb}\u4ECD\u5728\u4F1A\u8BDD\u4E2D\u7EE7\u7EED\u3002` : `${verb}\u4F1A\u8BDD\u672A\u5B8C\u6210\u3002`
+    }).catch(() => {
+    });
+  });
+}
 async function handleMessage(ctx, panel, raw) {
   const message = raw;
   switch (message.type) {
@@ -461,7 +702,8 @@ async function handleMessage(ctx, panel, raw) {
       try {
         const handle = ctx.ui.pickFile({
           title: "\u9009\u62E9Markdown\u6587\u4EF6",
-          filter: { extensions: [".md", ".markdown"] }
+          filter: { extensions: [".md", ".markdown"] },
+          allowSpaceSwitch: panel.view === "appView"
         });
         ctx.logger.info("ctx.ui.pickFile() call returned a handle, awaiting resolution\u2026");
         const picked = await handle;
@@ -487,7 +729,7 @@ async function handleMessage(ctx, panel, raw) {
     }
     case "loadPath": {
       const sourcePath = String(message.path ?? "").trim();
-      if (!path.isAbsolute(sourcePath)) {
+      if (!path3.isAbsolute(sourcePath)) {
         await panel.postMessage({ type: "error", message: "Please provide an absolute Markdown path." });
         return;
       }
@@ -503,7 +745,7 @@ async function handleMessage(ctx, panel, raw) {
     }
     case "watchPath": {
       const sourcePath = String(message.path ?? "").trim();
-      if (!path.isAbsolute(sourcePath)) return;
+      if (!path3.isAbsolute(sourcePath)) return;
       watchSource(ctx, panel, sourcePath);
       await rememberLastPath(ctx, panel, sourcePath);
       await panel.postMessage({ type: "watchStarted", path: sourcePath });
@@ -520,7 +762,7 @@ async function handleMessage(ctx, panel, raw) {
     }
     case "openPath": {
       const targetPath = String(message.path ?? "").trim();
-      if (targetPath && path.isAbsolute(targetPath)) await revealInFileManager(ctx, targetPath);
+      if (targetPath && path3.isAbsolute(targetPath)) await revealInFileManager(ctx, targetPath);
       return;
     }
     case "goHome": {
@@ -530,19 +772,32 @@ async function handleMessage(ctx, panel, raw) {
     }
     case "requestRecentDocuments": {
       const cwd = String(message.cwd ?? "").trim();
+      const sessionId = String(message.sessionId ?? "").trim();
+      const spaceId = String(message.spaceId ?? "").trim();
       try {
-        await panel.postMessage({ type: "recentDocuments", cwd, documents: await collectRecentDocuments(ctx, cwd) });
+        if (panel.view === "appView") {
+          const documents = await collectLibraryDocuments(ctx);
+          await panel.postMessage({ type: "recentDocuments", cwd, documents, library: true });
+        } else {
+          await rememberPanelRecentScope(ctx, panel, cwd, sessionId, spaceId);
+          const recent = await collectRecentDocuments(ctx, cwd, sessionId, spaceId);
+          await panel.postMessage({ type: "recentDocuments", cwd, documents: recent.documents, fallbackCwd: recent.fallbackCwd });
+        }
       } catch (error) {
         ctx.logger.warn(`Could not collect recent documents: ${String(error)}`);
-        await panel.postMessage({ type: "recentDocuments", cwd, documents: [] });
+        await panel.postMessage({ type: "recentDocuments", cwd, documents: [], library: panel.view === "appView" });
       }
       return;
     }
+    case "requestRewrite": {
+      await startRewriteSession(ctx, panel, message);
+      return;
+    }
     case "saveMarkdown": {
       const sourcePath = String(message.path ?? "").trim();
-      if (!path.isAbsolute(sourcePath)) return;
+      if (!path3.isAbsolute(sourcePath)) return;
       try {
-        await writeFile(sourcePath, String(message.markdown ?? ""), "utf8");
+        await writeFile2(sourcePath, String(message.markdown ?? ""), "utf8");
         cancelPendingDraftWrite(panel.id);
         await deleteDraft(ctx, sourcePath);
         await panel.postMessage({ type: "savedMarkdown", path: sourcePath, requestId: message.requestId });
@@ -553,14 +808,14 @@ async function handleMessage(ctx, panel, raw) {
     }
     case "saveDraft": {
       const sourcePath = String(message.path ?? "").trim();
-      if (!path.isAbsolute(sourcePath)) return;
+      if (!path3.isAbsolute(sourcePath)) return;
       const base = typeof message.base === "string" ? message.base : void 0;
       scheduleDraftWrite(ctx, panel.id, sourcePath, String(message.markdown ?? ""), base);
       return;
     }
     case "discardDraft": {
       const sourcePath = String(message.path ?? "").trim();
-      if (!path.isAbsolute(sourcePath)) return;
+      if (!path3.isAbsolute(sourcePath)) return;
       cancelPendingDraftWrite(panel.id);
       await deleteDraft(ctx, sourcePath);
       return;
@@ -596,13 +851,16 @@ async function handleMessage(ctx, panel, raw) {
     case "applyReplacement": {
       const sourcePath = String(message.path ?? "").trim();
       const markdown = String(message.markdown ?? "");
-      if (!sourcePath || !path.isAbsolute(sourcePath)) {
+      if (!sourcePath || !path3.isAbsolute(sourcePath)) {
         await panel.postMessage({ type: "error", message: "Pasted documents can be revised in the editor, but source-file apply needs an absolute path." });
         return;
       }
       try {
-        await writeFile(sourcePath, markdown, "utf8");
-        await panel.postMessage({ type: "applied", path: sourcePath, title: documentTitle(markdown, sourcePath) });
+        const current = await readFile2(sourcePath, "utf8");
+        const appliedMarkdown = preserveTextEnvelope(current, markdown);
+        await writeFile2(sourcePath, appliedMarkdown, "utf8");
+        await rememberRecentPath(ctx, sourcePath, panel);
+        await panel.postMessage({ type: "applied", path: sourcePath, title: documentTitle(appliedMarkdown, sourcePath) });
       } catch (error) {
         await panel.postMessage({ type: "error", message: `Could not apply revision: ${error instanceof Error ? error.message : String(error)}` });
       }
@@ -626,12 +884,12 @@ async function handleMessage(ctx, panel, raw) {
       try {
         const ext = PASTE_IMAGE_EXT[String(message.mimeType ?? "").toLowerCase()] ?? "png";
         const buffer = Buffer.from(dataBase64, "base64");
-        const digest = createHash("sha256").update(buffer).digest("hex").slice(0, 20);
-        const dir = path.join(ctx.storagePath, "assets");
-        await mkdir(dir, { recursive: true });
-        const targetPath = path.join(dir, `${digest}.${ext}`);
+        const digest = createHash3("sha256").update(buffer).digest("hex").slice(0, 20);
+        const dir = path3.join(ctx.storagePath, "assets");
+        await mkdir2(dir, { recursive: true });
+        const targetPath = path3.join(dir, `${digest}.${ext}`);
         const alreadyExists = await stat(targetPath).then(() => true).catch(() => false);
-        if (!alreadyExists) await writeFile(targetPath, buffer);
+        if (!alreadyExists) await writeFile2(targetPath, buffer);
         const url = `finch-file://local?path=${encodeURIComponent(targetPath)}`;
         await panel.postMessage({ type: "pastedImage", requestId: message.requestId, url, path: targetPath });
       } catch (error) {
@@ -664,15 +922,15 @@ async function handleMessage(ctx, panel, raw) {
       }
       try {
         const sourcePath = String(message.path ?? "").trim();
-        let dir = path.isAbsolute(sourcePath) ? path.dirname(sourcePath) : "";
+        let dir = path3.isAbsolute(sourcePath) ? path3.dirname(sourcePath) : "";
         if (!dir) {
-          const downloads = path.join(os.homedir(), "Downloads");
+          const downloads = path3.join(os.homedir(), "Downloads");
           dir = await stat(downloads).then((s) => s.isDirectory()).catch(() => false) ? downloads : ctx.storagePath;
         }
         const rawName = String(message.fileName ?? "").trim() || documentTitle(String(message.markdown ?? ""), sourcePath || void 0);
         const safeName = rawName.replace(/[\\/:*?"<>|]/g, " ").trim().slice(0, 120) || "article";
-        const targetPath = path.join(dir, `${safeName}.${ext}`);
-        await writeFile(targetPath, Buffer.from(dataBase64, "base64"));
+        const targetPath = path3.join(dir, `${safeName}.${ext}`);
+        await writeFile2(targetPath, Buffer.from(dataBase64, "base64"));
         await panel.postMessage({ type: "exported", path: targetPath, requestId: message.requestId });
       } catch (error) {
         await panel.postMessage({ type: "error", message: `Could not export file: ${error instanceof Error ? error.message : String(error)}` });
@@ -706,6 +964,12 @@ function activate(ctx) {
     },
     "swatch-book": {
       svg: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M11 17a4 4 0 0 1-8 0V5a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2Z"/><path d="M16.7 13H19a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2H7"/><path d="M 7 17h.01"/><path d="m11 8 2.3-2.3a2.4 2.4 0 0 1 3.404.004L18.6 7.6a2.4 2.4 0 0 1 .026 3.434L9.9 19.8"/></svg>'
+    },
+    // Static hourglass shown on the Preview button while bm.md rendering is
+    // in flight — a plain status hint, deliberately not animated (SMIL does
+    // not run on host-rendered SVGs and frame-swapping felt janky).
+    "hourglass": {
+      svg: '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M5 22h14"/><path d="M5 2h14"/><path d="M17 22v-4.172a2 2 0 0 0-.586-1.414L12 12l-4.414 4.414A2 2 0 0 0 7 17.828V22"/><path d="M7 2v4.172a2 2 0 0 0 .586 1.414L12 12l4.414-4.414A2 2 0 0 0 17 6.172V2"/></svg>'
     }
   }));
   ctx.subscriptions.push(ctx.ui.onDidOpenPanel((panel) => {
@@ -734,14 +998,27 @@ function activate(ctx) {
 action:
   open \u2014 read an absolute local Markdown path and open it as an editable WeChat article preview
   create \u2014 write brand-new Markdown content to an absolute path that does not exist yet, then open it in Markdown Editor. Use this whenever the user asks to write an article, start writing, write a post, create, or draft a new document \u2014 even if they do not mention Markdown. If title/topic or destination is missing, guide the user to provide it; once known, create and open the document rather than returning prose only. If they only want to begin, create a minimal titled starter document. Markdown Editor's own UI has no "new file" button on purpose \u2014 this tool action is the intended way to start a new document
-  apply \u2014 replace a source document with reviewed Markdown (requires path and markdown); the open panel refreshes in place, no Diff window
+  apply \u2014 revise a source document (requires path). For a small, targeted change, pass edits instead of markdown: an array of {old_string, new_string} replacements matched against the file's current on-disk content, the same find-and-replace contract as a code editor's Edit tool \u2014 this avoids resending the whole document and keeps the on-screen highlight scoped to what actually changed. Reserve markdown (the full updated document) for a genuine full rewrite. Once this conversation has started editing a .md document through Markdown Editor, always use this apply/edits path for subsequent changes to that same file before considering the built-in Edit tool: it refreshes the panel and highlights the exact change. Fall back to the built-in Edit tool only after this apply actually fails. The open panel refreshes in place, no Diff window. Whenever you propose a rewrite and wait for approval before applying it, calling Session action=suggest with 1-3 one-tap confirmations is MANDATORY, not optional, and part of that same turn \u2014 sending the proposal text alone does not complete the confirmation step, so do not end the turn without also calling it
   set_style \u2014 apply an AI-designed custom CSS layout to the currently open Markdown Editor preview (requires css). Write plain CSS scoped under #bm-md using tag/id selectors (no classes), use !important where needed to override the base style, and take inspiration from bm.md's built-in styles: kami (warm paper), bauhaus (geometric primary colors), blueprint (technical grid), botanical (soft green), newsprint (editorial serif), retro (nostalgic), sketch (hand-drawn), terminal (monospace dark).`,
     inputSchema: {
       type: "object",
       properties: {
         action: { type: "string", enum: ["open", "create", "apply", "set_style"], description: "Operation to perform." },
         path: { type: "string", description: "Absolute path to the Markdown file. Required for open, create, and apply. For create, the file must not already exist." },
-        markdown: { type: "string", description: "Full Markdown content, required for create and apply." },
+        markdown: { type: "string", description: "Full Markdown content. Required for create. For apply, use this only for a genuine full rewrite \u2014 prefer `edits` for a small, targeted change." },
+        edits: {
+          type: "array",
+          description: "For apply only: targeted local replacements instead of resending the whole document. Each old_string is matched against the file's current on-disk content (already reflecting earlier items in this same array) and must match exactly once unless replace_all is set. Prefer this over `markdown` for anything short of a full rewrite.",
+          items: {
+            type: "object",
+            properties: {
+              old_string: { type: "string", description: "Exact existing text to replace; must be unique in the file unless replace_all is true." },
+              new_string: { type: "string", description: "Replacement text." },
+              replace_all: { type: "boolean", description: "Replace every occurrence of old_string instead of requiring it to be unique." }
+            },
+            required: ["old_string", "new_string"]
+          }
+        },
         css: { type: "string", description: "Custom CSS to layer on top of the current base style, required for set_style." },
         label: { type: "string", description: "Short label describing the custom style, optional for set_style." },
         slot: { type: "number", enum: [1, 2, 3], description: "Required for AI-designed styles: user-selected reusable custom style slot to overwrite." }
@@ -753,7 +1030,7 @@ action:
       const action = String(input.action ?? "");
       if (action === "open" || action === "create" || action === "apply") {
         const sourcePath = String(input.path ?? "").trim();
-        if (!path.isAbsolute(sourcePath)) return result("`path` must be an absolute local path.", true);
+        if (!path3.isAbsolute(sourcePath)) return result("`path` must be an absolute local path.", true);
         if (action === "open") {
           try {
             const { markdown: markdown2, diskMarkdown, draftRestored, draftConflict } = await readFileWithDraft(ctx, sourcePath);
@@ -762,7 +1039,7 @@ action:
             watchSource(ctx, panel, sourcePath);
             await rememberLastPath(ctx, panel, sourcePath);
             await sendDocument(panel, { path: sourcePath, markdown: markdown2, title: documentTitle(markdown2, sourcePath), draftRestored, draftConflict, diskMarkdown });
-            return result(`Opened Markdown Editor for ${path.basename(sourcePath)}.`);
+            return result(`Opened Markdown Editor for ${path3.basename(sourcePath)}.`);
           } catch (error) {
             return result(`Could not read ${sourcePath}: ${error instanceof Error ? error.message : String(error)}`, true);
           }
@@ -772,23 +1049,46 @@ action:
           try {
             const alreadyExists = await stat(sourcePath).then(() => true).catch(() => false);
             if (alreadyExists) return result(`${sourcePath} already exists. Use action 'open' to view it or 'apply' to revise it instead.`, true);
-            await mkdir(path.dirname(sourcePath), { recursive: true });
-            await writeFile(sourcePath, markdown2, "utf8");
+            await mkdir2(path3.dirname(sourcePath), { recursive: true });
+            await writeFile2(sourcePath, markdown2, "utf8");
             const panel = ctx.ui.createPanel({ instanceMode: "single", payload: { path: sourcePath } });
             await panel.reveal();
             watchSource(ctx, panel, sourcePath);
             await rememberLastPath(ctx, panel, sourcePath);
             await sendDocument(panel, { path: sourcePath, markdown: markdown2, title: documentTitle(markdown2, sourcePath) });
-            return result(`Created ${path.basename(sourcePath)} and opened it in Markdown Editor.`);
+            return result(`Created ${path3.basename(sourcePath)} and opened it in Markdown Editor.`);
           } catch (error) {
             return result(`Could not create ${sourcePath}: ${error instanceof Error ? error.message : String(error)}`, true);
           }
         }
+        const rawEdits = Array.isArray(input.edits) ? input.edits : void 0;
+        if (rawEdits && rawEdits.length > 0) {
+          const edits = rawEdits.map((entry) => {
+            const item = entry && typeof entry === "object" ? entry : {};
+            return {
+              old_string: typeof item.old_string === "string" ? item.old_string : "",
+              new_string: typeof item.new_string === "string" ? item.new_string : "",
+              replace_all: Boolean(item.replace_all)
+            };
+          });
+          try {
+            const current = await readFile2(sourcePath, "utf8");
+            const applied = applyEditSpecs(current, edits);
+            if (!applied.ok) return result(applied.error, true);
+            await writeFile2(sourcePath, applied.content, "utf8");
+            await rememberRecentPath(ctx, sourcePath);
+            return result(`Applied ${edits.length} targeted edit${edits.length > 1 ? "s" : ""} to ${path3.basename(sourcePath)}.`);
+          } catch (error) {
+            return result(`Could not apply edits: ${error instanceof Error ? error.message : String(error)}`, true);
+          }
+        }
         const markdown = String(input.markdown ?? "");
-        if (!markdown) return result("`apply` requires non-empty `markdown`.", true);
+        if (!markdown) return result("`apply` requires either `edits` (targeted replacements) or non-empty `markdown` (full document).", true);
         try {
-          await writeFile(sourcePath, markdown, "utf8");
-          return result(`Applied reviewed Markdown to ${path.basename(sourcePath)}.`);
+          const current = await readFile2(sourcePath, "utf8");
+          await writeFile2(sourcePath, preserveTextEnvelope(current, markdown), "utf8");
+          await rememberRecentPath(ctx, sourcePath);
+          return result(`Applied reviewed Markdown to ${path3.basename(sourcePath)}.`);
         } catch (error) {
           return result(`Could not apply revision: ${error instanceof Error ? error.message : String(error)}`, true);
         }