pi-vault-mind 0.16.30 → 0.16.32

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog
 
+## 0.16.32 — 2026-08-28
+
+### Changed
+
+- **Concise setup progress.** `pvm setup` now reports one bounded progress line per extension and curated skill while preserving captured installer diagnostics on failure.
+
+### Fixed
+
+- **Vault-isolated main sessions.** `pvm run` disables implicit skill and prompt-template discovery, then explicitly loads only curated and package skills rooted in the vault-local agent directory. Specialist skill availability can no longer select a specialist identity for the interactive main session.
+- **Escaping package paths.** Setup removes local package paths that resolve outside the vault-local agent directory while preserving npm packages and in-runtime custom packages.
+
+## 0.16.31 — 2026-08-28
+
+### Added
+
+- **One-command vault setup.** `pvm setup [vault-path]` installs the complete vault-local extension, task/subagent, NotebookLM, and curated skill profile before merge-safely scaffolding Vault Mind, model-router, and main-agent configuration.
+- **Resource-only repair.** `pvm setup --resources-only [vault-path]` refreshes extensions, tools, and skills without changing vault configuration.
+- **Dependency audit and repair.** `pvm check-deps [--fix] [--strict] [--obsidian] [vault-path]` verifies the host runtime, vault-local extensions, curated skills, and optional content or Obsidian tooling.
+
+### Changed
+
+- **Pi 0.84.3 runtime.** Development and compatibility checks now target `@earendil-works/pi-coding-agent` and `@earendil-works/pi-tui` 0.84.3.
+- **Node.js 22.19 runtime floor.** Package metadata, dependency audits, and setup documentation now match the minimum Node version required by Pi 0.84.3.
+- **Current task and subagent extensions.** New vault setup installs `@juicesharp/rpiv-todo` 2.7.1 and `pi-subagents` 0.58.0, while removing the obsolete `@tintinweb/pi-tasks` package.
+- **Pi Context 2.1.2 integration.** Session-start and turn-end capture now use the current checkpoint and context-event APIs.
+- **Curated package surface.** Published Pi discovery exposes only Vault Mind usage, setup, and specialist content skills; internal release, plugin-development, and test workflows are no longer shipped as runtime skills.
+- **Reproducible package tooling.** The repository now pins pnpm 10.34.5 so Corepack does not select an incompatible pnpm major during clean release builds.
+
+### Fixed
+
+- **Quiet main-agent startup.** Automatic context management initializes without injecting a synthetic `/acm` user message into a new session.
+- **Stable Pi launcher selection.** Setup avoids transient `npx` binaries and consistently provisions the vault-local agent directory with the installed Pi runtime.
+
+### Verification
+
+- Node 24.19.0 with pnpm 10.34.5: dependency install, core build, and package-scoped Biome check completed successfully.
+- Full core test suite: 937/937 passing.
+- Packed `pi-vault-mind-0.16.31.tgz` successfully; the packaged `pvm --help` executable ran and exposed the `run`, `setup`, and `check-deps` commands.
+
 ## 0.16.30 — 2026-08-27
 
 ### Added

package/README.md

@@ -123,37 +123,32 @@ obsidian plugin:install id=obsidian42-brat enable
 # In Obsidian: Settings → BRAT → Beta Plugin List → Add
 ```
 
-### Recommended: kepano/obsidian-skills (pi skills)
+### Curated vault-local skills
 
-Install via the official [`skills` CLI](https://github.com/vercel-labs/skills)
-(pi is a first-class target agent — auto-detected):
+`pvm setup` installs the supported Obsidian and NotebookLM skills into the
+vault-local Pi agent directory:
 
 ```bash
-# Non-interactive: install all 5 globally for pi
-DISABLE_TELEMETRY=1 yes y | npx -y skills add https://github.com/kepano/obsidian-skills \
-  --skill obsidian-markdown --skill obsidian-bases \
-  --skill json-canvas --skill obsidian-cli --skill defuddle \
-  -g -a pi --copy -y
+pvm setup /path/to/your/vault
 ```
 
-This puts them at `~/.pi/agent/skills/<name>/SKILL.md` where pi
-auto-discovers them. The CLI handles agent detection, symlink/copy,
-and security risk confirmations.
+The skills live under
+`<vault>/.vault-mind/.pi/agent/skills/<name>/SKILL.md`. `pvm run` disables
+Pi's implicit global/project skill discovery and explicitly loads only these
+curated skills plus skills provided by packages installed in the same
+vault-local agent directory. Do not install these skills globally for a Vault
+Mind session; global copies defeat vault isolation and can create skill-name
+conflicts.
 
-**Verify they're discoverable:**
+- `obsidian-markdown` — Obsidian-flavored Markdown syntax
+- `obsidian-bases` — valid `.base` database views
+- `json-canvas` — Canvas JSON used by graph sync
+- `obsidian-cli` — Obsidian CLI operation
+- `nlm-skill` — NotebookLM CLI and MCP workflows
 
-```bash
-for s in obsidian-markdown obsidian-bases json-canvas obsidian-cli defuddle; do
-  [ -f ~/.pi/agent/skills/$s/SKILL.md ] && echo "✅ $s" || echo "❌ $s"
-done
-```
-- `obsidian-markdown` — agent learns Obsidian-flavored markdown syntax
-- `obsidian-bases` — agent learns to generate valid `.base` files (database views)
-- `json-canvas` — agent learns Canvas JSON format (used for our graph sync)
-- `obsidian-cli` — agent learns to use the Obsidian CLI
-- `defuddle` — cleaner markdown extraction from web pages
-
-These skills let the **Miner, Broadcaster, and Heavy-Lifter agents** produce valid Obsidian content.
+These skills let the **Miner, Broadcaster, and Heavy-Lifter agents** produce
+valid Obsidian content without changing the identity of the interactive main
+agent.
 
 ### Built-in Obsidian features used
 
@@ -176,7 +171,7 @@ The Broadcaster agent can generate podcasts, study guides, and slide decks from
 
 ### Prerequisites
 
-- **Node.js** 20+ (matches `engines` in `package.json`)
+- **Node.js** 22.19.0+ (matches `engines` in `package.json`)
 - **Embedding Provider** — choose one:
   - `@xenova/transformers` — built-in, no external deps (uses all-MiniLM-L6-v2, offline-capable)
   - `ollama` — requires Ollama running locally with `embeddinggemma` (higher quality)
@@ -190,47 +185,66 @@ The Broadcaster agent can generate podcasts, study guides, and slide decks from
 > bearer token are private to whoever owns it. (A standalone PyPI package for the
 > server may come later.)
 
-### 1. Install with pi
-
-```bash
-pi install npm:pi-vault-mind              # latest
-pi install npm:pi-vault-mind@0.16.30       # pinned release
-pi -e npm:pi-vault-mind                   # try without installing
-```
+### 1. Install and set up the vault-local runtime
 
-`pi install` loads the extension but does not expose its npm executable on your
-shell `PATH`. Install the first-class launcher once when you want the bare
-`pvm` command:
+Install the first-class `pvm` CLI once, then run setup against a vault:
 
 ```bash
 npm install --global pi-vault-mind
+pvm setup /path/to/your/vault
 pvm run /path/to/your/vault
 ```
 
-Or run it without a global installation:
+`pvm setup` is safe to repeat. It installs or updates the required Vault Mind,
+context, model-routing, task, and subagent extensions inside
+`<vault>/.vault-mind/.pi/agent/`; installs the curated `obsidian-cli`,
+`obsidian-markdown`, `obsidian-bases`, and `json-canvas` skills; and
+merge-safely scaffolds Vault Mind, model-router, and main-agent configuration.
+Existing user configuration, collections, model choices, and `system.md` are
+preserved.
+
+Refresh only extensions, tools, and skills without touching vault
+configuration:
 
 ```bash
-npx --yes pi-vault-mind run /path/to/your/vault
+pvm setup --resources-only /path/to/your/vault
 ```
 
-Or from git:
+Audit the isolated runtime without changing it, or repair it in place:
 
 ```bash
-pi install git:git@github.com:kylebrodeur/pi-vault-mind
+pvm check-deps /path/to/your/vault
+pvm check-deps --fix /path/to/your/vault
 ```
 
-### 2. Configure (interactive wizard)
+Add `--strict` to fail when optional tools are missing and `--obsidian` to
+include recommended Obsidian plugin checks.
+
+Run either mode without a global installation:
 
+```bash
+npx --yes pi-vault-mind setup /path/to/your/vault
+npx --yes pi-vault-mind run /path/to/your/vault
 ```
-/vm setup
+
+Installing only the Pi extension remains supported:
+
+```bash
+pi install npm:pi-vault-mind
+pi -e npm:pi-vault-mind
 ```
 
-This configures the current vault's setup surface: vault path, embedding
-provider details, folder layout, and scaffolding.
+### 2. Configure interactively when needed
 
-Or via CLI for scripting/repair:
+Inside Pi, use the wizard to choose or change embedding providers, folder
+layout, and other user-facing settings:
 
-```bash
+```text
+/vm setup
+```
+For a non-interactive repair inside Pi:
+
+```text
 /vm setup --vault /home/you/Obsidian/MyVault --remoteUrl https://your-embedding-service-url.example.com --model embeddinggemma
 ```
 

package/dist/src/commands.js

@@ -259,7 +259,7 @@ const handleInit = async (_args, ctx, pi) => {
         const existing = JSON.parse(fs.readFileSync(cfgDest, "utf-8"));
         existing.extensionCompatibility = existing.extensionCompatibility || {};
         existing.extensionCompatibility["pi-context"] = {
-            tagPatterns: [],
+            checkpointPatterns: [],
             enhanceInjectors: false,
             autoEnableAcm: true,
             indexContextEvents: true,
@@ -314,7 +314,7 @@ const handleValidate = async (_args, ctx, pi) => {
     const contextCfg = getPiContextConfig(cfg);
     const willCapture = hasContext && contextCfg.enabled;
     lines.push("", "🧩 Extension Integrations:", "   • pi-context:");
-    lines.push(`       - Tools installed: ${hasContext ? "✅ Yes (context_tag, context_log, context_checkout)" : "❌ No"}`);
+    lines.push(`       - Tools installed: ${hasContext ? "✅ Yes (context_checkpoint, context_timeline, context_compact)" : "❌ No"}`);
     lines.push(`       - Config enabled: ${contextCfg.enabled ? "✅ Yes" : "❌ No"}`);
     lines.push(`       - Will capture events: ${willCapture ? "✅ Yes — on next turn" : "❌ No"}`);
     if (hasContext && !contextCfg.enabled)
@@ -1122,10 +1122,10 @@ const handleContext = async (args, ctx, pi) => {
                 `  - Config enabled: ${piContextCfg.enabled ? "✅" : "❌"}`,
                 `  - Will capture on next turn: ${willCapture ? "✅ Yes" : "❌ No"}`,
                 "",
-                `Tag Patterns: ${piContextCfg.tagPatterns?.length || 0}`,
-                ...(piContextCfg.tagPatterns?.length
-                    ? piContextCfg.tagPatterns.map((p) => `  • "${p}"`)
-                    : ["  (none — no tag-based lookups)"]),
+                `Checkpoint Patterns: ${piContextCfg.checkpointPatterns?.length || 0}`,
+                ...(piContextCfg.checkpointPatterns?.length
+                    ? piContextCfg.checkpointPatterns.map((p) => `  • "${p}"`)
+                    : ["  (none — no checkpoint-based lookups)"]),
                 "",
                 `Enhance Injectors: ${piContextCfg.enhanceInjectors ? "Yes" : "No"}`,
                 `autoEnableAcm: ${piContextCfg.autoEnableAcm ? "Yes" : "No"}`,
@@ -1163,7 +1163,7 @@ const _toggleContext = (cfgPath, enabled) => {
     const existing = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
     existing.extensionCompatibility = existing.extensionCompatibility || {};
     existing.extensionCompatibility["pi-context"] = {
-        tagPatterns: [],
+        checkpointPatterns: [],
         enhanceInjectors: false,
         autoEnableAcm: true,
         indexContextEvents: true,

package/dist/src/context-capture.d.ts

@@ -1,18 +1,23 @@
 /**
- * Context Capture — Layer 4 auto-trigger pi-context /acm.
+ * Context Capture — Layer 4 pi-context /acm reminder.
+ *
+ * On extension load, reminds the human to run /acm to enable agentic context
+ * management. Does NOT inject /acm as a user or model message; the reminder
+ * is an unobtrusive UI notification only.
  *
- * On extension load, auto-sends /acm to enable agentic context management.
  * Injects context_checkpoint instructions into agent task prompts.
  *
  * Note: context_compact requires CommandCtx (only in main session, not
  * subagent forks). Subagent forks use context_checkpoint and context_timeline.
  */
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 /**
- * Auto-send /acm on extension load to enable agentic context management
- * for the Manager session.
+ * Notify the human to run /acm to enable agentic context management.
+ *
+ * Uses ctx.ui.notify — a transient TUI notification that never enters the
+ * session history and is never delivered to the model.
  */
-export declare function enableACM(pi: ExtensionAPI): void;
+export declare function notifyAcmReminder(ctx: ExtensionContext): void;
 /**
  * Build context_checkpoint instructions to inject into a dispatch task prompt.
  *

package/dist/src/context-capture.js

@@ -1,19 +1,24 @@
 /**
- * Context Capture — Layer 4 auto-trigger pi-context /acm.
+ * Context Capture — Layer 4 pi-context /acm reminder.
+ *
+ * On extension load, reminds the human to run /acm to enable agentic context
+ * management. Does NOT inject /acm as a user or model message; the reminder
+ * is an unobtrusive UI notification only.
  *
- * On extension load, auto-sends /acm to enable agentic context management.
  * Injects context_checkpoint instructions into agent task prompts.
  *
  * Note: context_compact requires CommandCtx (only in main session, not
  * subagent forks). Subagent forks use context_checkpoint and context_timeline.
  */
-// ── ACM auto-trigger ──────────────────────────────────────────────────────────
+// ── ACM reminder notification ─────────────────────────────────────────────────
 /**
- * Auto-send /acm on extension load to enable agentic context management
- * for the Manager session.
+ * Notify the human to run /acm to enable agentic context management.
+ *
+ * Uses ctx.ui.notify — a transient TUI notification that never enters the
+ * session history and is never delivered to the model.
  */
-export function enableACM(pi) {
-    pi.sendUserMessage("/acm", { deliverAs: "followUp" });
+export function notifyAcmReminder(ctx) {
+    ctx.ui.notify("Run /acm to enable agentic context management for this session.", "info");
 }
 // ── Checkpoint instructions for agent task prompts ────────────────────────────
 /**

package/dist/src/events.d.ts

@@ -1,13 +1,13 @@
 import type { BeforeAgentStartEvent, ExtensionAPI, ExtensionContext, TurnEndEvent } from "@earendil-works/pi-coding-agent";
 /**
- * Handles before_agent_start to inject collection entries and pi-context tag matches
+ * Handles before_agent_start to inject collection entries and pi-context checkpoint matches
  * into the system prompt.
  */
 export declare const handleBeforeAgentStart: (pi: ExtensionAPI, event: BeforeAgentStartEvent, ctx: ExtensionContext) => Promise<{
     systemPrompt?: string;
 } | undefined>;
 /**
- * Handles turn_end to capture pi-context events and append them to the
+ * Handles turn_end to capture pi-context checkpoints and summaries in the
  * context_events collection.
  */
 export declare const handleTurnEnd: (pi: ExtensionAPI, _event: TurnEndEvent, ctx: ExtensionContext) => Promise<void>;

package/dist/src/events.js

@@ -2,7 +2,7 @@ import * as fs from "node:fs";
 import { getActiveCollection } from "./state.js";
 import { ensureDir, getPiContextConfig, hasPiContextTools, loadConfig } from "./utils.js";
 /**
- * Handles before_agent_start to inject collection entries and pi-context tag matches
+ * Handles before_agent_start to inject collection entries and pi-context checkpoint matches
  * into the system prompt.
  */
 export const handleBeforeAgentStart = async (pi, event, ctx) => {
@@ -46,81 +46,71 @@ export const handleBeforeAgentStart = async (pi, event, ctx) => {
             .replace(/\{\{entries\}\}/g, entriesText || "(none)")
             .replace(/\{\{artifact\}\}/g, artifactText || "(none)");
     }
-    if (additions) {
-        return { systemPrompt: event.systemPrompt + additions };
-    }
-    // 2. pi-context integration: auto-ACM and tag-based triggers
+    // 2. pi-context integration: checkpoint-based triggers via sessionManager labels.
+    // context_checkpoint calls pi.setLabel(targetId, name); we read those labels directly
+    // from ctx.sessionManager — no cross-extension tool execution required.
     const piContextCfg = getPiContextConfig(cfg);
-    if (!piContextCfg.enabled || !hasPiContextTools(pi)) {
-        // pi-context is disabled or unavailable — skip integration silently.
-    }
-    else {
-        // ACM auto-enable is handled exactly once at session_start (see index.ts)
-        // via pi.sendUserMessage("/acm"), gated on isVaultMindReady. A hidden
-        // sendMessage({ customType: "pi-context", content: "/acm" }) here does NOT
-        // enable compaction — pi-context only enables ACM from its own `/acm`
-        // command handler (which captures the command context), so this dead path
-        // was removed.
-        if (piContextCfg.tagPatterns && piContextCfg.tagPatterns.length > 0) {
-            try {
-                const allTools = pi.getAllTools();
-                const contextLogTool = allTools.find((t) => t.name === "context_log");
-                if (contextLogTool) {
-                    const logs = await contextLogTool.execute?.(null, { limit: 100, verbose: true }, null, null, ctx);
-                    if (logs?.content?.[0]?.text) {
-                        const logText = logs.content[0].text;
-                        let tagInjections = 0;
-                        for (const pattern of piContextCfg.tagPatterns) {
-                            const tagRegex = new RegExp(pattern, "i");
-                            const tagMatches = logText.match(/tag:\s*([\w-]+)/gi);
-                            if (tagMatches) {
-                                for (const match of tagMatches) {
-                                    const tagValue = match.replace(/tag:\s*/i, "");
-                                    if (tagRegex.test(tagValue)) {
-                                        for (const [collectionName, collectionDef] of Object.entries(cfg.collections)) {
-                                            if (collectionDef.schema.includes("tag") &&
-                                                fs.existsSync(collectionDef.path)) {
-                                                const lines = fs
-                                                    .readFileSync(collectionDef.path, "utf-8")
-                                                    .split("\n")
-                                                    .filter(Boolean);
-                                                const hits = lines
-                                                    .map((l) => {
-                                                    try {
-                                                        return JSON.parse(l);
-                                                    }
-                                                    catch {
-                                                        return null;
-                                                    }
-                                                })
-                                                    .filter((e) => e && e.tag === tagValue);
-                                                if (hits.length > 0) {
-                                                    additions += `\n\n=== pi-context tag [${tagValue}] matched ${collectionName} ===\n${JSON.stringify(hits, null, 2)}\n`;
-                                                    tagInjections += hits.length;
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                            }
+    if (piContextCfg.enabled &&
+        hasPiContextTools(pi) &&
+        piContextCfg.checkpointPatterns &&
+        piContextCfg.checkpointPatterns.length > 0) {
+        try {
+            const sm = ctx.sessionManager;
+            // Inspect only the current branch (root-to-leaf path) for labels.
+            // getBranch() excludes entries on abandoned forks; getEntries() would span
+            // all forks and wrongly trigger injection for off-branch checkpoints.
+            const branchEntries = sm.getBranch();
+            // Collect all distinct labels present on the active branch
+            const checkpointNames = new Set();
+            for (const entry of branchEntries) {
+                const label = sm.getLabel(entry.id);
+                if (label)
+                    checkpointNames.add(label);
+            }
+            let checkpointInjections = 0;
+            for (const pattern of piContextCfg.checkpointPatterns) {
+                const checkpointRegex = new RegExp(pattern, "i");
+                for (const checkpointName of checkpointNames) {
+                    if (!checkpointRegex.test(checkpointName))
+                        continue;
+                    for (const [collectionName, collectionDef] of Object.entries(cfg.collections)) {
+                        if (!collectionDef.schema.includes("tag") || !fs.existsSync(collectionDef.path)) {
+                            continue;
                         }
-                        if (tagInjections > 0) {
-                            ctx.ui?.notify?.(`pi-context: injected ${tagInjections} entries from matching tags`, "info");
+                        const hits = fs
+                            .readFileSync(collectionDef.path, "utf-8")
+                            .split("\n")
+                            .filter(Boolean)
+                            .map((line) => {
+                            try {
+                                return JSON.parse(line);
+                            }
+                            catch {
+                                return null;
+                            }
+                        })
+                            .filter((e) => e?.tag === checkpointName);
+                        if (hits.length > 0) {
+                            additions += `\n\n=== pi-context checkpoint [${checkpointName}] matched ${collectionName} ===\n${JSON.stringify(hits, null, 2)}\n`;
+                            checkpointInjections += hits.length;
                         }
                     }
                 }
             }
-            catch (e) {
-                console.warn("[pi-vault-mind] pi-context tag integration error:", e);
+            if (checkpointInjections > 0) {
+                ctx.ui?.notify?.(`pi-context: injected ${checkpointInjections} entries from matching checkpoints`, "info");
             }
         }
+        catch (error) {
+            console.warn("[pi-vault-mind] pi-context checkpoint integration error:", error);
+        }
     }
     if (additions) {
         return { systemPrompt: event.systemPrompt + additions };
     }
 };
 /**
- * Handles turn_end to capture pi-context events and append them to the
+ * Handles turn_end to capture pi-context checkpoints and summaries in the
  * context_events collection.
  */
 export const handleTurnEnd = async (pi, _event, ctx) => {
@@ -131,96 +121,83 @@ export const handleTurnEnd = async (pi, _event, ctx) => {
         return;
     }
     try {
-        if (!hasPiContextTools(pi)) {
-            return;
-        }
-        const allTools = pi.getAllTools();
-        const contextLogTool = allTools.find((t) => t.name === "context_log");
-        const contextCheckoutTool = allTools.find((t) => t.name === "context_checkout");
-        if (!contextLogTool || !contextCheckoutTool) {
-            return;
-        }
         const collectionDef = cfg.collections.context_events;
         if (!collectionDef) {
             console.warn("[pi-vault-mind] 'context_events' collection not defined in config. Cannot index pi-context events.");
             return;
         }
-        // Get current session history
-        const logs = await contextLogTool.execute?.(null, { limit: 100, verbose: true }, null, null, ctx);
-        if (!logs?.content?.[0]?.text) {
-            return;
-        }
-        const logText = logs.content[0].text;
+        const sm = ctx.sessionManager;
+        // Inspect the most recent 100 entries (100-entry bound matches prior behavior)
+        const recentEntries = sm.getEntries().slice(-100);
         const capturedEvents = [];
-        const lines = logText.split("\n");
-        for (const line of lines) {
-            const timestamp = new Date().toISOString();
-            let event = null;
-            const tagMatch = line.match(/^\*?\s*([0-9a-f]+)\s+\(tag:\s*([\w-]+).*\)\s*\[(AI|USER|BASH|TOOL|SUMMARY)\]\s*(.*)/i);
-            if (tagMatch) {
-                event = {
-                    id: `tag-${tagMatch[1]}-${tagMatch[2]}`,
-                    type: "tag_created",
-                    session_entry_id: tagMatch[1],
-                    content: `Tag '${tagMatch[2]}' created at ${tagMatch[1]}`,
+        const timestamp = new Date().toISOString();
+        for (const entry of recentEntries) {
+            // Checkpoint: pi-context stores checkpoints as Pi labels on session entries.
+            // context_checkpoint calls pi.setLabel(entryId, name); we read via sm.getLabel.
+            const label = sm.getLabel(entry.id);
+            if (label) {
+                capturedEvents.push({
+                    id: `checkpoint-${entry.id}-${label}`,
+                    type: "checkpoint_created",
+                    session_entry_id: entry.id,
+                    content: `Checkpoint '${label}' created at ${entry.id}`,
                     timestamp,
-                    tags: [tagMatch[2], "pi-context"],
+                    tags: [label, "pi-context", "checkpoint"],
                     details: {
-                        tag_name: tagMatch[2],
-                        entry_id: tagMatch[1],
-                        entry_type: tagMatch[3],
-                        entry_summary: tagMatch[4].trim(),
+                        checkpoint_name: label,
+                        entry_id: entry.id,
+                        entry_type: entry.type.toUpperCase(),
                     },
-                };
+                });
             }
-            const summaryMatch = line.match(/^\*?\s*([0-9a-f]+)\s+\((ROOT|HEAD)?.*summary from (.*)\)\s*\[SUMMARY\]\s*(.*)/i);
-            if (summaryMatch) {
-                event = {
-                    id: `checkout-summary-${summaryMatch[1]}`,
-                    type: "checkout_summary",
-                    session_entry_id: summaryMatch[1],
-                    content: `Checkout summary from ${summaryMatch[3]}: ${summaryMatch[4].trim()}`,
+            // Summary: compaction and branch_summary entries carry a real `.summary` string.
+            if ((entry.type === "compaction" || entry.type === "branch_summary") &&
+                "summary" in entry &&
+                typeof entry.summary === "string") {
+                capturedEvents.push({
+                    id: `context-summary-${entry.id}`,
+                    type: "context_summary",
+                    session_entry_id: entry.id,
+                    content: entry.summary,
                     timestamp,
-                    tags: ["pi-context", "checkout", "summary"],
+                    tags: ["pi-context", "summary"],
                     details: {
-                        origin: summaryMatch[3],
-                        summary_message: summaryMatch[4].trim(),
-                        entry_id: summaryMatch[1],
+                        entry_id: entry.id,
+                        summary_message: entry.summary,
                     },
-                };
-            }
-            if (event) {
-                capturedEvents.push(event);
+                });
             }
         }
-        // Append events directly to the context_events collection
-        if (collectionDef) {
-            ensureDir(collectionDef.path);
-            const existingIds = new Set();
-            if (collectionDef.dedupField && fs.existsSync(collectionDef.path)) {
-                const data = fs.readFileSync(collectionDef.path, "utf-8");
-                for (const line of data.split("\n").filter(Boolean)) {
-                    try {
-                        existingIds.add(JSON.parse(line)[collectionDef.dedupField]);
-                    }
-                    catch {
-                        /* ignore malformed */
-                    }
+        // Append events to the context_events collection with dedup
+        ensureDir(collectionDef.path);
+        const existingIds = new Set();
+        if (collectionDef.dedupField && fs.existsSync(collectionDef.path)) {
+            const data = fs.readFileSync(collectionDef.path, "utf-8");
+            for (const line of data.split("\n").filter(Boolean)) {
+                try {
+                    existingIds.add(JSON.parse(line)[collectionDef.dedupField]);
+                }
+                catch {
+                    /* ignore malformed */
                 }
             }
-            let appended = 0;
-            for (const event of capturedEvents) {
-                if (collectionDef.dedupField && existingIds.has(event[collectionDef.dedupField])) {
+        }
+        let appended = 0;
+        for (const capturedEvent of capturedEvents) {
+            if (collectionDef.dedupField) {
+                const dedupVal = capturedEvent[collectionDef.dedupField];
+                if (existingIds.has(dedupVal))
                     continue;
-                }
-                fs.appendFileSync(collectionDef.path, `${JSON.stringify(event)}\n`);
-                if (collectionDef.dedupField)
-                    existingIds.add(event[collectionDef.dedupField]);
-                appended++;
+                fs.appendFileSync(collectionDef.path, `${JSON.stringify(capturedEvent)}\n`);
+                existingIds.add(dedupVal);
             }
-            if (appended > 0 && ctx.ui?.notify) {
-                ctx.ui.notify(`pi-context: captured ${appended} event(s) → ${collectionDef.path}`, "info");
+            else {
+                fs.appendFileSync(collectionDef.path, `${JSON.stringify(capturedEvent)}\n`);
             }
+            appended++;
+        }
+        if (appended > 0 && ctx.ui?.notify) {
+            ctx.ui.notify(`pi-context: captured ${appended} event(s) → ${collectionDef.path}`, "info");
         }
     }
     catch (e) {

package/dist/src/extension-packages.d.ts

@@ -1,9 +1,9 @@
 /**
- * Canonical list of pi extensions required/optional for vault-mind.
+ * Canonical extension list for the legacy `/vm setup` and Obsidian setup
+ * surfaces. The standalone `pvm` CLI has a broader package-managed runtime
+ * contract in `runtime/pvm-extensions.json`.
  *
- * This is the SINGLE SOURCE OF TRUTH. Shell scripts and the Obsidian plugin
- * consume generated JSON (see scripts/generate-extension-packages-json.mjs).
- * When adding/removing a package, edit ONLY this file and regenerate.
+ * Generate this surface with scripts/generate-extension-packages-json.mjs.
  */
 export declare const PI_REQUIRED_EXTENSIONS: readonly ["npm:pi-vault-mind", "npm:pi-context", "npm:@kylebrodeur/pi-model-discovery", "npm:@kylebrodeur/pi-model-router"];
 export declare const PI_OPTIONAL_EXTENSIONS: readonly ["npm:pi-1password"];