pi-auto-save-to-markdown 0.8.0 → 0.8.2

package/README.md

@@ -28,6 +28,10 @@ pi install npm:pi-auto-save-to-markdown
 Automatic: after every settled agent turn (`agent_settled`), the current
 conversation branch is written to `<cwd>/<folder>/<title>-<key>-<time>.md`.
 
+Sessions Pi does not persist (in-memory, `--no-session` — including the
+ephemeral auxiliary agents host clients spawn next to the real conversation,
+such as Claudian's title generation) are skipped by every automatic save; only
+the explicit `/save-conversation` command archives such a session on demand.
 Manual: run `/save-conversation` to save the current branch immediately and
 report the file path.
 
@@ -92,7 +96,7 @@ changes never touch the filename, and manually renamed files are left alone.
 ---
 title: "Fix login redirect loop"
 agent: "pi"
-format_version: "1.4"
+format_version: "1.5"
 session_id: "d0a4f541-976d-4d1b-8e1c-30a1f2b3c4d5"
 session_key: "c2088d77"
 branch_last_entry_id: "019be3a2-1f4d-7c8a-9b01-d23e45f6a7b8"
@@ -119,7 +123,7 @@ User <span style="font-size: 0.5em; color: var(--text-faint);">2026-08-29 13:05:
 The login page redirects in a loop after the auth refactor...
 
 > [!quote]- Editor Selection
-> **path**: [[src/auth/middleware.ts|middleware.ts]] · **lines**: `14-22`
+> [[src/auth/middleware.ts|middleware.ts]] · **lines**: `14-22`
 >
 > export function middleware(request) { … }
 
@@ -158,14 +162,21 @@ editor's active selection, attached or referenced notes, loaded skills — are
 re-rendered from their raw XML (which Obsidian cannot render and would show
 as literal angle-bracket text) into generic callouts. No block is parsed
 individually: the title is the tag name in words (`editor_selection` →
-Editor Selection), attribute pairs open the body as `**name**: value` lines
-(`path`/`location` values shaped like vault-relative note paths become
-Obsidian wikilinks), and the content follows, quoted in a collapsed callout.
-User-provided blocks (selections, note attachments) stay visible;
-agent-side traces (skills) render as a one-line marker with the content
-dropped. Unknown markup is left verbatim, so XML pasted as content is never
-mangled — and the fallback filename slug derives from the typed message
-with every known block stripped.
+Editor Selection), and the body opens with vault-shaped `path`/`location`
+values as bare Obsidian wikilinks (the aliased filename speaks for itself —
+no `path:` label), followed by the remaining attributes as
+`**name**: value` items, then the content. Every callout is preset-collapsed
+— user-provided blocks (selections, note attachments) as `> [!quote]-`, even
+when they carry only attributes (the client emits note references as
+self-closing tags carrying just a path), agent-side skill traces as a
+`> [!note]- Skill · <name>` marker (the loaded skill's name rides the title,
+so the collapsed marker still says which skill; the location follows in the
+body, the content is dropped) — and consecutive blocks of
+the same tag (nothing but whitespace between them) merge into one callout,
+so a run of note references collapses into a single list. Unknown markup is
+left verbatim, so XML pasted as content is never mangled — and the fallback
+filename slug derives from the typed message with every known block
+stripped.
 
 Each message block opens with a setext level-1 info header (`User`,
 `Assistant`) underlined with `===` — one level above the `##` headings AI

package/README.zh.md

@@ -21,6 +21,10 @@ pi install npm:pi-auto-save-to-markdown
 
 自动：每个 agent 轮次完全结束（`agent_settled`，含自动重试与压缩全部完成）后，当前对话分支写入 `<cwd>/<文件夹>/<标题>-<key>-<时间>.md`。
 
+Pi 未持久化的会话（内存态、`--no-session`——包括宿主客户端在真实对话旁派生的临时辅助
+agent，例如 Claudian 的标题生成）会被所有自动保存路径跳过；只有显式的
+`/save-conversation` 命令才会按需归档此类会话。
+
 手动：运行 `/save-conversation` 立即保存当前分支并显示文件路径。
 
 批量：运行 `/save-conversation-all` 保存**当前项目的全部 session**——即项目的
@@ -66,7 +70,7 @@ PI_SAVE_CONVERSATION_DIR=notes/ai pi
 ---
 title: "修复登录重定向死循环"
 agent: "pi"
-format_version: "1.4"
+format_version: "1.5"
 session_id: "d0a4f541-976d-4d1b-8e1c-30a1f2b3c4d5"
 session_key: "c2088d77"
 branch_last_entry_id: "019be3a2-1f4d-7c8a-9b01-d23e45f6a7b8"
@@ -93,7 +97,7 @@ User <span style="font-size: 0.5em; color: var(--text-faint);">2026-08-29 13:05:
 auth 重构之后登录页一直重定向死循环……
 
 > [!quote]- Editor Selection
-> **path**: [[src/auth/middleware.ts|middleware.ts]] · **lines**: `14-22`
+> [[src/auth/middleware.ts|middleware.ts]] · **lines**: `14-22`
 >
 > export function middleware(request) { … }
 
@@ -128,12 +132,17 @@ Markdown 解析。
 客户端或 agent 注入到用户消息中的提示块——编辑器当前选区、附加或引用的
 笔记、加载的 skill——会从原始 XML（Obsidian 无法渲染，只会显示成裸露的
 尖括号文本）重新渲染为通用 callout。不做任何逐块解析：标题取标记名的分词
-（`editor_selection` → Editor Selection），属性对以 `**属性**: 值` 行开头
-（形似 vault 相对笔记路径的 `path`/`location` 值会转为 Obsidian wikilink），
-随后是引用内容，折叠在 callout 中。用户提供的块（选区、笔记附件）保持
-可见；agent 侧痕迹（skill）渲染为单行标记，内容不再展示。未知标记原样
-保留，用户粘贴的 XML 内容绝不会被误改；回退文件名 slug 也从剥离全部
-已知块后的纯键入文本推导。
+（`editor_selection` → Editor Selection），正文以形似 vault 相对笔记路径的
+`path`/`location` 值开头——直接渲染为不带标签的 Obsidian wikilink（别名
+文件名自解释，`path:` 标签反而冗余），其余属性以 `**属性**: 值` 跟随，
+最后是引用内容。所有 callout 一律预设折叠——用户提供的块（选区、笔记附件）
+为 `> [!quote]-`（仅有属性的自闭合笔记引用同样折叠），agent 侧痕迹（skill）
+为 `> [!note]- Skill · <名称>` 标记（加载的 skill 名称直接进标题，折叠状态
+也能看到是哪个 skill；location 跟在正文，内容丢弃）；连续的同标签块（中间
+只有空白）合并进同一个 callout，一串笔记引用因此收拢为一份列表（skill 标记
+不合并：各自标注各自的 skill）。未知标记原样保留，用户粘贴的
+XML 内容绝不会被误改；回退文件名 slug 也从剥离全部已知块后的纯键入文本
+推导。
 
 每个消息块以 setext 一级信息头（`User`、`Assistant`，下一行以 `===` 下划）
 开头——高于 AI 内容常见的 `##` 二级标题，解析时也能与内容中的 `#` 一级标题

package/index.ts

@@ -9,6 +9,15 @@
  * - Trigger: `agent_settled` — fires once per user prompt, after the turn is
  *   fully done (including automatic retries and compaction), so each save
  *   captures a settled state of the conversation.
+ * - Skip rule: every automatic path (the `agent_settled` save and the batch
+ *   command's live save) skips sessions Pi does not persist — no session
+ *   file, i.e. an in-memory SessionManager (`--no-session`): those are
+ *   ephemeral auxiliary agents host clients spawn next to the real
+ *   conversation (Claudian's title generation, instruction refinement,
+ *   inline edits) or one-shot `pi --no-session` runs, not project
+ *   conversations, and archiving them would mint junk "User's request …"
+ *   files. The manual /save-conversation command still saves such a session
+ *   on explicit demand; the batch never sees them (no jsonl on disk).
  * - Location: a subfolder of the session's working directory (`ctx.cwd`, the
  *   directory the session was started in), defaulting to `ai-conversations`.
  *   Override with the PI_SAVE_CONVERSATION_DIR environment variable; set it to
@@ -61,12 +70,21 @@
  *   Obsidian cannot render (unknown tags are not HTML; CDATA is XML), so
  *   every block in a known vocabulary is re-rendered generically (see
  *   markdown.ts) — no per-tag formatting: the callout title is the tag name
- *   in words, attribute pairs open the body as "**name**: value" lines
- *   (path/location values shaped like vault-relative note paths become
- *   wikilinks), and the content follows (the client's `]]>` split-escaping
- *   reversed). User-provided blocks (selections, attachments) quote their
- *   content in a collapsed `> [!quote]`; agent-side traces (skills) render
- *   as a one-line `> [!note]` marker with the content dropped. Title
+ *   in words, the body opens with vault-shaped path/location values as
+ *   bare wikilinks (the aliased filename is self-explanatory — a `path:`
+ *   label is noise) followed by the remaining attributes as
+ *   "**name**: value" lines, then the content (the client's `]]>`
+ *   split-escaping reversed). Every callout is preset-collapsed: visible
+ *   blocks (selections, note references, attachments) as `> [!quote]-`,
+ *   whether they carry content or only attributes (the client emits note
+ *   references as self-closing tags whose whole payload is a path
+ *   attribute), agent-side traces (skills) as a `> [!note]- Skill · <name>`
+ *   marker — the loaded skill's name rides the title so the collapsed
+ *   marker still says which skill, the location follows in the body, the
+ *   content is dropped — and consecutive visible same-tag blocks (nothing
+ *   but whitespace between them) merge into one callout, so a run of note
+ *   references collapses into a single list (skill markers never merge:
+ *   each names its own skill). Title
  *   derivation strips every known block — the typed message is the title.
  *   Unknown markup is left verbatim so XML pasted as content is never
  *   mangled.
@@ -216,7 +234,7 @@ const SAVE_STATE_SCHEMA = "1.2";
  * the frontmatter and the document heading); additive frontmatter fields do
  * NOT bump it — they are invisible to any within-major parser.
  */
-const FORMAT_VERSION = "1.4";
+const FORMAT_VERSION = "1.5";
 
 /**
  * Package version of this extension, read best-effort from the adjacent
@@ -1916,6 +1934,15 @@ export default function (pi: ExtensionAPI) {
 
   // 1. Automatic: save after every settled agent turn.
   pi.on("agent_settled", async (_event: AgentSettledEvent, ctx: ExtensionContext) => {
+    // Non-persisted sessions (in-memory, `--no-session`) are ephemeral
+    // auxiliary agents — see the skip rule in the header. The manual
+    // /save-conversation command below is the explicit-demand escape hatch.
+    if (!ctx.sessionManager.getSessionFile()) {
+      debug(
+        "agent_settled — session has no session file (in-memory / --no-session); skipping auto-save",
+      );
+      return;
+    }
     debug("agent_settled — saving conversation");
     try {
       const live = liveContext(ctx);
@@ -1996,28 +2023,36 @@ export default function (pi: ExtensionAPI) {
 
     // The live session first, through the normal path: its in-memory tree may
     // be fresher than disk, and its state entry goes through pi.appendEntry.
-    try {
-      const r = await runSave(live);
-      count(r);
-      if (ctx.hasUI) {
-        const target = r.file ? relativeForUser(live, r.file) : "";
-        ctx.ui.notify(`${NOTIFY_TAG} ${r.message}${target ? ` → ${target}` : ""}`, "info");
-        if (r.recovered && r.file) {
-          ctx.ui.notify(`${NOTIFY_TAG} ${r.recovered} → ${target}`, "warning");
+    // A non-persisted current session (in-memory / --no-session) is skipped —
+    // see the skip rule in the header.
+    if (!ctx.sessionManager.getSessionFile()) {
+      debug(
+        "/" + COMMAND_ALL + " — current session not persisted (in-memory / --no-session); skipped",
+      );
+    } else {
+      try {
+        const r = await runSave(live);
+        count(r);
+        if (ctx.hasUI) {
+          const target = r.file ? relativeForUser(live, r.file) : "";
+          ctx.ui.notify(`${NOTIFY_TAG} ${r.message}${target ? ` → ${target}` : ""}`, "info");
+          if (r.recovered && r.file) {
+            ctx.ui.notify(`${NOTIFY_TAG} ${r.recovered} → ${target}`, "warning");
+          }
+          if (r.switchedFrom && r.file) {
+            ctx.ui.notify(
+              `${NOTIFY_TAG} branch changed — new branch file ${target}; the earlier branch file ${r.switchedFrom} is kept`,
+              "info",
+            );
+          }
         }
-        if (r.switchedFrom && r.file) {
-          ctx.ui.notify(
-            `${NOTIFY_TAG} branch changed — new branch file ${target}; the earlier branch file ${r.switchedFrom} is kept`,
-            "info",
-          );
+      } catch (e) {
+        failed.push("<current session>");
+        debug("/" + COMMAND_ALL + " live save failed:", String(e));
+        if (ctx.hasUI) {
+          ctx.ui.notify(`${NOTIFY_TAG} save failed: ${String(e)}`, "error");
         }
       }
-    } catch (e) {
-      failed.push("<current session>");
-      debug("/" + COMMAND_ALL + " live save failed:", String(e));
-      if (ctx.hasUI) {
-        ctx.ui.notify(`${NOTIFY_TAG} save failed: ${String(e)}`, "error");
-      }
     }
 
     // The project's sessions directory — every session jsonl lives there.

package/markdown.ts

@@ -54,8 +54,11 @@ export function callout(type: string, title: string, body: string, fold = true):
  *   references (linked_note / linked_content — the client's attachment
  *   mechanism; a typed @-mention stays as plain text in the message, these
  *   are the machine copy).
- * - Hidden: agent-side traces (loaded skills) — rendered as a one-line
- *   marker, content dropped (a skill is re-loadable from its location).
+ * - Hidden: agent-side traces (loaded skills) — rendered as a folded
+ *   `> [!note]- Skill · <name>` marker with the name riding the title
+ *   (which skill was loaded is the marker's whole meaning and must survive
+ *   the collapsed view), the content dropped (a skill is re-loadable from
+ *   its location).
  *
  * Unknown tags are left verbatim: this is both the safety boundary against
  * mangling pasted XML and a soft failure mode for future client tags (they
@@ -151,60 +154,105 @@ function wikilinkOf(path: string): string {
   return base && base !== path ? `[[${path}|${base}]]` : `[[${path}]]`;
 }
 
+/** Whether an attribute renders as a bare wikilink (a vault-shaped path/location). */
+function isWikilinkAttr(p: { name: string; value: string }): boolean {
+  return (p.name === "path" || p.name === "location") && isVaultNotePath(p.value);
+}
+
 /**
- * One attribute value for the callout body: path/location values that look
- * like vault-relative note paths become clickable wikilinks (the archives
- * live in the same vault; outside Obsidian they degrade to readable bracket
- * text, the same degradation callouts already accept); everything else is
- * an inline code span.
+ * Attribute pairs of one injected block as body items: a `path`/`location`
+ * value shaped like a vault-relative note path becomes a BARE wikilink —
+ * no `**name**:` prefix, because the aliased filename is self-explanatory
+ * (the file is user-provided material) and the label only adds noise — and
+ * sorts first, so the reference leads the line; every other attribute stays
+ * a labeled `**name**: value` item in source order.
  */
-function formatAttrValue(name: string, value: string): string {
-  return (name === "path" || name === "location") && isVaultNotePath(value)
-    ? wikilinkOf(value)
-    : inlineCode(value);
+function attrItems(attrs: string): string[] {
+  const pairs = parseAttrs(attrs);
+  return [
+    ...pairs.filter(isWikilinkAttr).map((p) => wikilinkOf(p.value)),
+    ...pairs.filter((p) => !isWikilinkAttr(p)).map((p) => `**${p.name}**: ${inlineCode(p.value)}`),
+  ];
 }
 
 /**
- * One injected block as a callout, fully generic:
- *
- * - title — the tag name in words;
- * - body — attribute pairs as `**name**: value` lines joined by ` · `, then
- *   (after a blank line) the content;
- * - visible blocks quote their content in a folded `> [!quote]-` callout;
- *   blocks without content stay unfolded (nothing to hide behind the fold);
- * - hidden (agent-side) blocks render as an unfolded `> [!note]` marker
- *   line with the content dropped.
+ * Hidden block as its own self-contained marker callout: the `name`
+ * attribute joins the title — WHICH skill was loaded is the marker's whole
+ * meaning, and a collapsed `Skill` alone would say nothing — while the
+ * remaining attributes (the location) form the body and the content is
+ * dropped (a skill is re-loadable from its location). A hidden block with
+ * no attributes at all carries no information and is removed.
+ */
+function hiddenCallout(tag: string, attrs: string): string {
+  const pairs = parseAttrs(attrs);
+  if (pairs.length === 0) return "";
+  const name = pairs.find((p) => p.name === "name")?.value;
+  const body = pairs
+    .filter((p) => p.name !== "name")
+    .map((p) => (isWikilinkAttr(p) ? wikilinkOf(p.value) : `**${p.name}**: ${inlineCode(p.value)}`))
+    .join(" · ");
+  return callout("note", name ? `${tagTitle(tag)} · ${name}` : tagTitle(tag), body);
+}
+
+/**
+ * One VISIBLE injected block's rendered body (no callout wrapper; hidden
+ * blocks render through hiddenCallout): the attribute items, then (after a
+ * blank line) the content.
  *
  * linked_note is the one content concession: its whole payload IS a note
  * reference, so content shaped like a vault note path renders as a wikilink
  * too — the same mechanical shape test, no semantics.
  */
-function renderInjectedBlock(tag: string, attrs: string, content: string): string {
-  const attrLine = parseAttrs(attrs)
-    .map((p) => `**${p.name}**: ${formatAttrValue(p.name, p.value)}`)
-    .join(" · ");
-  const title = tagTitle(tag);
-  if (HIDDEN_TAGS.has(tag)) return callout("note", title, attrLine, false);
+function injectedBlockBody(tag: string, attrs: string, content: string): string {
+  const attrLine = attrItems(attrs).join(" · ");
   const text = content ? unwrapCDATA(content).trim() : "";
   const body = tag === "linked_note" && isVaultNotePath(text) ? wikilinkOf(text) : text;
-  return callout(
-    "quote",
-    title,
-    attrLine ? (body ? `${attrLine}\n\n${body}` : attrLine) : body,
-    Boolean(body),
-  );
+  return attrLine ? (body ? `${attrLine}\n\n${body}` : attrLine) : body;
 }
 
 /**
  * User message text for the saved body: every known injected block renders
- * as a callout; anything else stays verbatim.
+ * as a preset-collapsed callout — visible blocks as `> [!quote]-`, hidden
+ * blocks as a `> [!note]-` marker — and a RUN of visible same-tag blocks
+ * with nothing but whitespace between them merges into ONE callout (a user
+ * attaching five notes saves one Linked Content callout listing five
+ * wikilinks, not five callouts; hidden markers never merge — each names its
+ * own skill). Anything else stays verbatim.
  */
 export function renderUserMessageText(text: string): string {
-  return text.replace(
-    INJECTED_BLOCK_RE,
-    (_s: string, tag: string, attrs: string, content?: string) =>
-      renderInjectedBlock(tag, attrs, content ?? ""),
-  );
+  const re = new RegExp(INJECTED_BLOCK_RE, "g");
+  let out = "";
+  let pos = 0;
+  let runTag: string | null = null;
+  const runBodies: string[] = [];
+  const flushRun = () => {
+    if (runTag === null) return;
+    out += callout("quote", tagTitle(runTag), runBodies.join("\n\n"));
+    runTag = null;
+    runBodies.length = 0;
+  };
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(text)) !== null) {
+    const tag = m[1];
+    const gap = text.slice(pos, m.index);
+    const mergeable = runTag !== null && tag === runTag && gap.trim() === "";
+    if (!mergeable) {
+      // A different tag, real text between the blocks, or a hidden block
+      // (self-contained markers never merge) ends the run; the gap is
+      // emitted only then — inside a run it is whitespace.
+      flushRun();
+      out += gap;
+    }
+    if (HIDDEN_TAGS.has(tag)) {
+      out += hiddenCallout(tag, m[2]);
+    } else {
+      if (runTag === null) runTag = tag;
+      runBodies.push(injectedBlockBody(tag, m[2], m[3] ?? ""));
+    }
+    pos = re.lastIndex;
+  }
+  flushRun();
+  return out + text.slice(pos);
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-auto-save-to-markdown",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "Pi extension that automatically saves each completed conversation turn as a markdown file with YAML frontmatter, one file per session-tree branch.",
   "type": "module",
   "license": "MIT",