@zosmaai/pi-llm-wiki 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## [Unreleased]
 
+## [0.6.0] - 2026-05-11
+
+### Added
+- **Phase 1 — Auto-recall** (PR #19 by @arjun-zosma): New `wiki_recall` tool for explicit searches. Extension now auto-searches wiki before every user turn via `before_agent_start` hook. Matching pages injected as "Relevant Wiki Knowledge" into system prompt. 8 new tests.
+- **Phase 2 — Auto-capture** (PR #20 by @arjun-zosma): New `wiki_retro` tool for saving atomic insights from completed tasks. Creates source packets with manifest, extracted text, and source page. 4 new tests.
+- **Phase 3 — MCP Server** (PR #21 by @arjun-zosma): Standalone MCP server using `@modelcontextprotocol/server` (v2 SDK) with stdio transport. Exposes 5 tools: wiki_recall, wiki_search, wiki_status, wiki_retro, wiki_capture_source. Cross-platform reach to Claude Code, Cursor, Windsurf.
+- **12 extension tools** (up from 10): wiki_recall (auto at turn start) and wiki_retro (manual at task end)
+- **SKILL.md**: Auto-Recall section, wiki_recall + wiki_retro tool docs, "Task → Capture → Retro" workflow
+
+### Changed
+- Extension registers 12 tools instead of 10
+- Status bar now shows "12 tools, auto-recall active"
+
 ## [0.5.0] - 2026-05-11
 
 ### Added

package/extensions/llm-wiki/index.ts

@@ -1,5 +1,9 @@
+import { existsSync } from "node:fs";
+import { 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 { registerWikiRetro } from "./lib/retro.js";
 import {
   registerWikiBootstrap,
   registerWikiCaptureSource,
@@ -12,25 +16,22 @@ import {
   registerWikiStatus,
   registerWikiWatch,
 } from "./lib/tools.js";
+import { getVaultPaths, resolveVaultRoot } from "./lib/utils.js";
 
 /**
  * @zosmaai/pi-llm-wiki — LLM Wiki extension for Pi
  *
- * Registers 10 custom tools and installs guardrails:
- * - wiki_bootstrap      Initialize a new vault
- * - wiki_capture_source Capture URL/file/text into source packet
- * - wiki_ingest         Get batch of sources needing synthesis
- * - wiki_ensure_page    Create canonical page from template
- * - wiki_search         Search generated registry
- * - wiki_lint           Health check with auto-fix
- * - wiki_status         Instant stats from registry
- * - wiki_rebuild_meta   Force metadata rebuild
- * - wiki_log_event      Append event and regenerate log
- * - wiki_watch          Schedule auto-updates
+ * Registers 11 custom tools and installs guardrails:
+ * All 10 original tools + wiki_recall (auto-recall at session start)
  *
  * 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
  */
 
 export default function (pi: ExtensionAPI) {
@@ -44,10 +45,36 @@ export default function (pi: ExtensionAPI) {
   registerWikiRebuildMeta(pi);
   registerWikiLogEvent(pi);
   registerWikiWatch(pi);
+  registerWikiRecall(pi);
+  registerWikiRetro(pi);
 
   installGuardrails(pi);
 
   pi.on("session_start", async (_event, ctx) => {
-    ctx.ui.setStatus("llm-wiki", "🧠 LLM Wiki (10 tools, guardrails active)");
+    ctx.ui.setStatus("llm-wiki", "🧠 LLM Wiki (11 tools, auto-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.
+  pi.on("before_agent_start", async (event, _ctx) => {
+    const root = resolveVaultRoot(process.cwd());
+    if (!existsSync(join(root, ".wiki", "config.json"))) {
+      return; // No wiki vault — nothing to recall
+    }
+
+    const paths = getVaultPaths(root);
+    const prompt = event.prompt || "";
+    if (!prompt.trim()) return;
+
+    const results = searchWiki(paths, prompt);
+    if (results.length === 0) return;
+
+    const context = formatRecallContext(results);
+    if (!context) return;
+
+    return {
+      systemPrompt: `${event.systemPrompt}\n\n${context}`,
+    };
   });
 }

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

@@ -0,0 +1,208 @@
+import { existsSync, readFileSync } from "node:fs";
+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, getVaultPaths, readJson, readText, resolveVaultRoot } from "./utils.js";
+
+// ─── Public API ────────────────────────────────────────
+
+export interface RecallResult {
+  /** Page identifier (folder-qualified, e.g. "concepts/rag") */
+  id: string;
+  /** Page title */
+  title: string;
+  /** Page type: source, entity, concept, synthesis, analysis */
+  type: string;
+  /** First N chars of page content for context */
+  preview: string;
+  /** Relative path from wiki root */
+  path: string;
+}
+
+/**
+ * Search the wiki 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[] {
+  const registry = readJson<Registry>(join(paths.meta, "registry.json"), {
+    version: "1.0",
+    last_updated: "",
+    pages: {},
+  });
+
+  const q = query.toLowerCase();
+  const terms = q
+    .split(/\s+/)
+    .filter((t) => t.length > 2)
+    .slice(0, 10);
+
+  if (terms.length === 0) return [];
+
+  type Scored = { id: string; entry: Registry["pages"][string]; score: number };
+  const scored: Scored[] = [];
+
+  for (const [id, entry] of Object.entries(registry.pages)) {
+    let score = 0;
+    const title = String(entry.title || "").toLowerCase();
+    const type = String(entry.type || "").toLowerCase();
+
+    for (const term of terms) {
+      if (id.toLowerCase().includes(term)) score += 3;
+      if (title.includes(term)) score += 4;
+      if (type.includes(term)) score += 1;
+    }
+
+    // Boost if query terms appear in tags/categories
+    const tags = String(entry.tags || entry.category || entry.domain || "");
+    for (const term of terms) {
+      if (tags.toLowerCase().includes(term)) score += 2;
+    }
+
+    if (score > 0) {
+      scored.push({ id, entry, score });
+    }
+  }
+
+  scored.sort((a, b) => b.score - a.score);
+  const top = scored.slice(0, maxResults);
+
+  return top.map(({ id, entry }) => {
+    // Try to read page content for preview
+    let preview = "";
+    const pagePath = join(paths.wiki, `${id}.md`);
+    if (existsSync(pagePath)) {
+      const content = readFileSync(pagePath, "utf-8");
+      // Strip frontmatter
+      const body = content.replace(/^---[\s\S]*?---\n/, "").trim();
+      preview = body.slice(0, 200).replace(/\n/g, " ");
+    }
+
+    return {
+      id,
+      title: String(entry.title || id),
+      type: String(entry.type || "page"),
+      preview,
+      path: pagePath,
+    };
+  });
+}
+
+/**
+ * Format recall results as a compact system-prompt section.
+ */
+export function formatRecallContext(results: RecallResult[]): string {
+  if (results.length === 0) return "";
+
+  const lines: string[] = [
+    "## Relevant Wiki Knowledge",
+    "",
+    `_${results.length} page(s) matched your query — reviewed automatically by LLM Wiki._`,
+    "",
+  ];
+
+  for (const r of results) {
+    lines.push(`- **[[${r.id}]]** — *${r.type}* — ${r.title}`);
+    if (r.preview) {
+      // Truncate preview to one line
+      const preview = r.preview.length > 120 ? `${r.preview.slice(0, 120)}…` : r.preview;
+      lines.push(`  ${preview}`);
+    }
+    lines.push("");
+  }
+
+  lines.push(
+    "Use `read` to view full pages. Add new findings via wiki_ensure_page or wiki_retro.",
+    "",
+  );
+
+  return lines.join("\n");
+}
+
+// ─── Tool Registration ──────────────────────────────────
+
+/**
+ * Register the `wiki_recall` tool.
+ * The model can call this explicitly to search the wiki.
+ * It is also called automatically via before_agent_start hook.
+ */
+export function registerWikiRecall(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "wiki_recall",
+    label: "Wiki Recall",
+    description:
+      "Search the wiki for pages relevant to a query. " +
+      "Returns matching page IDs, titles, types, and content previews. " +
+      "Called automatically at session start — use explicitly to dig deeper.",
+    promptSnippet: "Recall wiki knowledge relevant to the current task",
+    promptGuidelines: [
+      "Use wiki_recall at the START of every task to find relevant wiki knowledge.",
+      "The extension auto-calls wiki_recall — but calling it explicitly with specific terms gets better results.",
+    ],
+    parameters: Type.Object({
+      query: Type.String({
+        description: "Search query — use the user's full request or key terms",
+      }),
+      max_results: Type.Optional(
+        Type.Number({ description: "Max results (default: 5, max: 10)", default: 5 }),
+      ),
+    }),
+    async execute(_toolCallId, params) {
+      const root = resolveVaultRoot(process.cwd());
+      const paths = getVaultPaths(root);
+
+      if (!existsSync(join(root, ".wiki", "config.json"))) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No wiki vault found at this location. Initialize one with wiki_bootstrap first.",
+            },
+          ],
+          details: { error: "no_vault" } as Record<string, unknown>,
+          isError: true,
+        };
+      }
+
+      const maxResults = Math.min(params.max_results ?? 5, 10);
+      const results = searchWiki(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.`,
+            },
+          ],
+          details: { query: params.query, matches: [] } as Record<string, unknown>,
+        };
+      }
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: [
+              `🧠 **${results.length} wiki page(s) relevant** to "${params.query}":`,
+              "",
+              ...results.map(
+                (r) =>
+                  `- [[${r.id}]] — *${r.type}* — ${r.title}${
+                    r.preview ? `\n  > ${r.preview.slice(0, 150)}` : ""
+                  }`,
+              ),
+              "",
+              "Use `read` on any page for full content.",
+              "Use `wiki_retro` to save new insights from this task.",
+            ].join("\n"),
+          },
+        ],
+        details: { query: params.query, matches: results.map((r) => r.id) } as Record<
+          string,
+          unknown
+        >,
+      };
+    },
+  });
+}

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

@@ -0,0 +1,203 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+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,
+  getVaultPaths,
+  nextSourceId,
+  resolveVaultRoot,
+} from "./utils.js";
+
+// ─── Public API ────────────────────────────────────────
+
+export interface RetroResult {
+  sourceId: string;
+  packetPath: 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.
+ */
+export function saveInsight(
+  paths: VaultPaths,
+  slug: string,
+  title: string,
+  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
+  const sourcePageDir = join(paths.wiki, "sources");
+  mkdirSync(sourcePageDir, { recursive: true });
+  const sourcePagePath = join(sourcePageDir, `${sourceId}.md`);
+
+  const tagLine = category ? `category: ${category}` : "";
+  const sourcePageContent = [
+    "---",
+    "type: source",
+    `title: "${title}"`,
+    `source_id: ${sourceId}`,
+    "status: insight",
+    `created: ${today}`,
+    `updated: ${today}`,
+    tagLine,
+    "---",
+    "",
+    `# ${title}`,
+    "",
+    body,
+    "",
+    "## Source",
+    "",
+    `- **Packet:** \`${packetPath}\``,
+    `- **Captured:** ${today}`,
+    category ? `- **Category:** ${category}` : "",
+    "",
+    "## Related",
+    "",
+    "_(Add [[wikilinks]] to related pages)_",
+    "",
+  ]
+    .filter((l) => l !== "")
+    .join("\n");
+  writeFileSync(sourcePagePath, sourcePageContent, "utf-8");
+
+  // Log event
+  appendEvent(paths, {
+    kind: "retro",
+    source_id: sourceId,
+    title,
+    slug,
+    category: category || "uncategorized",
+  });
+
+  // Rebuild metadata
+  rebuildMetadataLight(paths);
+
+  return { sourceId, packetPath, sourcePagePath };
+}
+
+// ─── Tool Registration ──────────────────────────────────
+
+/**
+ * Register the `wiki_retro` tool.
+ * The model calls this to save an atomic insight from a completed task.
+ * Inspired by the memex_retro pattern.
+ */
+export function registerWikiRetro(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "wiki_retro",
+    label: "Wiki Retro",
+    description:
+      "Save an atomic insight from a completed task into the wiki. " +
+      "Creates a source packet and source page. The insight will be " +
+      "surfaced automatically by wiki_recall in future sessions.",
+    promptSnippet: "Save atomic insights from completed tasks into the wiki",
+    promptGuidelines: [
+      "Use wiki_retro at the END of every meaningful task to save what you learned.",
+      "Write atomic insights — one insight per call. Use multiple calls for multiple insights.",
+      "The insight will be auto-surfaced by wiki_recall in future sessions.",
+    ],
+    parameters: Type.Object({
+      slug: Type.String({
+        description:
+          "Unique kebab-case identifier (e.g. 'jwt-revocation-pattern'). Used for lookups.",
+      }),
+      title: Type.String({
+        description: "Short descriptive title (60 chars max). Noun phrase, not a sentence.",
+      }),
+      body: Type.String({
+        description:
+          "Markdown body with [[wikilinks]] to related wiki pages. Explain what was learned.",
+      }),
+      category: Type.Optional(
+        Type.String({
+          description: "Optional category (e.g. frontend, architecture, devops, bugfix, design)",
+        }),
+      ),
+    }),
+    async execute(_toolCallId, params) {
+      const root = resolveVaultRoot(process.cwd());
+      const paths = getVaultPaths(root);
+
+      if (!existsSync(join(root, ".wiki", "config.json"))) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No wiki vault found at this location. Initialize one with wiki_bootstrap first.",
+            },
+          ],
+          details: { error: "no_vault" } as Record<string, unknown>,
+          isError: true,
+        };
+      }
+
+      const result = saveInsight(paths, params.slug, params.title, params.body, params.category);
+
+      return {
+        content: [
+          {
+            type: "text",
+            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.",
+            ].join("\n"),
+          },
+        ],
+        details: {
+          sourceId: result.sourceId,
+          slug: params.slug,
+          title: params.title,
+          category: params.category || null,
+        } as Record<string, unknown>,
+      };
+    },
+  });
+}

package/mcp/index.ts

@@ -0,0 +1,463 @@
+#!/usr/bin/env node
+
+/**
+ * LLM Wiki MCP Server
+ *
+ * Exposes wiki tools over the Model Context Protocol (MCP).
+ * Run: node mcp/index.js
+ * Or via package.json: pi install npm:@zosmaai/pi-llm-wiki && node mcp/index.js
+ *
+ * Environment:
+ *   WIKI_ROOT — path to wiki vault (default: auto-detect from cwd)
+ *   WIKI_MARKITDOWN_TIMEOUT_MS — PDF extraction timeout (default: 180000)
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { McpServer } from "@modelcontextprotocol/server";
+import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
+import * as z from "zod/v4";
+
+// ─── Wiki Vault Detection ──────────────────────────────
+
+interface VaultPaths {
+  root: string;
+  rawSources: string;
+  wiki: string;
+  meta: string;
+}
+
+function resolveVaultRoot(cwd: string): string | null {
+  if (existsSync(join(cwd, ".wiki", "config.json"))) return cwd;
+  const parts = cwd.split("/");
+  for (let i = parts.length - 1; i >= 0; i--) {
+    const dir = parts.slice(0, i + 1).join("/") || "/";
+    if (existsSync(join(dir, ".wiki", "config.json"))) return dir;
+  }
+  return null;
+}
+
+function getPaths(): VaultPaths {
+  const root = process.env.WIKI_ROOT || resolveVaultRoot(process.cwd()) || process.cwd();
+  return {
+    root,
+    rawSources: join(root, "raw", "sources"),
+    wiki: join(root, "wiki"),
+    meta: join(root, "meta"),
+  };
+}
+
+function hasVault(): boolean {
+  return existsSync(join(getPaths().root, ".wiki", "config.json"));
+}
+
+// ─── Helpers ────────────────────────────────────────────
+
+function readJson<T>(path: string, defaultVal: T): T {
+  try {
+    if (!existsSync(path)) return defaultVal;
+    return JSON.parse(readFileSync(path, "utf-8")) as T;
+  } catch {
+    return defaultVal;
+  }
+}
+
+// ─── MCP Server ─────────────────────────────────────────
+
+const server = new McpServer({
+  name: "llm-wiki",
+  version: "1.0.0",
+});
+
+// ---- wiki_recall ----
+
+server.registerTool(
+  "wiki_recall",
+  {
+    description:
+      "Search the wiki for pages relevant to a query. Returns matching page IDs, titles, types, and content previews.",
+    inputSchema: z.object({
+      query: z.string().describe("Search query — use the user's full request or key terms"),
+      max_results: z.number().optional().default(5).describe("Max results (default: 5, max: 10)"),
+    }),
+  },
+  async ({ query, max_results }) => {
+    if (!hasVault()) {
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: "No wiki vault found. Set WIKI_ROOT or run wiki_bootstrap first.",
+          },
+        ],
+        isError: true,
+      };
+    }
+
+    const paths = getPaths();
+    const registry = readJson<{
+      pages: Record<string, { type: string; title: string; [key: string]: unknown }>;
+    }>(join(paths.meta, "registry.json"), { pages: {} });
+
+    const terms = query
+      .toLowerCase()
+      .split(/\s+/)
+      .filter((t) => t.length > 2)
+      .slice(0, 10);
+
+    if (terms.length === 0) {
+      return {
+        content: [{ type: "text" as const, text: "Query too short." }],
+      };
+    }
+
+    type Scored = { id: string; score: number };
+    const scored: Scored[] = [];
+
+    for (const [id, entry] of Object.entries(registry.pages)) {
+      let score = 0;
+      const title = String(entry.title || "").toLowerCase();
+      const type = String(entry.type || "").toLowerCase();
+
+      for (const term of terms) {
+        if (id.toLowerCase().includes(term)) score += 3;
+        if (title.includes(term)) score += 4;
+        if (type.includes(term)) score += 1;
+      }
+
+      const tags = String(entry.tags || entry.category || entry.domain || "").toLowerCase();
+      for (const term of terms) {
+        if (tags.includes(term)) score += 2;
+      }
+
+      if (score > 0) scored.push({ id, score });
+    }
+
+    scored.sort((a, b) => b.score - a.score);
+    const top = scored.slice(0, Math.min(max_results ?? 5, 10));
+
+    const results = top.map(({ id }) => {
+      const entry = registry.pages[id];
+      let preview = "";
+      const pagePath = join(paths.wiki, `${id}.md`);
+      if (existsSync(pagePath)) {
+        const content = readFileSync(pagePath, "utf-8");
+        preview = content
+          .replace(/^---[\s\S]*?---\n/, "")
+          .trim()
+          .slice(0, 200)
+          .replace(/\n/g, " ");
+      }
+      return {
+        id,
+        title: String(entry?.title || id),
+        type: String(entry?.type || "page"),
+        preview,
+      };
+    });
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: JSON.stringify(results, null, 2),
+        },
+      ],
+    };
+  },
+);
+
+// ---- wiki_search ----
+
+server.registerTool(
+  "wiki_search",
+  {
+    description: "Search the wiki registry for pages matching a query.",
+    inputSchema: z.object({
+      query: z.string().describe("Search term"),
+      type: z
+        .string()
+        .optional()
+        .describe("Filter by page type (source, entity, concept, synthesis, analysis)"),
+    }),
+  },
+  async ({ query, type }) => {
+    if (!hasVault()) {
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: "No wiki vault found. Set WIKI_ROOT or run wiki_bootstrap first.",
+          },
+        ],
+        isError: true,
+      };
+    }
+
+    const paths = getPaths();
+    const registry = readJson<{
+      pages: Record<string, { type: string; title: string; [key: string]: unknown }>;
+    }>(join(paths.meta, "registry.json"), { pages: {} });
+
+    const q = query.toLowerCase();
+    const matches = Object.entries(registry.pages)
+      .filter(([id, entry]) => {
+        const matchesQuery =
+          id.toLowerCase().includes(q) ||
+          String(entry.title).toLowerCase().includes(q) ||
+          String(entry.type).toLowerCase().includes(q);
+        const matchesType = !type || String(entry.type).toLowerCase() === type.toLowerCase();
+        return matchesQuery && matchesType;
+      })
+      .map(([id, entry]) => ({
+        id,
+        title: entry.title,
+        type: entry.type,
+      }));
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text:
+            matches.length > 0 ? JSON.stringify(matches, null, 2) : `No pages found for "${query}"`,
+        },
+      ],
+    };
+  },
+);
+
+// ---- wiki_status ----
+
+server.registerTool(
+  "wiki_status",
+  {
+    description: "Show wiki health and stats: page counts, orphans, recent activity.",
+    inputSchema: z.object({}),
+  },
+  async () => {
+    if (!hasVault()) {
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: "No wiki vault found. Set WIKI_ROOT or run wiki_bootstrap first.",
+          },
+        ],
+        isError: true,
+      };
+    }
+
+    const paths = getPaths();
+    const registry = readJson<{
+      version: string;
+      last_updated: string;
+      pages: Record<string, { type: string; title: string; [key: string]: unknown }>;
+    }>(join(paths.meta, "registry.json"), {
+      version: "1.0",
+      last_updated: "",
+      pages: {},
+    });
+
+    const config = readJson<Record<string, unknown>>(join(paths.root, ".wiki", "config.json"), {});
+
+    const byType: Record<string, number> = {};
+    for (const entry of Object.values(registry.pages)) {
+      byType[entry.type] = (byType[entry.type] || 0) + 1;
+    }
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: JSON.stringify(
+            {
+              topic: config.topic || "Unknown",
+              mode: config.mode || "personal",
+              totalPages: Object.keys(registry.pages).length,
+              byType,
+              lastUpdated: registry.last_updated || "Never",
+            },
+            null,
+            2,
+          ),
+        },
+      ],
+    };
+  },
+);
+
+// ---- wiki_retro ----
+
+server.registerTool(
+  "wiki_retro",
+  {
+    description:
+      "Save an atomic insight from a completed task into the wiki. Creates a source packet and source page.",
+    inputSchema: z.object({
+      slug: z.string().describe("Unique kebab-case identifier (e.g. 'jwt-revocation-pattern')"),
+      title: z.string().describe("Short descriptive title (60 chars max)"),
+      body: z
+        .string()
+        .describe(
+          "Markdown body explaining what was learned. Include [[wikilinks]] to related pages.",
+        ),
+      category: z
+        .string()
+        .optional()
+        .describe("Category (e.g. frontend, architecture, devops, bugfix)"),
+    }),
+  },
+  async ({ slug, title, body, category }) => {
+    if (!hasVault()) {
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: "No wiki vault found. Set WIKI_ROOT or run wiki_bootstrap first.",
+          },
+        ],
+        isError: true,
+      };
+    }
+
+    const { saveInsight } = (await import("../extensions/llm-wiki/lib/retro.js")) as {
+      saveInsight: (
+        paths: Record<string, string>,
+        slug: string,
+        title: string,
+        body: string,
+        category?: string,
+      ) => { sourceId: string; packetPath: string; sourcePagePath: string };
+    };
+
+    const vaultPaths = {
+      ...getPaths(),
+      raw: join(getPaths().root, "raw"),
+      dotWiki: join(getPaths().root, ".wiki"),
+      outputs: join(getPaths().root, "outputs"),
+      discoveries: join(getPaths().root, ".discoveries"),
+    };
+
+    const result = saveInsight(vaultPaths, slug, title, body, category);
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: `Insight saved: ${result.sourceId} — ${title}`,
+        },
+      ],
+    };
+  },
+);
+
+// ---- wiki_capture_source ----
+
+server.registerTool(
+  "wiki_capture_source",
+  {
+    description: "Capture a URL, local file, or pasted text into an immutable source packet.",
+    inputSchema: z.object({
+      text: z.string().optional().describe("Text content to capture"),
+      url: z.string().optional().describe("URL to capture"),
+      file_path: z.string().optional().describe("Local file path to capture"),
+      title: z.string().optional().describe("Title for the captured source"),
+    }),
+  },
+  async ({ text, url: urlParam, file_path, title }) => {
+    if (!hasVault()) {
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: "No wiki vault found. Set WIKI_ROOT or run wiki_bootstrap first.",
+          },
+        ],
+        isError: true,
+      };
+    }
+
+    const vaultPaths = {
+      ...getPaths(),
+      raw: join(getPaths().root, "raw"),
+      dotWiki: join(getPaths().root, ".wiki"),
+      outputs: join(getPaths().root, "outputs"),
+      discoveries: join(getPaths().root, ".discoveries"),
+    };
+
+    let result: { sourceId: string };
+
+    if (urlParam) {
+      // For MCP, use simple curl-based capture
+      const { captureUrl } = (await import("../extensions/llm-wiki/lib/source-packet.js")) as {
+        captureUrl: (
+          pi: never,
+          paths: Record<string, string>,
+          url: string,
+          signal?: AbortSignal,
+        ) => Promise<{ sourceId: string }>;
+      };
+      result = await captureUrl(
+        { exec: async () => ({ stdout: "", stderr: "", code: 0 }) } as never,
+        vaultPaths,
+        urlParam,
+      );
+    } else if (file_path) {
+      const { captureFile } = (await import("../extensions/llm-wiki/lib/source-packet.js")) as {
+        captureFile: (
+          pi: never,
+          paths: Record<string, string>,
+          filePath: string,
+          signal?: AbortSignal,
+        ) => Promise<{ sourceId: string }>;
+      };
+      result = await captureFile(
+        { exec: async () => ({ stdout: "", stderr: "", code: 0 }) } as never,
+        vaultPaths,
+        file_path,
+      );
+    } else if (text) {
+      const { captureText } = (await import("../extensions/llm-wiki/lib/source-packet.js")) as {
+        captureText: (
+          paths: Record<string, string>,
+          text: string,
+          title?: string,
+        ) => { sourceId: string };
+      };
+      result = captureText(vaultPaths, text, title);
+    } else {
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: "Provide one of: text, url, or file_path",
+          },
+        ],
+        isError: true,
+      };
+    }
+
+    return {
+      content: [
+        {
+          type: "text" as const,
+          text: `Source captured: ${result.sourceId}`,
+        },
+      ],
+    };
+  },
+);
+
+// ─── Main ───────────────────────────────────────────────
+
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("🧠 LLM Wiki MCP Server running on stdio");
+}
+
+main().catch((err) => {
+  console.error("MCP Server error:", err);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zosmaai/pi-llm-wiki",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Self-maintaining LLM Wiki for Pi — Karpathy-pattern knowledge base with immutable source capture, automated ingestion, search, linting, and Obsidian-compatible vault. auto-updating personal & company wiki.",
   "keywords": [
     "pi",
@@ -37,6 +37,7 @@
     "extensions",
     "skills",
     "prompts",
+    "mcp",
     "docs",
     "assets",
     "README.md",
@@ -62,7 +63,10 @@
     "extensions": ["./extensions"],
     "skills": ["./skills"],
     "prompts": ["./prompts"],
-    "image": "https://raw.githubusercontent.com/zosmaai/pi-llm-wiki/main/assets/screenshot.png"
+    "image": "https://raw.githubusercontent.com/zosmaai/pi-llm-wiki/main/assets/screenshot.png",
+    "mcpservers": {
+      "llm-wiki": "node ./mcp/index.js"
+    }
   },
   "peerDependencies": {
     "@mariozechner/pi-coding-agent": "*",
@@ -71,6 +75,9 @@
   "engines": {
     "node": ">=18"
   },
+  "dependencies": {
+    "@modelcontextprotocol/server": "^2.0.0-alpha.2"
+  },
   "devDependencies": {
     "@biomejs/biome": "^1.9.4",
     "@mariozechner/pi-coding-agent": "^0.70.2",

package/skills/llm-wiki/SKILL.md

@@ -45,21 +45,48 @@ WIKI_ROOT/
 
 ## How the Extension Helps You
 
-| Task               | Before (skill-only)          | Now (extension-backed)                |
-| ------------------ | ---------------------------- | ------------------------------------- |
-| Track ingestion    | Manual `history.json`        | Automatic via `meta/registry.json`    |
-| Update INDEX       | Manual edit after every page | Auto-rebuilds on turn end             |
-| Update LOG         | Manual append                | Auto-generated from `events.jsonl`    |
-| Find orphans       | Shell `grep` scans           | Instant from `backlinks.json`         |
-| Block raw edits    | Skill says "don't"           | Extension **enforces** immutability   |
-| Create source page | 8 tool calls                 | `wiki_capture_source` + LLM synthesis |
+| Task                        | Before (skill-only)          | Now (extension-backed)                |
+| --------------------------- | ---------------------------- | ------------------------------------- |
+| Track ingestion             | Manual `history.json`        | Automatic via `meta/registry.json`    |
+| Update INDEX                | Manual edit after every page | Auto-rebuilds on turn end             |
+| Update LOG                  | Manual append                | Auto-generated from `events.jsonl`    |
+| Find orphans                | Shell `grep` scans           | Instant from `backlinks.json`         |
+| Block raw edits             | Skill says "don't"           | Extension **enforces** immutability   |
+| Create source page          | 8 tool calls                 | `wiki_capture_source` + LLM synthesis |
+| **Recall wiki knowledge**   | Never happens                | **Auto-search before every turn**     |
+| **Save task insights**      | Manual capture               | `wiki_retro` — one tool call          |
+
+## 🔄 Auto-Recall (New)
+
+**The extension now automatically searches the wiki before every user turn.**
+
+When you send a prompt, the extension:
+1. Extracts key terms from your request
+2. Searches the wiki registry for matching pages
+3. Injects matching page titles + summaries into context
+4. You see this as "Relevant Wiki Knowledge" in your system prompt
+
+**This means the wiki works as an automatic second brain.**
+You don't need to remember to search — relevant knowledge is surfaced automatically.
+
+### Manual recall for deeper searches
+
+If the auto-recall doesn't find enough context, call `wiki_recall` explicitly:
+
+```
+wiki_recall(query="specific terms...", max_results=10)
+```
+
+This gives you more control over the search terms and returns content previews.
 
 ## Available Tools
 
-Use these directly — they handle scaffolding and bookkeeping:
+Use these directly — they handle scaffolding, bookkeeping, recall, and capture:
 
 - `wiki_bootstrap` — Initialize a new vault
 - `wiki_capture_source` — Capture URL/file/text into immutable packet + skeleton page
+- `wiki_recall` — **Auto-called at turn start.** Search wiki for task-relevant pages
+- `wiki_retro` — Save an atomic insight from a completed task into the wiki
 - `wiki_ingest` — Get batch of uningested sources with extracted text
 - `wiki_ensure_page` — Create entity/concept/synthesis/analysis page from template
 - `wiki_search` — Search registry for existing pages
@@ -83,12 +110,20 @@ Use these directly — they handle scaffolding and bookkeeping:
 
 ### Query → Answer → File
 
-1. `wiki_search(query="...")` to find relevant pages
+1. **Auto-recall**: Extension surfaces relevant wiki pages automatically
 2. Read those pages
 3. Synthesize answer with `[[wikilink]]` citations
 4. If novel: create analysis page via `wiki_ensure_page(type="analysis")`
 5. Extension auto-updates metadata
 
+### Task → Capture → Retro
+
+1. Complete a meaningful task
+2. Call `wiki_retro` to save key insights
+3. The insight is captured as a source packet
+4. Extension auto-updates metadata
+5. Next time, auto-recall surfaces your saved insight
+
 ## Page Conventions
 
 ### Naming