@zosmaai/pi-llm-wiki 0.6.6 → 0.7.1

package/README.md

@@ -20,6 +20,8 @@ Turn raw sources (URLs, PDFs, markdown, JSON, XML) into a durable, interlinked,
 pi install npm:@zosmaai/pi-llm-wiki
 ```
 
+The extension will proactively suggest creating a wiki on your first session. Alternatively:
+
 ```
 /wiki-init "AI Engineering"
 /wiki-ingest
@@ -47,14 +49,16 @@ The result is a wiki that **compounds** as you capture sources, ask questions, a
 
 | Capability | Description |
 |------------|-------------|
+| 🏠 **Personal fallback** | Always-on `~/.llm-wiki/` vault — knowledge compounds across projects even when no project wiki exists |
 | 🔗 **Immutable source capture** | URLs, local files (PDF/md/txt/html/XML/JSON), or pasted text → structured source packets |
 | 🧠 **Automated ingestion** | `wiki_ingest` batch-processes sources into concept, entity, synthesis & analysis pages |
 | 🔍 **Full-text search** | Generated registry with keyword lookup across all pages and sources |
 | 🩺 **Mechanical linting** | Orphans, broken links, duplicate aliases, coverage gaps, stale captures |
 | 📊 **Dashboard** | `wiki_status` — counts, source states, recent activity |
 | 🤖 **Auto-update watch** | `wiki_watch` — schedule periodic discovery + ingest |
-| 🧠 **Auto-recall** | Wiki searched automatically before every turn — relevant pages injected into context |
-| 💾 **Auto-capture** | `wiki_retro` — save atomic insights from completed tasks with one call |
+| 🧠 **Layered recall** | Searches both personal (`~/.llm-wiki/`) and project (`.llm-wiki/`) vaults — personal knowledge follows you everywhere |
+| 📝 **Auto-bootstrap** | Extension suggests creating a wiki when none exists in the current directory |
+| 💾 **Lightweight capture** | `wiki_retro` — save atomic insights as a single markdown file; full 4-layer pipeline also available via `wiki_capture_source` |
 | 🌐 **MCP Server** | Use with Claude Code, Cursor, Windsurf via stdio MCP transport |
 | 📝 **Obsidian-friendly** | Folder-qualified wikilinks, stable source-ID citations, compatible vault |
 | 🛡️ **Guardrails** | Blocks direct edits to raw sources and generated metadata |
@@ -69,7 +73,7 @@ The result is a wiki that **compounds** as you capture sources, ask questions, a
 |------|-------------|
 | `wiki_bootstrap` | Initialize a new wiki vault with config, templates, schema, and metadata |
 | `wiki_capture_source` | Capture a URL, local file, or pasted text into an immutable source packet |
-| `wiki_recall` | 🔄 **Auto-called at turn start** — search wiki for task-relevant pages |
+| `wiki_recall` | Search wiki for task-relevant pages — searches both personal (`~/.llm-wiki/`) and project (`.llm-wiki/`) vaults, deduplicated |
 | `wiki_retro` | Save atomic insights from completed tasks into the wiki |
 | `wiki_ingest` | Process uningested source packets into wiki pages (batch) |
 | `wiki_ensure_page` | Resolve or safely create entity / concept / synthesis / analysis pages |
@@ -96,6 +100,28 @@ The result is a wiki that **compounds** as you capture sources, ask questions, a
 
 ---
 
+## Layered Vault Architecture
+
+Knowledge follows you everywhere. pi-llm-wiki uses a layered vault system:
+
+| Layer | Location | Purpose |
+|-------|----------|---------|
+| 🏠 **Personal** | `~/.llm-wiki/` | Always active. Zero setup. Knowledge compounds across all your sessions — regardless of which project you're in. |
+| 📁 **Project** | `{project}/.llm-wiki/` | Explicit opt-in. Dedicated wiki per project, sharing personal knowledge when relevant. |
+| 🏢 **Company** (future) | git-tracked | Shared wiki across a team. `wiki_publish` promotes personal/project pages to the company wiki. |
+
+**How it works:**
+
+1. `resolveVaultRoot()` checks: cwd → walk up for `.llm-wiki/` → `~/.llm-wiki/`
+2. `wiki_recall` (layered) searches **both** personal and project vaults, merging results with vault labels
+3. Personal results are shown first in recall output, tagged as "📓 personal"
+4. `wiki_retro` writes to whichever vault is active (project takes priority)
+5. Set `WIKI_HOME` env var to override the personal wiki location
+
+This means: you can have a project wiki for team documentation **and** a personal wiki for your own notes, and recall searches both simultaneously.
+
+---
+
 ## Quick Start (Detailed)
 
 ### 1) Create a new wiki
@@ -306,7 +332,13 @@ The bundled `llm-wiki` skill teaches the model to:
 
 ## Architecture
 
-Four layers with clear ownership:
+### Vault Layers
+
+See the [Layered Vault Architecture](#layered-vault-architecture) section above for the personal/project/company layering.
+
+### Four-Layer Page Model
+
+Each wiki vault has four layers with clear ownership:
 
 ```
 .llm-wiki/raw/sources/SRC-*/     # Immutable source packets (extension-owned)

package/docs/architecture.md

@@ -1,6 +1,37 @@
 # Architecture
 
-## Four Layers
+## Layered Vault Architecture
+
+pi-llm-wiki supports multiple vault layers that are searched together:
+
+| Layer | Location | Resolution | Searched by recall |
+|-------|----------|------------|-------------------|
+| **Personal** | `~/.llm-wiki/` | Fallback when no project wiki found | ✅ Always |
+| **Project** | `{project}/.llm-wiki/` | Walk up from cwd | ✅ When present |
+
+### Resolution Order
+
+1. Check current directory for `.llm-wiki/` → use as project wiki
+2. Walk up parent directories looking for `.llm-wiki/` → use as project wiki
+3. Check `WIKI_HOME` env var → use as personal wiki
+4. Fall back to `~/.llm-wiki/` → create if doesn't exist
+
+This means a project wiki is always preferred when you're inside a project that has one, but your personal wiki is always available as the fallback.
+
+### Dual-Vault Recall
+
+`wiki_recall` uses `searchWikiLayered()` which:
+1. Searches the **project vault** (if one exists in cwd)
+2. Searches the **personal vault** (`~/.llm-wiki/` or `WIKI_HOME`)
+3. Deduplicates results by page ID (project takes priority on duplicates)
+4. Tags personal results with "📓 personal" label
+5. Merges results: personal first, then project
+
+Results are injected into the context with vault source tags so the model can distinguish between personal and project knowledge.
+
+---
+
+## Four-Layer Page Model (within each vault)
 
 ```
 WIKI_ROOT/

package/docs/commands.md

@@ -22,7 +22,7 @@ The extension registers 12 tools the LLM can call directly:
 | --------------------- | ------------------------------------------- |
 | `wiki_bootstrap`      | Initialize a new vault                      |
 | `wiki_capture_source` | Capture URL/file/text into immutable packet |
-| `wiki_recall`         | 🔄 Auto-called at turn start — search wiki  |
+| `wiki_recall`         | Search personal + project wikis for task-relevant pages (layered) |
 | `wiki_retro`          | Save atomic insights from completed tasks   |
 | `wiki_ingest`         | Get batch of uningested sources             |
 | `wiki_ensure_page`    | Create canonical page from template         |

package/docs/configuration.md

@@ -6,6 +6,8 @@ Wiki configuration lives in `.llm-wiki/config.json`.
 
 ### Personal
 
+The personal vault lives at `~/.llm-wiki/` (or `$WIKI_HOME`) and is always available as a fallback when no project wiki exists. It accumulates knowledge across all your sessions.
+
 - Extra folders: `wiki/journal/`, `wiki/goals/`
 - Track: learning, books, health, reflections
 
@@ -25,9 +27,19 @@ Wiki configuration lives in `.llm-wiki/config.json`.
 
 ## Environment Variables
 
-| Variable                      | Default | Description                                     |
-| ----------------------------- | ------- | ----------------------------------------------- |
-| `WIKI_MARKITDOWN_TIMEOUT_MS` | 180000  | Timeout (ms) for MarkItDown PDF/text extraction |
+| Variable                      | Default     | Description                                     |
+| ----------------------------- | ----------- | ----------------------------------------------- |
+| `WIKI_HOME`                   | `~/.llm-wiki` | Override the personal wiki vault location     |
+| `WIKI_MARKITDOWN_TIMEOUT_MS` | 180000      | Timeout (ms) for MarkItDown PDF/text extraction |
+
+## Vault Resolution
+
+The vault root is resolved in this priority order:
+
+1. **Project vault**: walk up from current directory looking for `.llm-wiki/`
+2. **Personal vault**: fall back to `$WIKI_HOME` or `~/.llm-wiki/`
+
+This means when you're in a project with its own `.llm-wiki/`, that project wiki is active. When you're outside any project wiki, your personal `~/.llm-wiki/` takes over automatically.
 
 ## Page Frontmatter
 

package/extensions/llm-wiki/index.ts

@@ -1,8 +1,8 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, join } from "node:path";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { installGuardrails } from "./lib/guardrails.js";
-import { formatRecallContext, registerWikiRecall, searchWiki } from "./lib/recall.js";
+import { formatRecallContext, registerWikiRecall, searchWikiLayered } from "./lib/recall.js";
 import { registerWikiRetro } from "./lib/retro.js";
 import {
   registerWikiBootstrap,
@@ -16,27 +16,32 @@ import {
   registerWikiStatus,
   registerWikiWatch,
 } from "./lib/tools.js";
-import { resolveVaultPaths } from "./lib/utils.js";
+import {
+  ensureVaultStructure,
+  fmtDate,
+  getVaultPaths,
+  resolveVaultPaths,
+  writeJson,
+} from "./lib/utils.js";
 
 /**
  * @zosmaai/pi-llm-wiki — LLM Wiki extension for Pi
  *
- * Registers 11 custom tools and installs guardrails:
- * All 10 original tools + wiki_recall (auto-recall at session start)
+ * Registers 12 custom tools and installs guardrails:
+ * - wiki_recall (layered: personal + project vaults)
+ * - wiki_retro (lightweight: single markdown file)
+ * - wiki_capture_source (full 4-layer pipeline)
  *
  * Guardrails:
  * - Blocks direct edits to raw/** and meta/**
  * - Auto-rebuilds metadata after wiki/** edits
  *
- * Auto-recall:
- * - before_agent_start hook searches wiki for pages relevant to user prompt
- * - Injects matching knowledge as system context
- * - wiki_recall tool available for explicit deep searches
+ * Layered recall:
+ * - before_agent_start hook searches personal + project vaults
+ * - Injects matching knowledge as system context with vault labels
+ * - wiki_recall tool available for explicit task-specific searches
  */
 
-// Track whether we already suggested bootstrapping this session
-let bootstrapSuggested = false;
-
 export default function (pi: ExtensionAPI) {
   registerWikiBootstrap(pi);
   registerWikiCaptureSource(pi);
@@ -53,43 +58,112 @@ export default function (pi: ExtensionAPI) {
 
   installGuardrails(pi);
 
+  // Track if wiki was just auto-created and needs topic inference
+  let needsTopicInference = false;
+
   pi.on("session_start", async (_event, ctx) => {
-    bootstrapSuggested = false;
     const paths = resolveVaultPaths(process.cwd());
     if (!existsSync(join(paths.dotWiki, "config.json"))) {
-      ctx.ui.setStatus("llm-wiki", "📝 No wiki — call wiki_bootstrap to enable");
+      // Silently create the wiki vault — no UI prompts
+      // Topic/mode will be inferred from user's first prompt via before_agent_start
+      const root = paths.root;
+      const vaultPaths = getVaultPaths(root);
+      ensureVaultStructure(vaultPaths);
+
+      writeJson(join(vaultPaths.dotWiki, "config.json"), {
+        name: "pending",
+        mode: "personal",
+        topic: "pending",
+        created: fmtDate(),
+        version: "1.0",
+      });
+
+      const schema = [
+        "# LLM Wiki Schema",
+        "",
+        "## Ownership Rules",
+        "",
+        "| Path | Owner | Rule |",
+        "|------|-------|------|",
+        "| raw/** | extension | immutable after capture |",
+        "| wiki/** | model + user | editable knowledge pages |",
+        "| meta/* | extension | auto-generated |",
+        "| . | human + explicit request | operating rules |",
+      ].join("\n");
+      writeFileSync(join(vaultPaths.dotWiki, "WIKI_SCHEMA.md"), schema, "utf-8");
+
+      needsTopicInference = true;
+      ctx.ui.setStatus("llm-wiki", "🧠 Wiki created (inferring topic from first prompt…)");
       return;
     }
-    ctx.ui.setStatus("llm-wiki", "🧠 LLM Wiki (12 tools, auto-recall active)");
+
+    ctx.ui.setStatus("llm-wiki", "🧠 LLM Wiki (12 tools, layered recall active)");
   });
 
-  // ─── Auto-recall hook ──────────────────────────────
-  // Before each agent turn, search the wiki for pages relevant
-  // to the user's prompt and inject them as system context.
+  // ─── Layered recall + topic inference hook ──────────
+  // Before each agent turn:
+  // 1. If wiki was just auto-created, inject a directive to infer topic/mode
+  //    from the user's first prompt and update config via wiki_bootstrap.
+  // 2. Search both personal + project vaults for relevant pages.
   pi.on("before_agent_start", async (event, _ctx) => {
     const paths = resolveVaultPaths(process.cwd());
     if (!existsSync(join(paths.dotWiki, "config.json"))) {
-      // No wiki — suggest bootstrap on first turn only
-      if (!bootstrapSuggested) {
-        bootstrapSuggested = true;
-        return {
-          systemPrompt: `${event.systemPrompt}\n\n📝 No LLM Wiki found in this directory. On your first response, use ask_user to offer the user creating one via wiki_bootstrap. After suggesting once, do not repeat.`,
-        };
-      }
       return;
     }
 
     const prompt = event.prompt || "";
-    if (!prompt.trim()) return;
+    let injectedContext = event.systemPrompt || "";
+
+    // Topic inference on first turn after auto-creation
+    if (needsTopicInference && prompt.trim()) {
+      needsTopicInference = false;
+
+      // Gather project context clues for topic inference
+      const cwd = process.cwd();
+      const dirName = basename(cwd);
+      let projectHints = `Project directory: "${dirName}" (path: ${cwd})`;
 
-    const results = searchWiki(paths, prompt);
-    if (results.length === 0) return;
+      try {
+        const pkgPath = join(cwd, "package.json");
+        if (existsSync(pkgPath)) {
+          const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+          projectHints += `\nPackage: ${pkg.name || "unknown"} v${pkg.version || "?"}`;
+          if (pkg.description) projectHints += `\nDescription: ${pkg.description}`;
+        }
+      } catch {
+        // ignore
+      }
+
+      injectedContext += `
+
+## Wiki Setup Required
+The LLM Wiki was just auto-created but needs its topic and mode configured. Before responding to the user, analyze their prompt and this project's context to infer:
+- **topic**: What is this wiki about? (e.g. "React app", "personal notes", "startup finances")
+- **mode**: "personal" or "company" based on whether this looks like work or personal use
+
+Project context hints:
+${projectHints}
+
+Then call wiki_bootstrap with the inferred topic and mode to finalize the setup. This is a one-time step.`;
+    }
+
+    // Layered recall: search personal + project vaults for relevant pages
+    if (prompt.trim()) {
+      const results = searchWikiLayered(paths, prompt);
+      if (results.length > 0) {
+        const recallContext = formatRecallContext(results);
+        if (recallContext) {
+          injectedContext += `\n\n${recallContext}`;
+        }
+      }
+    }
 
-    const context = formatRecallContext(results);
-    if (!context) return;
+    // Always inject a visible wiki status footer, even when empty
+    // This ensures the model knows the wiki is active and can use it
+    injectedContext +=
+      "\n\n<wiki_status>LLM Wiki active — use wiki_recall for deeper search, wiki_retro to save new knowledge.</wiki_status>";
 
-    return {
-      systemPrompt: `${event.systemPrompt}\n\n${context}`,
-    };
+    if (injectedContext === event.systemPrompt) return;
+    return { systemPrompt: injectedContext };
   });
 }

package/extensions/llm-wiki/lib/recall.ts

@@ -3,7 +3,13 @@ import { join } from "node:path";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { Type } from "typebox";
 import type { Registry } from "./metadata.js";
-import { type VaultPaths, readJson, resolveVaultPaths } from "./utils.js";
+import {
+  type VaultPaths,
+  getPersonalWikiPaths,
+  isPersonalVault,
+  readJson,
+  resolveVaultPaths,
+} from "./utils.js";
 
 // ─── Public API ────────────────────────────────────────
 
@@ -18,10 +24,12 @@ export interface RecallResult {
   preview: string;
   /** Relative path from wiki root */
   path: string;
+  /** Vault source label for dual-vault results */
+  vaultLabel?: string;
 }
 
 /**
- * Search the wiki registry for pages matching a query.
+ * Search a single vault's registry for pages matching a query.
  * Returns up to `maxResults` matches, each with a content preview.
  */
 export function searchWiki(paths: VaultPaths, query: string, maxResults = 5): RecallResult[] {
@@ -88,21 +96,68 @@ export function searchWiki(paths: VaultPaths, query: string, maxResults = 5): Re
   });
 }
 
+/**
+ * Format recall results as a compact system-prompt section.
+ */
+/**
+ * Search both project/primary vault and personal vault, merging results.
+ * Personal results are appended after primary results, deduplicated by page ID.
+ */
+export function searchWikiLayered(
+  primaryPaths: VaultPaths,
+  query: string,
+  maxResults = 5,
+): RecallResult[] {
+  // Search primary vault
+  const primaryResults = searchWiki(primaryPaths, query, maxResults);
+
+  // If primary is already the personal vault, no layered search needed
+  if (isPersonalVault(primaryPaths)) return primaryResults;
+
+  // Search personal vault as secondary layer
+  const personalPaths = getPersonalWikiPaths();
+  if (!existsSync(join(personalPaths.dotWiki, "config.json"))) return primaryResults;
+
+  const personalResults = searchWiki(personalPaths, query, maxResults);
+
+  // Merge: personal results first (they're the user's accumulated knowledge),
+  // then primary results (project-specific). Deduplicate by page ID.
+  const seen = new Set<string>();
+  const merged: RecallResult[] = [];
+
+  for (const r of [...personalResults, ...primaryResults]) {
+    if (seen.has(r.id)) continue;
+    seen.add(r.id);
+    // If it's from personal vault, tag it
+    if (personalResults.includes(r)) {
+      merged.push({ ...r, vaultLabel: "📓 personal" });
+    } else {
+      merged.push(r);
+    }
+  }
+
+  return merged.slice(0, maxResults);
+}
+
 /**
  * Format recall results as a compact system-prompt section.
  */
 export function formatRecallContext(results: RecallResult[]): string {
   if (results.length === 0) return "";
 
+  const hasLayered = results.some((r) => r.vaultLabel);
+  const label = hasLayered ? " (personal + project)" : "";
+
   const lines: string[] = [
     "## Relevant Wiki Knowledge",
     "",
-    `_${results.length} page(s) matched your query — reviewed automatically by LLM Wiki._`,
+    `_${results.length} page(s) matched your query${label}._`,
     "",
   ];
 
   for (const r of results) {
-    lines.push(`- **[[${r.id}]]** — *${r.type}* — ${r.title}`);
+    const vaultTag = r.vaultLabel ? ` ${r.vaultLabel}` : "";
+    lines.push(`- **[[${r.id}]]** — *${r.type}* — ${r.title}${vaultTag}`);
     if (r.preview) {
       // Truncate preview to one line
       const preview = r.preview.length > 120 ? `${r.preview.slice(0, 120)}…` : r.preview;
@@ -147,8 +202,8 @@ export function registerWikiRecall(pi: ExtensionAPI): void {
         Type.Number({ description: "Max results (default: 5, max: 10)", default: 5 }),
       ),
     }),
-    async execute(_toolCallId, params) {
-      const paths = resolveVaultPaths(process.cwd());
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const paths = resolveVaultPaths(ctx.cwd ?? process.cwd());
 
       if (!existsSync(join(paths.dotWiki, "config.json"))) {
         return {
@@ -164,30 +219,34 @@ export function registerWikiRecall(pi: ExtensionAPI): void {
       }
 
       const maxResults = Math.min(params.max_results ?? 5, 10);
-      const results = searchWiki(paths, params.query, maxResults);
+      // Use layered search: personal vault + project vault
+      const results = searchWikiLayered(paths, params.query, maxResults);
 
       if (results.length === 0) {
         return {
           content: [
             {
               type: "text",
-              text: `No wiki pages found matching "${params.query}". Use wiki_search for broader results.`,
+              text: `No wiki pages found matching "${params.query}". The wiki is empty — use wiki_retro to start building knowledge.`,
             },
           ],
           details: { query: params.query, matches: [] } as Record<string, unknown>,
         };
       }
 
+      const hasPersonal = results.some((r) => r.vaultLabel);
+      const layerTag = hasPersonal ? " (personal + project)" : "";
+
       return {
         content: [
           {
             type: "text",
             text: [
-              `🧠 **${results.length} wiki page(s) relevant** to "${params.query}":`,
+              `🧠 **${results.length} wiki page(s) relevant** to "${params.query}"${layerTag}:`,
               "",
               ...results.map(
                 (r) =>
-                  `- [[${r.id}]] — *${r.type}* — ${r.title}${
+                  `- ${r.vaultLabel || "📁"} [[${r.id}]] — *${r.type}* — ${r.title}${
                     r.preview ? `\n  > ${r.preview.slice(0, 150)}` : ""
                   }`,
               ),

package/extensions/llm-wiki/lib/retro.ts

@@ -3,19 +3,24 @@ import { join } from "node:path";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { Type } from "typebox";
 import { appendEvent, rebuildMetadataLight } from "./metadata.js";
-import { type VaultPaths, fmtDate, nextSourceId, resolveVaultPaths } from "./utils.js";
+import { type VaultPaths, fmtDate, resolveVaultPaths } from "./utils.js";
 
 // ─── Public API ────────────────────────────────────────
 
 export interface RetroResult {
-  sourceId: string;
-  packetPath: string;
+  slug: string;
   sourcePagePath: string;
 }
 
 /**
- * Save an atomic insight into the wiki as a source packet + source page.
- * Returns the source ID, packet path, and source page path.
+ * Save an atomic insight into the wiki as a single markdown file.
+ *
+ * Unlike wiki_capture_source (which creates a full source packet with
+ * manifest.json, extracted.md, and attachments), this is a lightweight
+ * path for quick knowledge capture — one file, one call.
+ *
+ * The 4-layer pipeline (raw → source pages → canonical pages → metadata)
+ * is still available via wiki_capture_source → wiki_ingest for deep research.
  */
 export function saveInsight(
   paths: VaultPaths,
@@ -24,69 +29,32 @@ export function saveInsight(
   body: string,
   category?: string,
 ): RetroResult {
-  const sourceId = nextSourceId(paths);
-  const packetPath = join(paths.rawSources, sourceId);
-  mkdirSync(packetPath, { recursive: true });
-  mkdirSync(join(packetPath, "attachments"), { recursive: true });
-
   const today = fmtDate();
 
-  // Write manifest
-  const manifest = {
-    id: sourceId,
-    title,
-    slug,
-    category: category || "uncategorized",
-    captured: today,
-    format: "insight",
-    packet_version: "1.0",
-  };
-  writeFileSync(
-    join(packetPath, "manifest.json"),
-    `${JSON.stringify(manifest, null, 2)}\n`,
-    "utf-8",
-  );
-
-  // Write extracted text (the insight body in markdown)
-  const extracted = [
-    `# ${title}`,
-    "",
-    body,
-    "",
-    "---",
-    `*Captured: ${today}*`,
-    category ? `*Category: ${category}*` : "",
-  ]
-    .filter(Boolean)
-    .join("\n");
-  writeFileSync(join(packetPath, "extracted.md"), extracted, "utf-8");
-
-  // Create source page
+  // Write a single markdown file to wiki/sources/{slug}.md
   const sourcePageDir = join(paths.wiki, "sources");
   mkdirSync(sourcePageDir, { recursive: true });
-  const sourcePagePath = join(sourcePageDir, `${sourceId}.md`);
+  const sourcePagePath = join(sourcePageDir, `${slug}.md`);
 
-  const tagLine = category ? `category: ${category}` : "";
-  const sourcePageContent = [
+  const pageContent = [
     "---",
     "type: source",
     `title: "${title}"`,
-    `source_id: ${sourceId}`,
+    `slug: ${slug}`,
     "status: insight",
     `created: ${today}`,
     `updated: ${today}`,
-    tagLine,
+    category ? `category: ${category}` : "",
     "---",
     "",
     `# ${title}`,
     "",
     body,
     "",
-    "## Source",
+    category ? `*Category: ${category}*` : "",
     "",
-    `- **Packet:** \`${packetPath}\``,
-    `- **Captured:** ${today}`,
-    category ? `- **Category:** ${category}` : "",
+    "---",
+    `*Captured: ${today}*`,
     "",
     "## Related",
     "",
@@ -95,21 +63,20 @@ export function saveInsight(
   ]
     .filter((l) => l !== "")
     .join("\n");
-  writeFileSync(sourcePagePath, sourcePageContent, "utf-8");
+  writeFileSync(sourcePagePath, pageContent, "utf-8");
 
   // Log event
   appendEvent(paths, {
     kind: "retro",
-    source_id: sourceId,
-    title,
     slug,
+    title,
     category: category || "uncategorized",
   });
 
-  // Rebuild metadata
+  // Rebuild metadata so the insight is immediately searchable
   rebuildMetadataLight(paths);
 
-  return { sourceId, packetPath, sourcePagePath };
+  return { slug, sourcePagePath };
 }
 
 // ─── Tool Registration ──────────────────────────────────
@@ -151,8 +118,8 @@ export function registerWikiRetro(pi: ExtensionAPI): void {
         }),
       ),
     }),
-    async execute(_toolCallId, params) {
-      const paths = resolveVaultPaths(process.cwd());
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const paths = resolveVaultPaths(ctx.cwd ?? process.cwd());
 
       if (!existsSync(join(paths.dotWiki, "config.json"))) {
         return {
@@ -176,8 +143,6 @@ export function registerWikiRetro(pi: ExtensionAPI): void {
             text: [
               `🧠 **Insight saved**: ${params.title}`,
               "",
-              `- Source: \`${result.sourceId}\``,
-              `- Packet: \`${result.packetPath}\``,
               `- Page: \`${result.sourcePagePath}\``,
               "",
               "This insight will be auto-surfaced by wiki_recall in future sessions.",
@@ -185,7 +150,6 @@ export function registerWikiRetro(pi: ExtensionAPI): void {
           },
         ],
         details: {
-          sourceId: result.sourceId,
           slug: params.slug,
           title: params.title,
           category: params.category || null,