finch-markdown-editor 0.2.1 → 0.2.3

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
 import { createHash as createHash3 } from "node:crypto";
-import { mkdir as mkdir2, readFile as readFile2, realpath, stat, writeFile as writeFile2 } from "node:fs/promises";
+import { appendFile, mkdir as mkdir2, readFile as readFile2, realpath, rename, stat, writeFile as writeFile2 } from "node:fs/promises";
 import { watch } from "node:fs";
 import { spawn as spawn2 } from "node:child_process";
 import path3 from "node:path";
@@ -161,6 +161,39 @@ async function runBmmd(args, input) {
 }
 var FINCH_FILE_IMAGE_RE = /finch-file:\/\/local\?path=[^\s)"']+/g;
 var FINCH_IMAGE_PLACEHOLDER_ORIGIN = "https://finch-local.invalid/markdown-image/";
+var MARKDOWN_IMAGE_ALT_RE = /!\[([^\]\n]*)\](?=\()/g;
+function prepareObsidianImageWidths(markdown) {
+  const markers = [];
+  const prepared = markdown.replace(MARKDOWN_IMAGE_ALT_RE, (whole, rawAlt) => {
+    const sized = /^(.*)\|(\d+)(?:x\d+)?$/.exec(rawAlt);
+    const width = sized ? Number(sized[2]) : NaN;
+    if (!sized || !Number.isFinite(width) || width <= 0) return whole;
+    const normalizedWidth = Math.round(width);
+    const token = `FINCHIMGSIZE${markers.length}X${normalizedWidth}X`;
+    markers.push({ token, width: normalizedWidth, emptyCaption: !sized[1] });
+    return `![${sized[1]}${token}]`;
+  });
+  return { markdown: prepared, markers };
+}
+function applyObsidianImageWidths(html, markers) {
+  let rendered = html;
+  for (const marker of markers) {
+    const widthStyle = `width: ${marker.width}px; max-width: 100%; height: auto;`;
+    rendered = rendered.replace(/<img\b[^>]*>/gi, (tag) => {
+      if (!tag.includes(marker.token)) return tag;
+      const cleanTag = tag.split(marker.token).join("");
+      if (/\sstyle="[^"]*"/i.test(cleanTag)) {
+        return cleanTag.replace(/\sstyle="([^"]*)"/i, (_styleAttr, style) => ` style="${style} ${widthStyle}"`);
+      }
+      return cleanTag.replace(/>$/, ` style="${widthStyle}">`);
+    });
+    if (marker.emptyCaption) {
+      rendered = rendered.replace(/<figcaption\b[^>]*>[\s\S]*?<\/figcaption>/gi, (caption) => caption.includes(marker.token) ? "" : caption);
+    }
+    rendered = rendered.split(marker.token).join("");
+  }
+  return rendered;
+}
 function substituteFinchFileImagesForBm(markdown) {
   const urls = /* @__PURE__ */ new Map();
   let sequence = 0;
@@ -174,8 +207,10 @@ function substituteFinchFileImagesForBm(markdown) {
 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);
+  const sized = prepareObsidianImageWidths(markdown);
+  const prepared = substituteFinchFileImagesForBm(sized.markdown);
   let html = await runBmmd(args, prepared.markdown);
+  html = applyObsidianImageWidths(html, sized.markers);
   for (const [placeholder, originalUrl] of prepared.urls) html = html.split(placeholder).join(originalUrl);
   return html;
 }
@@ -236,6 +271,8 @@ async function openMarkdownImagePreview(ctx, rawUrl) {
   throw new Error(`Unsupported image URL: ${url.protocol}`);
 }
 var STYLE_SLOT_COUNT = 3;
+var WRITING_STYLE_IDS = /* @__PURE__ */ new Set(["kami", "bauhaus", "blueprint", "botanical", "newsprint", "retro", "sketch", "terminal", "custom"]);
+var MAX_CUSTOM_STYLE_CSS_LENGTH = 2e5;
 function result(message, isError = false) {
   return { content: [{ type: "text", text: message }], isError };
 }
@@ -245,6 +282,39 @@ function stateFile(ctx) {
 function styleSlotsFile(ctx) {
   return path3.join(ctx.storagePath, "style-slots.json");
 }
+function writingPreferencesFile(ctx) {
+  return path3.join(ctx.storagePath, "writing-preferences.json");
+}
+function normalizeWritingPreferences(raw) {
+  const value = raw && typeof raw === "object" ? raw : {};
+  const fontSize = value.fontSize === 16 || value.fontSize === 18 ? value.fontSize : 14;
+  const fontFamily = value.fontFamily === "songti" ? "songti" : "rounded";
+  const customCss = typeof value.customCss === "string" ? value.customCss.slice(0, MAX_CUSTOM_STYLE_CSS_LENGTH) : "";
+  const requestedStyle = typeof value.style === "string" ? value.style : "kami";
+  const style = WRITING_STYLE_IDS.has(requestedStyle) && (requestedStyle !== "custom" || customCss) ? requestedStyle : "kami";
+  return {
+    fontSize,
+    fontFamily,
+    comfortWriting: value.comfortWriting === true,
+    style,
+    customCss: style === "custom" ? customCss : "",
+    customStyleLabel: style === "custom" && typeof value.customStyleLabel === "string" ? value.customStyleLabel.slice(0, 120) : ""
+  };
+}
+async function readWritingPreferences(ctx) {
+  try {
+    const raw = await readFile2(writingPreferencesFile(ctx), "utf8");
+    return normalizeWritingPreferences(JSON.parse(raw));
+  } catch {
+    return void 0;
+  }
+}
+async function writeWritingPreferences(ctx, raw) {
+  const preferences = normalizeWritingPreferences(raw);
+  await mkdir2(ctx.storagePath, { recursive: true });
+  await writeFile2(writingPreferencesFile(ctx), JSON.stringify(preferences), "utf8");
+  return preferences;
+}
 function normalizeStyleSlots(raw) {
   const arr = Array.isArray(raw) ? raw : [];
   const slots = [];
@@ -284,6 +354,34 @@ async function readLastPathState(ctx) {
     return {};
   }
 }
+async function loadStateForWrite(ctx) {
+  let raw;
+  try {
+    raw = await readFile2(stateFile(ctx), "utf8");
+  } catch (error) {
+    if (error?.code === "ENOENT") return {};
+    throw error;
+  }
+  if (!raw.trim()) throw new Error("state file is present but empty");
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("state file is not an object");
+  return parsed;
+}
+var stateWriteChain = Promise.resolve();
+async function mutateState(ctx, mutate) {
+  const run = stateWriteChain.then(async () => {
+    const state = await loadStateForWrite(ctx);
+    if (await mutate(state) === false) return;
+    await mkdir2(ctx.storagePath, { recursive: true });
+    const target = stateFile(ctx);
+    const temp = `${target}.${process.pid}.tmp`;
+    await writeFile2(temp, JSON.stringify(state), "utf8");
+    await rename(temp, target);
+  });
+  stateWriteChain = run.catch(() => {
+  });
+  return run;
+}
 function resolveRecentScope(state, cwd, sessionId, spaceId) {
   if (path3.isAbsolute(cwd)) {
     if (sessionId && !spaceId) state.homePath = cwd;
@@ -313,26 +411,39 @@ async function resolveDocumentScope(ctx, sourcePath, fallbackCwd) {
     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 describePanelScope(ctx, scopeDir, sessionSpaceId) {
+  const spaces = await ctx.spaces.list().catch(() => []);
+  const named = (space) => space.name || space.alias || (space.directoryPath ? path3.basename(space.directoryPath) : space.id);
+  if (sessionSpaceId) {
+    const space = spaces.find((entry) => entry.id === sessionSpaceId);
+    if (space) {
+      const label = named(space);
+      return { spaceId: space.id, spaceName: label, scopeLabel: label, scopeKind: "space", scopePath: space.directoryPath || scopeDir };
+    }
+  }
+  const match = spaces.filter((space) => path3.isAbsolute(space.directoryPath ?? "") && pathBelongsTo(space.directoryPath, scopeDir)).sort((a, b) => (b.directoryPath?.length ?? 0) - (a.directoryPath?.length ?? 0))[0];
+  if (match?.directoryPath) {
+    const label = named(match);
+    return { spaceId: match.id, spaceName: label, scopeLabel: label, scopeKind: "space", scopePath: match.directoryPath };
+  }
+  return { scopeKind: "workspace", scopePath: scopeDir };
+}
 async function rememberPanelRecentScope(ctx, panel, cwd, sessionId, spaceId) {
   try {
-    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");
+    let resolved = {};
+    await mutateState(ctx, (state) => {
+      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);
+      }
+    });
     return resolved;
   } catch (error) {
     ctx.logger.warn(`Could not persist panel recent scope: ${String(error)}`);
@@ -341,32 +452,42 @@ async function rememberPanelRecentScope(ctx, panel, cwd, sessionId, spaceId) {
 }
 async function rememberLastPath(ctx, panel, sourcePath) {
   try {
-    await mkdir2(ctx.storagePath, { recursive: true });
-    const state = await readLastPathState(ctx);
-    state.panels = { ...state.panels, [panel.id]: sourcePath };
-    state.sessions = { ...state.sessions, [sessionBucketKey(panel)]: sourcePath };
-    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");
+    await mutateState(ctx, async (state) => {
+      state.panels = { ...state.panels, [panel.id]: sourcePath };
+      state.sessions = { ...state.sessions, [sessionBucketKey(panel)]: sourcePath };
+      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);
+    });
   } 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");
+    await mutateState(ctx, (state) => {
+      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);
+    });
   } catch (error) {
     ctx.logger.warn(`Could not persist recent path: ${String(error)}`);
   }
 }
+async function forgetLastPath(ctx, panel) {
+  try {
+    await mutateState(ctx, (state) => {
+      const key = sessionBucketKey(panel);
+      state.panels = { ...state.panels, [panel.id]: "" };
+      state.sessions = { ...state.sessions, [key]: "" };
+      if (key === "__global__" && typeof state.lastPath === "string") state.lastPath = "";
+    });
+  } catch (error) {
+    ctx.logger.warn(`Could not clear last-opened path: ${String(error)}`);
+  }
+}
 async function readLastPath(ctx, panel) {
   const state = await readLastPathState(ctx);
   const perPanel = state.panels?.[panel.id];
@@ -402,36 +523,24 @@ async function collectRecentDocuments(ctx, requestedCwd, sessionId, spaceId) {
   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 readFile2(filePath, "utf8");
-        const fileName = path3.basename(filePath);
-        return {
-          path: filePath,
-          relativePath: path3.relative(scope, filePath),
-          fileName,
-          title: deriveTitle(markdown, fileName.replace(/\.[^.]+$/, "")),
-          preview: derivePreview(markdown),
-          modifiedAt: info.mtimeMs
-        };
-      } catch {
-        return void 0;
-      }
-    })
-  );
+  const descriptor = await describePanelScope(ctx, scope, spaceId);
+  const scopeRoot = descriptor.scopePath && path3.isAbsolute(descriptor.scopePath) ? descriptor.scopePath : scope;
+  const classified = await classifyTrackedDocuments(ctx, state);
+  const documents = classified.filter((doc) => descriptor.spaceId ? doc.spaceId === descriptor.spaceId : !doc.spaceId && pathBelongsTo(scopeRoot, doc.path)).map((doc) => ({
+    ...doc,
+    relativePath: path3.relative(scopeRoot, doc.path),
+    spaceId: descriptor.spaceId,
+    spaceName: descriptor.spaceName,
+    scopeLabel: descriptor.scopeLabel,
+    scopeKind: descriptor.scopeKind,
+    scopePath: descriptor.scopePath
+  }));
   return {
-    documents: documents.filter((entry) => Boolean(entry)).sort((a, b) => b.modifiedAt - a.modifiedAt).slice(0, RECENT_LIMIT),
+    documents: documents.slice(0, RECENT_LIMIT),
     fallbackCwd: resolved.fallbackCwd
   };
 }
-async function collectLibraryDocuments(ctx) {
-  const state = await readLastPathState(ctx);
+async function classifyTrackedDocuments(ctx, state) {
   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 {
@@ -448,24 +557,55 @@ async function collectLibraryDocuments(ctx) {
         spaceId: scope.spaceId,
         spaceName: scope.spaceName,
         scopeLabel: scope.scopeLabel,
-        scopeKind: scope.scopeKind
+        scopeKind: scope.scopeKind,
+        scopePath: scope.scope
       };
     } catch {
       return void 0;
     }
   }));
-  return documents.filter((entry) => Boolean(entry)).sort((a, b) => b.modifiedAt - a.modifiedAt).slice(0, RECENT_LIMIT);
+  return documents.filter((entry) => Boolean(entry)).sort((a, b) => b.modifiedAt - a.modifiedAt);
+}
+async function collectLibraryDocuments(ctx) {
+  const state = await readLastPathState(ctx);
+  const classified = await classifyTrackedDocuments(ctx, state);
+  const perCategory = /* @__PURE__ */ new Map();
+  return classified.filter((doc) => {
+    const key = doc.spaceId ? `space:${doc.spaceId}` : `${doc.scopeKind}:${doc.scopePath ?? ""}`;
+    const used = perCategory.get(key) ?? 0;
+    if (used >= RECENT_LIMIT) return false;
+    perCategory.set(key, used + 1);
+    return true;
+  });
 }
 var livePanelDocuments = /* @__PURE__ */ new Map();
+var openPanels = /* @__PURE__ */ new Map();
+var fileRevisions = /* @__PURE__ */ new Map();
+function nextFileRevision(sourcePath) {
+  const next = (fileRevisions.get(sourcePath) ?? 0) + 1;
+  fileRevisions.set(sourcePath, next);
+  return next;
+}
 async function sendDocument(panel, state) {
-  livePanelDocuments.set(panel.id, state);
-  await panel.postMessage({ type: "document", ...state });
+  const revision = state.path && path3.isAbsolute(state.path) ? state.revision ?? nextFileRevision(state.path) : state.revision;
+  const delivered = revision === void 0 ? state : { ...state, revision };
+  livePanelDocuments.set(panel.id, delivered);
+  await panel.postMessage({ type: "document", ...delivered });
+}
+async function publishFileUpdate(ctx, sourcePath) {
+  const markdown = await readFile2(sourcePath, "utf8");
+  const revision = nextFileRevision(sourcePath);
+  const state = { path: sourcePath, markdown, title: documentTitle(markdown, sourcePath), revision };
+  const targets = Array.from(openPanels.values()).filter((panel) => livePanelDocuments.get(panel.id)?.path === sourcePath);
+  await Promise.all(targets.map((panel) => sendDocument(panel, state).catch((error) => {
+    ctx.logger.warn(`Could not deliver written file to panel ${panel.id}: ${String(error)}`);
+  })));
 }
 async function sendLiveDocument(ctx, panel, liveDocument) {
   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 });
+      await sendDocument(panel, { ...liveDocument, revision: void 0, markdown, title: documentTitle(markdown, liveDocument.path), draftRestored, draftConflict, diskMarkdown });
       return;
     } catch (error) {
       ctx.logger.warn(`Could not re-read ${liveDocument.path} for a reconnecting panel, resending cached copy: ${String(error)}`);
@@ -511,8 +651,10 @@ function watchSource(ctx, panel, sourcePath) {
     entry.watcher = watch(sourcePath, () => {
       if (entry.timer) clearTimeout(entry.timer);
       entry.timer = setTimeout(async () => {
+        const revisionBeforeRead = fileRevisions.get(sourcePath) ?? 0;
         try {
           const markdown = await readFile2(sourcePath, "utf8");
+          if (panelWatchers.get(panel.id) !== entry || (fileRevisions.get(sourcePath) ?? 0) !== revisionBeforeRead) return;
           await sendDocument(panel, { path: sourcePath, markdown, title: documentTitle(markdown, sourcePath) });
         } catch (error) {
           ctx.logger.warn(`Source refresh failed: ${String(error)}`);
@@ -542,14 +684,18 @@ async function getAssistantName(ctx) {
 }
 async function sendReady(ctx, panel) {
   const pickFileSupported = ctx.api.supports("ui.pickFile");
-  const styleSlots = await readStyleSlots(ctx);
-  const assistantName = await getAssistantName(ctx);
+  const [styleSlots, writingPreferences, assistantName] = await Promise.all([
+    readStyleSlots(ctx),
+    readWritingPreferences(ctx),
+    getAssistantName(ctx)
+  ]);
   ctx.logger.info(`sending ready to panel; pickFileSupported = ${pickFileSupported}`);
   await panel.postMessage({
     type: "ready",
     locale: ctx.i18n.locale,
     pickFileSupported,
     styleSlots,
+    writingPreferences,
     assistantName,
     // So the page can render `cwd` the OS-friendly way (`~/…`) without a
     // round trip — it never needs the raw value for anything but display.
@@ -580,13 +726,60 @@ async function readRewriteSession(ctx, sourcePath) {
 }
 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");
+    await mutateState(ctx, (state) => {
+      state.rewriteSessions = { ...state.rewriteSessions, [sourcePath]: sessionId };
+    });
   } catch (error) {
     ctx.logger.warn(`Could not persist rewrite session: ${String(error)}`);
   }
 }
+async function rememberStyleOperation(ctx, sourcePath, operation) {
+  await mutateState(ctx, (state) => {
+    state.styleOperations = { ...state.styleOperations, [sourcePath]: operation };
+  });
+}
+async function clearStyleOperation(ctx, sourcePath, turnId) {
+  await mutateState(ctx, (state) => {
+    if (state.styleOperations?.[sourcePath]?.turnId !== turnId) return false;
+    const operations = { ...state.styleOperations };
+    delete operations[sourcePath];
+    state.styleOperations = operations;
+  });
+}
+async function rememberPendingStyle(ctx, sourcePath, pending) {
+  await mutateState(ctx, (state) => {
+    state.pendingStyles = { ...state.pendingStyles, [sourcePath]: pending };
+  });
+}
+async function clearPendingStyle(ctx, sourcePath) {
+  await mutateState(ctx, (state) => {
+    if (!state.pendingStyles?.[sourcePath]) return false;
+    const pending = { ...state.pendingStyles };
+    delete pending[sourcePath];
+    state.pendingStyles = pending;
+  });
+}
+function findPanelsForPath(sourcePath) {
+  return Array.from(openPanels.values()).filter((panel) => livePanelDocuments.get(panel.id)?.path === sourcePath);
+}
+async function rememberRewriteOperation(ctx, sourcePath, operation) {
+  await mutateState(ctx, (state) => {
+    state.rewriteOperations = { ...state.rewriteOperations, [sourcePath]: operation };
+  });
+}
+async function clearRewriteOperation(ctx, sourcePath, turnId) {
+  await mutateState(ctx, (state) => {
+    if (state.rewriteOperations?.[sourcePath]?.turnId !== turnId) return false;
+    const operations = { ...state.rewriteOperations };
+    delete operations[sourcePath];
+    state.rewriteOperations = operations;
+  });
+}
+async function notifyRewritePanels(sourcePath, message) {
+  const targets = Array.from(openPanels.values()).filter((panel) => livePanelDocuments.get(panel.id)?.path === sourcePath);
+  await Promise.all(targets.map((panel) => panel.postMessage(message).catch(() => {
+  })));
+}
 async function startRewriteSession(ctx, panel, message) {
   const sourcePath = String(message.path ?? "").trim();
   const selectedText = String(message.selectedText ?? "").trim();
@@ -634,30 +827,104 @@ ${selectedText}
     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({
+  const operation = {
+    sessionId,
+    turnId: receipt.turnId,
+    startLine: message.startLine,
+    endLine: message.endLine ?? message.startLine,
+    rewriteMode,
+    startedAt: Date.now()
+  };
+  await rememberRewriteOperation(ctx, sourcePath, operation).catch((error) => ctx.logger.warn(`Could not persist rewrite operation: ${String(error)}`));
+  await notifyRewritePanels(sourcePath, {
     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,
+    startLine: operation.startLine,
+    endLine: operation.endLine,
     rewriteMode
   });
   void ctx.sessions.waitForTurn(sessionId, receipt.turnId, { timeoutMs: 6e5 }).then(async (result2) => {
     const verb = rewriteMode === "continue" ? "\u7EED\u5199" : "\u6539\u5199";
-    await panel.postMessage({
+    await clearRewriteOperation(ctx, sourcePath, receipt.turnId).catch((error) => ctx.logger.warn(`Could not clear rewrite operation: ${String(error)}`));
+    await notifyRewritePanels(sourcePath, {
       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 readStyleSession(ctx, sourcePath) {
+  const state = await readLastPathState(ctx);
+  const id = state.styleSessions?.[sourcePath];
+  if (!id) return void 0;
+  const session = await ctx.sessions.get(id).catch(() => void 0);
+  return session ? id : void 0;
+}
+async function rememberStyleSession(ctx, sourcePath, sessionId) {
+  try {
+    await mutateState(ctx, (state) => {
+      state.styleSessions = { ...state.styleSessions, [sourcePath]: sessionId };
+    });
+  } catch (error) {
+    ctx.logger.warn(`Could not persist style session: ${String(error)}`);
+  }
+}
+async function startStyleSession(ctx, panel, message) {
+  const sourcePath = String(message.path ?? "").trim();
+  if (panel.view !== "appView" || !path3.isAbsolute(sourcePath)) {
+    await panel.postMessage({ type: "styleSessionFailed", message: "\u8BA9 AI \u8BBE\u8BA1\u6392\u7248\u9700\u8981 App View \u4E2D\u5DF2\u4FDD\u5B58\u7684\u672C\u5730\u6587\u6863\u3002" });
+    return;
+  }
+  const requirement = String(message.requirement ?? "").trim() || "\u8BA9\u6392\u7248\u66F4\u6E05\u6670\u7F8E\u89C2\uFF0C\u8D34\u5408\u6587\u7AE0\u5185\u5BB9\u548C\u8BED\u6C14";
+  const baseStyle = String(message.baseStyle ?? "").trim();
+  const baseNote = baseStyle === "custom" ? "\u5F53\u524D\u57FA\u7840\u98CE\u683C\u662F kami\uFF08\u81EA\u5B9A\u4E49 CSS \u53E0\u52A0\u5176\u4E0A\uFF09" : baseStyle ? `\u5F53\u524D\u57FA\u7840\u98CE\u683C\u662F ${baseStyle}` : "";
+  const scope = await resolveDocumentScope(ctx, sourcePath);
+  let sessionId = await readStyleSession(ctx, sourcePath);
+  if (!sessionId) {
+    const session = await ctx.sessions.create({
+      ...scope.spaceId ? { space: { spaceId: scope.spaceId } } : {},
+      title: `\u8BBE\u8BA1\u6392\u7248\uFF1A${path3.basename(sourcePath)}`,
+      activity: "interactive",
+      permissionMode: "acceptCalls"
+    });
+    sessionId = session.sessionId;
+    await rememberStyleSession(ctx, sourcePath, sessionId);
+  }
+  const prompt = `\u8BF7\u4E3A\u8FD9\u7BC7\u516C\u4F17\u53F7\u6587\u7AE0\u8BBE\u8BA1\u4E00\u5957\u81EA\u5B9A\u4E49\u6392\u7248 CSS\u3002${baseNote ? baseNote + "\uFF0C" : ""}\u4F60\u7684 CSS \u4F1A\u53E0\u52A0\u5728\u57FA\u7840\u98CE\u683C\u4E4B\u4E0A\u3002\u8981\u6C42\uFF1A\u53EA\u5199\u666E\u901A CSS \u89C4\u5219\uFF0C\u9009\u62E9\u5668\u9650\u5B9A\u5728 #bm-md \u4E0B\u7684\u6807\u7B7E/\u7ED3\u6784\uFF08\u5982 #bm-md h1\u3001#bm-md p\u3001#bm-md blockquote\u3001#bm-md pre code\u3001#bm-md a\u3001#bm-md strong\u3001#bm-md table \u7B49\uFF09\uFF0C\u4E0D\u8981\u4F7F\u7528 class\uFF0C\u5FC5\u8981\u65F6\u7528 !important \u8986\u76D6\u57FA\u7840\u98CE\u683C\u3002\u53EF\u53C2\u8003 bm.md \u5185\u7F6E\u98CE\u683C\u7684\u8BBE\u8BA1\u8BED\u8A00\uFF1Akami\uFF08\u6696\u8272\u7EB8\u611F\uFF09\u3001bauhaus\uFF08\u51E0\u4F55\u649E\u8272\uFF09\u3001blueprint\uFF08\u6280\u672F\u84DD\u56FE\u7F51\u683C\uFF09\u3001botanical\uFF08\u6E05\u65B0\u7EFF\u610F\uFF09\u3001newsprint\uFF08\u62A5\u520A\u886C\u7EBF\uFF09\u3001retro\uFF08\u590D\u53E4\u6000\u65E7\uFF09\u3001sketch\uFF08\u624B\u7ED8\u98CE\uFF09\u3001terminal\uFF08\u7B49\u5BBD\u6697\u8272\u7EC8\u7AEF\u98CE\uFF09\u3002\u6587\u7AE0\u8DEF\u5F84\uFF1A${sourcePath}\u3002\u8981\u6C42\uFF1A${requirement}\u3002\u8BBE\u8BA1\u597D\u540E\u76F4\u63A5\u8C03\u7528 markdown_editor_document \u7684 set_style\uFF08\u4F20 path="${sourcePath}"\uFF0Ccss \u548C\u7B80\u77ED label\uFF0C\u4E0D\u8981\u4F20 slot\u2014\u2014\u4F20 path \u662F\u4E3A\u4E86\u8BA9\u5B83\u80FD\u627E\u5230\u8FD9\u7BC7\u6587\u6863\u5BF9\u5E94\u7684\u9884\u89C8\u7A97\u53E3\uFF0C\u5373\u4F7F\u7528\u6237\u5DF2\u7ECF\u5207\u6362\u5230\u522B\u7684\u754C\u9762\uFF09\uFF0C\u8BA9\u5B83\u5E94\u7528\u5230\u9884\u89C8\uFF1B\u4E0D\u8981\u5728\u8FD9\u91CC\u8BE2\u95EE\u8981\u8986\u76D6\u54EA\u4E2A\u69FD\u4F4D\u2014\u2014\u9762\u677F\u4F1A\u81EA\u5DF1\u7ED9\u7528\u6237\u4E00\u4E2A\u8F7B\u91CF\u7684\u201C\u4FDD\u5B58\u4E3A\u81EA\u5B9A\u4E49\u98CE\u683C\u201D\u6309\u94AE\uFF0C\u7528\u6237\u56DE\u5230\u8FD9\u7BC7\u6587\u6863\u65F6\u4E5F\u8FD8\u80FD\u770B\u5230\u3002\u5B8C\u6210\u540E\u7528\u4E00\u4E24\u53E5\u8BDD\u7B80\u77ED\u8BF4\u660E\u8BBE\u8BA1\u601D\u8DEF\u5373\u53EF\u3002`;
+  const receipt = await ctx.sessions.send(sessionId, {
+    text: prompt,
+    idempotencyKey: `style-${createHash3("sha256").update(`${sourcePath}:${requirement}:${Date.now()}`).digest("hex")}`
+  });
+  if (receipt.state === "rejected") {
+    await panel.postMessage({ type: "styleSessionFailed", message: "\u6392\u7248\u8BBE\u8BA1\u4F1A\u8BDD\u961F\u5217\u7E41\u5FD9\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002" });
+    return;
+  }
+  await rememberStyleOperation(ctx, sourcePath, { sessionId, turnId: receipt.turnId, startedAt: Date.now() });
+  await panel.postMessage({ type: "styleSessionStarted", sessionId, spaceName: scope.spaceName });
+  void ctx.sessions.waitForTurn(sessionId, receipt.turnId, { timeoutMs: 6e5 }).then(async (result2) => {
+    await clearStyleOperation(ctx, sourcePath, receipt.turnId);
+    const targets = findPanelsForPath(sourcePath);
+    await Promise.all((targets.length ? targets : [panel]).map((target) => target.postMessage({
+      type: result2.state === "completed" ? "styleSessionFinished" : "styleSessionFailed",
+      sessionId,
+      message: result2.state === "completed" ? "\u6392\u7248\u8BBE\u8BA1\u5DF2\u5B8C\u6210\u3002" : result2.state === "timeout" ? "\u6392\u7248\u8BBE\u8BA1\u4ECD\u5728\u4F1A\u8BDD\u4E2D\u7EE7\u7EED\u3002" : "\u6392\u7248\u8BBE\u8BA1\u4F1A\u8BDD\u672A\u5B8C\u6210\u3002"
+    }).catch(() => {
+    })));
+  });
+}
 async function handleMessage(ctx, panel, raw) {
   const message = raw;
   switch (message.type) {
     case "clientLog": {
-      ctx.logger.info(`[panel] ${String(message.message ?? "")}`);
+      const text = `[panel] ${String(message.message ?? "")}`;
+      ctx.logger.info(text);
+      try {
+        await appendFile(path3.join(ctx.storagePath, "panel-errors.log"), `${(/* @__PURE__ */ new Date()).toISOString()} ${text}
+`);
+      } catch (_) {
+      }
       return;
     }
     case "panelReady": {
@@ -668,6 +935,22 @@ async function handleMessage(ctx, panel, raw) {
       } else if (!await restoreDocument(ctx, panel)) {
         await panel.postMessage({ type: "lastFileUnavailable" });
       }
+      const currentPath = livePanelDocuments.get(panel.id)?.path;
+      if (currentPath) {
+        const state = await readLastPathState(ctx);
+        const operation = state.rewriteOperations?.[currentPath];
+        if (operation) await panel.postMessage({
+          type: "rewriteSessionStarted",
+          sessionId: operation.sessionId,
+          startLine: operation.startLine,
+          endLine: operation.endLine,
+          rewriteMode: operation.rewriteMode
+        });
+        const styleOperation = state.styleOperations?.[currentPath];
+        if (styleOperation) await panel.postMessage({ type: "styleSessionStarted", sessionId: styleOperation.sessionId });
+        const pendingStyle = state.pendingStyles?.[currentPath];
+        if (pendingStyle) await panel.postMessage({ type: "customStyleSet", css: pendingStyle.css, label: pendingStyle.label });
+      }
       return;
     }
     case "openImage": {
@@ -768,6 +1051,7 @@ async function handleMessage(ctx, panel, raw) {
     case "goHome": {
       stopWatching(panel.id);
       livePanelDocuments.delete(panel.id);
+      await forgetLastPath(ctx, panel);
       return;
     }
     case "requestRecentDocuments": {
@@ -793,6 +1077,10 @@ async function handleMessage(ctx, panel, raw) {
       await startRewriteSession(ctx, panel, message);
       return;
     }
+    case "requestStyleSession": {
+      await startStyleSession(ctx, panel, message);
+      return;
+    }
     case "saveMarkdown": {
       const sourcePath = String(message.path ?? "").trim();
       if (!path3.isAbsolute(sourcePath)) return;
@@ -806,6 +1094,14 @@ async function handleMessage(ctx, panel, raw) {
       }
       return;
     }
+    case "saveWritingPreferences": {
+      try {
+        await writeWritingPreferences(ctx, message.preferences);
+      } catch (error) {
+        ctx.logger.warn(`Could not save writing preferences: ${String(error)}`);
+      }
+      return;
+    }
     case "saveDraft": {
       const sourcePath = String(message.path ?? "").trim();
       if (!path3.isAbsolute(sourcePath)) return;
@@ -859,6 +1155,7 @@ async function handleMessage(ctx, panel, raw) {
         const current = await readFile2(sourcePath, "utf8");
         const appliedMarkdown = preserveTextEnvelope(current, markdown);
         await writeFile2(sourcePath, appliedMarkdown, "utf8");
+        await publishFileUpdate(ctx, sourcePath);
         await rememberRecentPath(ctx, sourcePath, panel);
         await panel.postMessage({ type: "applied", path: sourcePath, title: documentTitle(appliedMarkdown, sourcePath) });
       } catch (error) {
@@ -907,6 +1204,8 @@ async function handleMessage(ctx, panel, raw) {
       }
       try {
         const slots = await writeStyleSlot(ctx, slot, { css, label: String(message.label ?? "").trim() || "\u81EA\u5B9A\u4E49\u98CE\u683C" });
+        const sourcePath = String(message.path ?? "").trim();
+        if (sourcePath) await clearPendingStyle(ctx, sourcePath);
         await panel.postMessage({ type: "styleSlots", styleSlots: slots, savedSlot: slot });
       } catch (error) {
         await panel.postMessage({ type: "error", message: `Could not save style slot: ${error instanceof Error ? error.message : String(error)}` });
@@ -973,6 +1272,7 @@ function activate(ctx) {
     }
   }));
   ctx.subscriptions.push(ctx.ui.onDidOpenPanel((panel) => {
+    openPanels.set(panel.id, panel);
     if (panel.visible) lastPanel = panel;
     ctx.subscriptions.push(panel.onDidReceiveMessage((message) => {
       handleMessage(ctx, panel, message).catch((error) => {
@@ -985,6 +1285,7 @@ function activate(ctx) {
     }));
     ctx.subscriptions.push(panel.onDidDispose(() => {
       stopWatching(panel.id);
+      openPanels.delete(panel.id);
       livePanelDocuments.delete(panel.id);
       flushPendingDraftWrite(ctx, panel.id);
       if (lastPanel === panel) lastPanel = void 0;
@@ -999,12 +1300,12 @@ 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 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).`,
+  set_style \u2014 apply an AI-designed custom CSS layout to the currently open Markdown Editor preview (requires css). Apply it right away, without asking the user which reusable slot to use first \u2014 omit \`slot\` and it only updates the live preview; the panel itself then shows a lightweight one-tap prompt so the user decides whether to save it into a reusable custom-style slot, no chat back-and-forth needed. Only pass \`slot\` when the user already told you which of the 3 slots (1/2/3) to save into. 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." },
+        path: { type: "string", description: "Absolute path to the Markdown file. Required for open, create, and apply. For create, the file must not already exist. Recommended (though optional) for set_style: passing it lets Markdown Editor find the right panel for this document even if it is not the most recently focused one \u2014 e.g. the user switched away while an App View design Session was still working. Without it, set_style falls back to whichever panel was last focused." },
         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",
@@ -1021,7 +1322,7 @@ action:
         },
         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." }
+        slot: { type: "number", enum: [1, 2, 3], description: "Optional for set_style. Omit it to just apply the design to the live preview \u2014 the panel will offer the user a one-tap way to save it afterward. Only pass this when the user already picked which of the 3 reusable custom style slots (1, 2, or 3) to overwrite." }
       },
       required: ["action"]
     },
@@ -1076,6 +1377,7 @@ action:
             const applied = applyEditSpecs(current, edits);
             if (!applied.ok) return result(applied.error, true);
             await writeFile2(sourcePath, applied.content, "utf8");
+            await publishFileUpdate(ctx, sourcePath);
             await rememberRecentPath(ctx, sourcePath);
             return result(`Applied ${edits.length} targeted edit${edits.length > 1 ? "s" : ""} to ${path3.basename(sourcePath)}.`);
           } catch (error) {
@@ -1087,6 +1389,7 @@ action:
         try {
           const current = await readFile2(sourcePath, "utf8");
           await writeFile2(sourcePath, preserveTextEnvelope(current, markdown), "utf8");
+          await publishFileUpdate(ctx, sourcePath);
           await rememberRecentPath(ctx, sourcePath);
           return result(`Applied reviewed Markdown to ${path3.basename(sourcePath)}.`);
         } catch (error) {
@@ -1096,16 +1399,32 @@ action:
       if (action === "set_style") {
         const css = String(input.css ?? "").trim();
         if (!css) return result("`set_style` requires non-empty `css`.", true);
-        if (!lastPanel) return result("No Markdown Editor panel is open. Ask the user to open a document first.", true);
+        const pathHint = String(input.path ?? "").trim();
+        const targets = pathHint ? findPanelsForPath(pathHint) : [];
+        const panel = targets[0] ?? lastPanel;
+        if (!panel && !pathHint) return result("No Markdown Editor panel is open. Ask the user to open a document first.", true);
         try {
           const label = String(input.label ?? "") || "AI style";
+          const hasSlot = input.slot !== void 0 && input.slot !== null && String(input.slot).trim() !== "";
+          if (!hasSlot) {
+            if (pathHint) await rememberPendingStyle(ctx, pathHint, { css, label });
+            if (panel) {
+              await panel.postMessage({ type: "customStyleSet", css, label });
+              return result("Custom style applied to the open Markdown Editor preview. It is not saved to a reusable slot yet \u2014 the panel now shows a one-tap prompt for the user to save it themselves; do not ask which slot in chat unless the user asks you to save it directly.");
+            }
+            return result("No Markdown Editor panel is currently open for this document, so the style was saved for later \u2014 it will apply automatically (with the same one-tap save prompt) the next time the user opens this file in Markdown Editor.");
+          }
           const slot = Number(input.slot);
           if (!Number.isInteger(slot) || slot < 1 || slot > STYLE_SLOT_COUNT) {
-            return result("Ask the user which reusable custom style slot (1, 2, or 3) to overwrite, then call `set_style` again with that `slot`.", true);
+            return result("`slot` must be 1, 2, or 3 when provided.", true);
           }
           const slots = await writeStyleSlot(ctx, slot - 1, { css, label });
-          await lastPanel.postMessage({ type: "customStyleSet", css, label, styleSlots: slots, savedSlot: slot - 1 });
-          return result(`Custom style saved to slot ${slot} and applied to the open Markdown Editor panel.`);
+          if (pathHint) await clearPendingStyle(ctx, pathHint);
+          if (panel) {
+            await panel.postMessage({ type: "customStyleSet", css, label, styleSlots: slots, savedSlot: slot - 1 });
+            return result(`Custom style saved to slot ${slot} and applied to the open Markdown Editor panel.`);
+          }
+          return result(`Custom style saved to slot ${slot}. No Markdown Editor panel is currently open for this document \u2014 it will apply automatically the next time the user opens this file.`);
         } catch (error) {
           return result(`Could not apply custom style: ${error instanceof Error ? error.message : String(error)}`, true);
         }