pi-weave 0.3.12 → 0.3.14

package/README.md

@@ -57,8 +57,15 @@ pi-weave keeps track of where knowledge came from, while making the whole worksp
 
 ## Install
 
-pi-weave supports [Pi](https://github.com/earendil-works/pi) and OpenCode (V1 **1.18.29+** and V2) from the same package. The adapters share
-the vault, repository index, browser workspace, tools, and skills.
+pi-weave supports [Pi](https://github.com/earendil-works/pi), OpenCode (V1 **1.18.29+** and V2), and Claude Code from the same repository.
+The adapters share the vault, repository index, browser workspace, tools, and skills.
+
+Claude Code:
+
+```bash
+/plugin marketplace add EranYonai/pi-weave
+/plugin install pi-weave@pi-weave
+```
 
 OpenCode V2:
 
@@ -176,13 +183,14 @@ Every change to a note is saved to `<vault>/history/`, whether you, your agent,
 ## Remember sessions
 
 ```bash
-/weave-scan sessions                    # Pi history, or the current OpenCode session
+/weave-scan sessions                    # Pi history, or the current OpenCode or Claude Code session
 /weave-scan sessions /path/to/history   # explicit history root
 ```
 
 This opt-in scan treats a supplied file—or every bounded text file under a supplied directory—as opaque session material for the active
 model to interpret, then writes generated notes under `~/.okf/notes/sessions/`. In OpenCode, the pathless form reads the current session
-through the public plugin API; it never inspects OpenCode's internal database. That makes explicit paths usable with Claude Code, OpenCode,
+through the public plugin API; it never inspects OpenCode's internal database. In Claude Code, it reads the current session's transcript
+from `~/.claude/projects/` (or `$CLAUDE_CONFIG_DIR/projects/`). That makes explicit paths usable with Claude Code, OpenCode,
 Codex, or exported history trees without requiring their schema or file extension. It skips unchanged files, captures outcomes plus reusable
 technical takeaways, works outside Git repositories, and can be stopped with `/weave-scan-cancel`.
 
@@ -212,6 +220,7 @@ Most people only need natural language and `/weave-view`.
 | Command | `/weave-scan` | Add incremental model-written file summaries |
 | Command | `/weave-scan sessions [path]` | Turn changed session-history files into durable memory notes |
 | Command | `/weave-scan-cancel` | Stop a running scan |
+| Command | `/weave-statusline` | Claude Code only: print the setting that shows pi-weave in the status line |
 | Tool | `weave_note` | List, read, add, append, finalize, and search notes |
 | Tool | `weave_repo` | Describe the repository structure for the agent |
 
@@ -221,6 +230,13 @@ pipeline, so the model reports command results in the conversation. `/weave` doe
 chat message: send a message after selecting a model, then scan. Generation runs in temporary child sessions with tools denied;
 those sessions are removed on completion or cancellation. V2 uses its direct command and generation APIs.
 
+In Claude Code, the commands appear as `/pi-weave:weave-view` and so on (type `/weave` and pick one). The plugin runs a small local MCP
+server for the tools and the workspace, and a SessionStart hook adds the vault status to each session. Scans run in the background: `/weave`
+shows their progress and result. Each summary is one headless `claude -p` run on Haiku with tools and MCP servers disabled, billed to your
+own Claude Code login; set `PI_WEAVE_CLAUDE_MODEL` to use another model. Claude Code asks before each tool call until you allow the
+pi-weave tools; to allow them up front, add `"mcp__plugin_pi-weave_pi-weave"` to `permissions.allow` in your settings. The plugin needs
+`node` (20.13+) on your `PATH`.
+
 ## Files, privacy, and portability
 
 Personal notes are ordinary Markdown files:
@@ -260,15 +276,16 @@ We probably want OIDC next quarter…
 Set `PI_WEAVE_VAULT` to use a different vault location.
 
 Reading, writing, searching, and viewing notes are local operations. Deep repository scans and session summaries send bounded input to the
-active Pi/V2 model or the last-used V1 chat model. The browser workspace binds only to loopback, uses a per-session token, and shuts down
+active Pi/V2 model, the last-used V1 chat model, or headless Claude Code. The browser workspace binds only to loopback, uses a per-session token, and shuts down
 with the plugin lifecycle. OpenCode opens it automatically when the terminal can reach the viewer's loopback URL. Otherwise, it shows the
 exact URL for a browser or tunnel.
 
-The vault format, repository index, and skills are intentionally harness-agnostic. `src/core` contains no Pi- or OpenCode-specific imports.
+The vault format, repository index, and skills are intentionally harness-agnostic. `src/core` contains no Pi-, OpenCode-, or Claude Code-specific imports.
 
 ## Development
 
-The OpenCode V1/V2 bindings share tool schemas, core actions, and one command/scan workflow. Zod is the only direct runtime dependency,
+All adapters share one set of tool schemas (`src/core/tools.ts`), the core actions, and one command/scan workflow
+(`src/core/workspaceCommands.ts`). Zod is the only direct runtime dependency,
 required by V1's tool-schema protocol; OpenCode SDKs are development-only.
 
 ```bash
@@ -286,7 +303,8 @@ npm run build:web
 ```
 
 Coverage must remain at or above **95%** for lines, branches, functions, and statements. If browser source changes, rebuild and commit
-`src/web/client/dist/app.js`.
+`src/web/client/dist/app.js`. The Claude Code plugin runs from a committed bundle too: after changing anything it imports, run
+`npm run build:claude` and commit `claude/dist/weave.mjs`.
 
 Read [AGENTS.md](AGENTS.md) before contributing. Work on a feature branch; do not commit directly to `main`.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-weave",
-  "version": "0.3.12",
-  "description": "Local-first Markdown memory and knowledge graph for Pi and OpenCode: preserve decisions, recall sessions, and explore notes with code.",
+  "version": "0.3.14",
+  "description": "Local-first Markdown memory and knowledge graph for Pi, OpenCode and Claude Code: preserve decisions, recall sessions, and explore notes with code.",
   "type": "module",
   "sideEffects": false,
   "publishConfig": {
@@ -11,6 +11,7 @@
     "pi-package",
     "pi-coding-agent",
     "opencode-plugin",
+    "claude-code-plugin",
     "agent-memory",
     "persistent-memory",
     "markdown",
@@ -59,8 +60,10 @@
     "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.web.json",
     "build:web": "node scripts/build-web.mjs",
     "build:web:check": "node scripts/build-web.mjs --check",
+    "build:claude": "node scripts/build-claude.mjs",
+    "build:claude:check": "node scripts/build-claude.mjs --check",
     "e2e": "vitest run --config vitest.e2e.config.ts",
-    "check": "npm run typecheck && npm run build:web:check && npm run coverage",
+    "check": "npm run typecheck && npm run build:web:check && npm run build:claude:check && npm run coverage",
     "eval:notepad": "node scripts/eval-notepad-search.mjs",
     "rewrap:md": "node scripts/rewrap-md.mjs",
     "rewrap:md:check": "node scripts/rewrap-md.mjs --check",

package/src/claude/cli.ts

@@ -0,0 +1,13 @@
+/* v8 ignore start -- process wiring; the bundle smoke test runs it */
+import { main, packageVersion } from "./index";
+
+// The bundle's entry: run `main` against the real process.
+const code = await main(process.argv.slice(2), {
+  stdin: process.stdin,
+  stdout: process.stdout,
+  env: process.env,
+  cwd: process.cwd(),
+  version: packageVersion(),
+});
+process.exitCode = code;
+/* v8 ignore stop */

package/src/claude/control.ts

@@ -0,0 +1,84 @@
+import { createHash } from "node:crypto";
+import { mkdirSync, rmSync } from "node:fs";
+import { createConnection, createServer, type Server } from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+/**
+ * A per-session control socket, so a hook can run a slash command without a
+ * model turn. The MCP process owns the browser workspace, so the hook asks
+ * that process to run the command. The protocol is one JSON line each way:
+ * `{name, args}` in, `{text}` or `{error}` out.
+ */
+
+export type ControlHandler = (name: string, args: string) => Promise<string>;
+
+/** Short on purpose: unix socket paths top out near 104 bytes on macOS. */
+export function controlSocketPath(sessionId: string, tmp = tmpdir(), uid = process.getuid?.() ?? 0): string {
+  return join(tmp, `pw-${uid}`, `${createHash("sha1").update(sessionId).digest("hex").slice(0, 12)}.sock`);
+}
+
+export async function serveControl(path: string, handler: ControlHandler): Promise<{ close(): Promise<void> }> {
+  mkdirSync(join(path, ".."), { recursive: true, mode: 0o700 });
+  // A socket left by a crashed session; a live one is never at this path.
+  rmSync(path, { force: true });
+  const server: Server = createServer((socket) => {
+    let line = "";
+    socket.setEncoding("utf8");
+    socket.on("error", () => {});
+    socket.on("data", async (chunk) => {
+      line += chunk;
+      if (!line.includes("\n")) return;
+      let reply: object;
+      try {
+        const request = JSON.parse(line) as { name?: unknown; args?: unknown };
+        reply = { text: await handler(String(request.name), typeof request.args === "string" ? request.args : "") };
+      } catch (error) {
+        reply = { error: error instanceof Error ? error.message : String(error) };
+      }
+      socket.end(`${JSON.stringify(reply)}\n`);
+    });
+  });
+  await new Promise<void>((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(path, resolve);
+  });
+  return {
+    close: () => new Promise((resolve) => {
+      server.close(() => {
+        rmSync(path, { force: true });
+        resolve();
+      });
+    }),
+  };
+}
+
+/** The command's output, or null when nothing answers (the model can run it). */
+export function callControl(path: string, name: string, args: string, timeoutMs = 15_000): Promise<string | null> {
+  return new Promise((resolve) => {
+    let data = "";
+    const socket = createConnection(path);
+    const finish = (value: string | null) => {
+      socket.destroy();
+      resolve(value);
+    };
+    let connected = false;
+    // Once connected the command is running; falling back to the model would run it twice.
+    socket.setTimeout(timeoutMs, () => finish(connected ? "pi-weave: still working; check /weave for progress." : null));
+    socket.setEncoding("utf8");
+    socket.on("error", () => finish(null));
+    socket.on("connect", () => {
+      connected = true;
+      socket.write(`${JSON.stringify({ name, args })}\n`);
+    });
+    socket.on("data", (chunk) => { data += chunk; });
+    socket.on("end", () => {
+      try {
+        const reply = JSON.parse(data) as { text?: string; error?: string };
+        finish(typeof reply.text === "string" ? reply.text : reply.error ? `pi-weave: ${reply.error}` : null);
+      } catch {
+        finish(null);
+      }
+    });
+  });
+}

package/src/claude/generate.ts

@@ -0,0 +1,62 @@
+import { spawn as nodeSpawn } from "node:child_process";
+import { tmpdir } from "node:os";
+
+/**
+ * Model calls for the shared scans, through headless Claude Code.
+ *
+ * Pi and OpenCode hand the scans their own model API. A Claude Code plugin has
+ * none, so each summary is one `claude -p` run: no tools, no MCP servers, no
+ * saved session, a short system prompt in place of Claude Code's own, and the
+ * user's own login and plan. It runs in the temp directory so no project
+ * CLAUDE.md or project settings ride along.
+ */
+
+/** Set on the child so this plugin's own hooks stay quiet inside it. */
+export const NESTED_ENV = "PI_WEAVE_NESTED";
+
+const SYSTEM_PROMPT = "You write concise summaries for a Markdown knowledge vault. Follow the instructions in the message and answer with the summary only.";
+
+export type SpawnFn = typeof nodeSpawn;
+
+export interface ClaudeGenerateOptions {
+  bin?: string;
+  env?: NodeJS.ProcessEnv;
+  spawn?: SpawnFn;
+}
+
+export function claudeArgs(model: string): string[] {
+  return [
+    "-p",
+    "--model", model,
+    "--system-prompt", SYSTEM_PROMPT,
+    "--tools", "",
+    "--strict-mcp-config",
+    "--no-session-persistence",
+    "--output-format", "text",
+  ];
+}
+
+export function claudeGenerate(options: ClaudeGenerateOptions = {}) {
+  const env = options.env ?? process.env;
+  const bin = options.bin ?? "claude";
+  const spawn = options.spawn ?? nodeSpawn;
+  return (prompt: string, signal: AbortSignal, model: string): Promise<string> => new Promise((resolve, reject) => {
+    const child = spawn(bin, claudeArgs(model), {
+      cwd: tmpdir(),
+      env: { ...env, [NESTED_ENV]: "1" },
+      signal,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout!.setEncoding("utf8").on("data", (chunk: string) => { stdout += chunk; });
+    child.stderr!.setEncoding("utf8").on("data", (chunk: string) => { stderr += chunk; });
+    child.on("error", (error) => reject(signal.aborted ? signal.reason : new Error(`could not run ${bin}: ${error.message}`)));
+    child.on("close", (code) => {
+      if (code === 0) resolve(stdout);
+      else reject(new Error(`${bin} exited with code ${code}${stderr.trim() ? `: ${stderr.trim().slice(-400)}` : ""}`));
+    });
+    child.stdin!.on("error", () => {});
+    child.stdin!.end(prompt);
+  });
+}

package/src/claude/index.ts

@@ -0,0 +1,87 @@
+import { readFileSync } from "node:fs";
+import type { Readable, Writable } from "node:stream";
+import { formatStatusLine, getWorkspaceStatus } from "../core";
+import { NESTED_ENV } from "./generate";
+import { callControl, controlSocketPath, serveControl } from "./control";
+import { serveMcp } from "./mcp";
+import { createClaudeAdapter } from "./server";
+
+/**
+ * Entry point of the Claude Code plugin, bundled to `claude/dist/weave.mjs`.
+ *
+ *   weave.mjs mcp            the MCP server (plugin.json → mcpServers)
+ *   weave.mjs session-start  SessionStart hook: the status line, as context
+ *   weave.mjs prompt-submit  UserPromptSubmit hook: runs /weave commands with no model turn
+ *   weave.mjs statusline     opt-in status-line command
+ *
+ * Hooks and the status line pass a JSON object on stdin; only its working
+ * directory is used.
+ */
+
+export interface MainIo {
+  stdin: Readable;
+  stdout: Writable;
+  env: NodeJS.ProcessEnv;
+  cwd: string;
+  version: string;
+}
+
+async function readJson(stdin: Readable): Promise<Record<string, unknown>> {
+  let text = "";
+  for await (const chunk of stdin) text += String(chunk);
+  try {
+    const value: unknown = JSON.parse(text);
+    return value !== null && typeof value === "object" ? value as Record<string, unknown> : {};
+  } catch {
+    return {};
+  }
+}
+
+function cwdFrom(input: Record<string, unknown>, fallback: string): string {
+  const workspace = input.workspace as Record<string, unknown> | undefined;
+  if (typeof workspace?.current_dir === "string") return workspace.current_dir;
+  return typeof input.cwd === "string" ? input.cwd : fallback;
+}
+
+/** `/weave…` or `/pi-weave:weave…` and its arguments. */
+const PROMPT = /^\/(?:pi-weave:)?(weave(?:-view|-scan-cancel|-scan|-statusline)?)(?:\s+(.*))?$/s;
+
+export async function main(argv: readonly string[], io: MainIo): Promise<number> {
+  const [mode = "mcp"] = argv;
+  if (mode === "mcp") {
+    const adapter = createClaudeAdapter({ env: io.env, cwd: io.env.CLAUDE_PROJECT_DIR ?? io.cwd, version: io.version });
+    const sessionId = io.env.CLAUDE_CODE_SESSION_ID;
+    const control = sessionId ? await serveControl(controlSocketPath(sessionId), adapter.runCommand).catch(() => null) : null;
+    await serveMcp(adapter.server, io.stdin, io.stdout);
+    await control?.close();
+    await adapter.close();
+    return 0;
+  }
+  if (mode === "prompt-submit") {
+    const input = await readJson(io.stdin);
+    const prompt = typeof input.prompt === "string" ? PROMPT.exec(input.prompt.trim()) : null;
+    if (!prompt || io.env[NESTED_ENV] || typeof input.session_id !== "string") return 0;
+    const text = await callControl(controlSocketPath(input.session_id), prompt[1] as string, (prompt[2] ?? "").trim());
+    // Nothing answered: stay silent and the command runs through the model instead.
+    if (text !== null) io.stdout.write(JSON.stringify({ continue: false, stopReason: text }));
+    return 0;
+  }
+  if (mode === "session-start" || mode === "statusline") {
+    const input = await readJson(io.stdin);
+    // Scans run headless Claude Code; its sessions need no pi-weave context.
+    if (mode === "session-start" && io.env[NESTED_ENV]) return 0;
+    const line = formatStatusLine(await getWorkspaceStatus(cwdFrom(input, io.cwd)));
+    io.stdout.write(mode === "session-start" ? `pi-weave: ${line}\n` : `${line}\n`);
+    return 0;
+  }
+  io.stdout.write("usage: weave.mjs [mcp | session-start | prompt-submit | statusline]\n");
+  return 2;
+}
+
+export function packageVersion(): string {
+  try {
+    return (JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8")) as { version: string }).version;
+  } catch {
+    return "0.0.0";
+  }
+}

package/src/claude/mcp.ts

@@ -0,0 +1,105 @@
+import { createInterface } from "node:readline";
+import type { Readable, Writable } from "node:stream";
+
+/**
+ * A minimal Model Context Protocol server over stdio: newline-delimited
+ * JSON-RPC 2.0 with the `tools` capability and nothing else.
+ *
+ * Hand-rolled on purpose. pi-weave keeps runtime dependencies near zero, and
+ * the slice Claude Code needs (initialize, tools/list, tools/call, ping) is a
+ * few dozen lines; the official SDK would add more code than the adapter.
+ */
+
+export interface McpToolResult {
+  text: string;
+  isError?: boolean;
+}
+
+export interface McpTool {
+  name: string;
+  description: string;
+  inputSchema: object;
+  call(args: Record<string, unknown>): Promise<McpToolResult>;
+}
+
+export interface McpServerInfo {
+  name: string;
+  version: string;
+  instructions?: string;
+  tools: readonly McpTool[];
+}
+
+/** Newest first; an unknown requested version is answered with the newest. */
+export const MCP_PROTOCOL_VERSIONS = ["2025-06-18", "2025-03-26", "2024-11-05"] as const;
+
+type Id = string | number | null;
+type Response = { jsonrpc: "2.0"; id: Id; result: unknown } | { jsonrpc: "2.0"; id: Id; error: { code: number; message: string } };
+
+function record(value: unknown): Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {};
+}
+
+const failure = (id: Id, code: number, message: string): Response => ({ jsonrpc: "2.0", id, error: { code, message } });
+
+/** Answer one parsed message; `null` for a notification, which gets no reply. */
+export async function handleMcpMessage(server: McpServerInfo, raw: unknown): Promise<Response | null> {
+  const message = record(raw);
+  const id = typeof message.id === "string" || typeof message.id === "number" ? message.id : null;
+  if (message.jsonrpc !== "2.0" || typeof message.method !== "string") return failure(id, -32600, "Invalid request");
+  if (!("id" in message)) return null;
+  const params = record(message.params);
+  const result = (value: unknown): Response => ({ jsonrpc: "2.0", id, result: value });
+  switch (message.method) {
+    case "initialize": {
+      const requested = params.protocolVersion;
+      const protocolVersion = MCP_PROTOCOL_VERSIONS.find((version) => version === requested) ?? MCP_PROTOCOL_VERSIONS[0];
+      return result({
+        protocolVersion,
+        capabilities: { tools: {} },
+        serverInfo: { name: server.name, version: server.version },
+        ...(server.instructions ? { instructions: server.instructions } : {}),
+      });
+    }
+    case "ping":
+      return result({});
+    case "tools/list":
+      return result({ tools: // alwaysLoad keeps the tools out of Claude Code's deferred tool search: a
+      // slash command would otherwise spend a model round trip finding them.
+      server.tools.map(({ name, description, inputSchema }) => ({ name, description, inputSchema, _meta: { "anthropic/alwaysLoad": true } })) });
+    case "tools/call": {
+      const tool = server.tools.find((candidate) => candidate.name === params.name);
+      if (!tool) return failure(id, -32602, `Unknown tool: ${String(params.name)}`);
+      try {
+        const output = await tool.call(record(params.arguments));
+        return result({ content: [{ type: "text", text: output.text }], isError: output.isError === true });
+      } catch (error) {
+        // A failed tool is a result the model should read, not a protocol error.
+        return result({ content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }], isError: true });
+      }
+    }
+    default:
+      return failure(id, -32601, `Method not found: ${message.method}`);
+  }
+}
+
+/** Serve until `input` closes. Requests are answered as they finish, not in order. */
+export async function serveMcp(server: McpServerInfo, input: Readable, output: Writable): Promise<void> {
+  const pending = new Set<Promise<void>>();
+  const write = (response: Response | null) => {
+    if (response) output.write(`${JSON.stringify(response)}\n`);
+  };
+  for await (const line of createInterface({ input, crlfDelay: Infinity })) {
+    if (!line.trim()) continue;
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      write(failure(null, -32700, "Parse error"));
+      continue;
+    }
+    const task = handleMcpMessage(server, parsed).then(write);
+    pending.add(task);
+    void task.finally(() => pending.delete(task));
+  }
+  await Promise.all(pending);
+}

package/src/claude/server.ts

@@ -0,0 +1,154 @@
+import { spawn as nodeSpawn } from "node:child_process";
+import { formatDashboard, getWorkspaceStatus } from "../core";
+import { weaveTools } from "../core/tools";
+import { createWorkspaceCommands } from "../core/workspaceCommands";
+import { browserOpenCommand, WorkspaceServerController } from "../web/server/controller";
+import { claudeGenerate, type SpawnFn } from "./generate";
+import type { McpServerInfo, McpTool } from "./mcp";
+import { claudeConfigDir, findTranscript, readClaudeTranscript, transcriptSessionId } from "./sessions";
+
+/**
+ * The Claude Code adapter: the shared tools and the shared workspace
+ * commands, served as MCP tools from one process per Claude Code session.
+ *
+ * The browser workspace lives in this same process, so the recall trail and
+ * the agent's graph spotlight see every `weave_note` call, exactly as in Pi.
+ * Claude Code has no turn event for MCP servers, so turns fall back to the
+ * trail's time gap, as in OpenCode.
+ */
+
+/** The model scans use unless `PI_WEAVE_CLAUDE_MODEL` names another. */
+export const DEFAULT_SCAN_MODEL = "haiku";
+const MODEL_PREFIX = "claude-code/";
+
+export const INSTRUCTIONS = [
+  "pi-weave is the user's local Markdown memory vault, shared with Pi and OpenCode.",
+  "Save the user's notes, decisions and dictation with weave_note, and search it before answering questions about past work.",
+  "Leave CLAUDE.md for project instructions; durable knowledge belongs in the vault.",
+].join(" ");
+
+export const COMMANDS = ["weave", "weave-view", "weave-scan", "weave-scan-cancel", "weave-statusline"] as const;
+
+export interface ClaudeAdapterOptions {
+  env?: NodeJS.ProcessEnv;
+  cwd?: string;
+  home?: string;
+  /** Path of the running script, for the status-line snippet. */
+  script?: string;
+  version?: string;
+  spawn?: SpawnFn;
+  viewer?: WorkspaceServerController;
+}
+
+function statusLineSnippet(script: string): string {
+  const command = `node ${JSON.stringify(script)} statusline`;
+  return [
+    "Add this to ~/.claude/settings.json to show pi-weave in your status line:",
+    "",
+    JSON.stringify({ statusLine: { type: "command", command } }, null, 2),
+  ].join("\n");
+}
+
+export function createClaudeAdapter(options: ClaudeAdapterOptions = {}) {
+  const env = options.env ?? process.env;
+  const cwd = options.cwd ?? env.CLAUDE_PROJECT_DIR ?? process.cwd();
+  const spawn = options.spawn ?? nodeSpawn;
+  const viewer = options.viewer ?? new WorkspaceServerController();
+  const generate = claudeGenerate({ env, spawn, ...(env.PI_WEAVE_CLAUDE_BIN ? { bin: env.PI_WEAVE_CLAUDE_BIN } : {}) });
+  const configDir = claudeConfigDir(env, options.home);
+  const transcript = () => findTranscript(cwd, env.CLAUDE_CODE_SESSION_ID, configDir);
+
+  let collecting: string[] | null = null;
+  let scan: { text: string; active: boolean } | null = null;
+  const shared = createWorkspaceCommands({
+    async getSession() {
+      const path = await transcript();
+      return {
+        id: path ? transcriptSessionId(path) : env.CLAUDE_CODE_SESSION_ID ?? "claude-code",
+        cwd,
+        model: `${MODEL_PREFIX}${env.PI_WEAVE_CLAUDE_MODEL || DEFAULT_SCAN_MODEL}`,
+      };
+    },
+    async getDigest() {
+      const path = await transcript();
+      if (!path) throw new Error("no Claude Code transcript found for this project");
+      return readClaudeTranscript(path);
+    },
+    sessionSource: (id) => `claude-code:session:${id}`,
+    generate: (_id, prompt, signal, model) => generate(prompt, signal, model.slice(MODEL_PREFIX.length)),
+    // While a command runs its output is its tool result; a background scan's
+    // final word arrives later and is kept by the status below instead.
+    async output(_id, text) {
+      collecting?.push(text);
+    },
+  }, (status) => {
+    scan = { text: status.text, active: status.active };
+  }, viewer, ({ url, open }) => {
+    // Over SSH the browser would open on the wrong machine, if at all.
+    if (!open || env.SSH_CONNECTION) return;
+    const { command, args } = browserOpenCommand(url);
+    try {
+      spawn(command, args, { detached: true, stdio: "ignore" }).on("error", () => {}).unref();
+    } catch {
+      // No opener on this machine; the URL is in the tool result.
+    }
+  });
+
+  async function runCommand(name: string, args: string): Promise<string> {
+    if (name === "weave-statusline") return statusLineSnippet(options.script ?? process.argv[1] ?? "weave.mjs");
+    if (name === "weave") {
+      const dashboard = formatDashboard(await getWorkspaceStatus(cwd));
+      return scan ? `${dashboard}\n\n${scan.active ? "Scan running" : "Last scan"}: ${scan.text}` : dashboard;
+    }
+    const command = shared.commands.find((candidate) => candidate.name === name);
+    if (!command) throw new Error(`Unknown pi-weave command: ${name}`);
+    const lines: string[] = [];
+    collecting = lines;
+    try {
+      await command.execute("claude-code", args);
+    } finally {
+      collecting = null;
+    }
+    // The hook shows this line as-is, so keep just the URL.
+    const text = lines.join("\n").replace(/^pi-weave: workspace (?:already )?running at (\S+) — .*$/m, "pi-weave: workspace at $1");
+    return text || "pi-weave: scan started in the background. Run /weave to see its progress.";
+  }
+
+  const tools: McpTool[] = [
+    ...weaveTools.map((tool): McpTool => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.input,
+      async call(args) {
+        return { text: (await tool.execute(args, cwd)).text };
+      },
+    })),
+    {
+      name: "weave_command",
+      description: "Run a pi-weave slash command (/weave, /weave-view, /weave-scan, /weave-scan-cancel, /weave-statusline) and return its output. Only call this when the user ran one of those commands.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          command: { type: "string", enum: [...COMMANDS] },
+          args: { type: "string", description: "The command's arguments, exactly as the user typed them" },
+        },
+        required: ["command"],
+        additionalProperties: false,
+      },
+      async call(args) {
+        return { text: await runCommand(String(args.command), typeof args.args === "string" ? args.args : "") };
+      },
+    },
+  ];
+
+  const server: McpServerInfo = { name: "pi-weave", version: options.version ?? "0.0.0", instructions: INSTRUCTIONS, tools };
+  return {
+    server,
+    /** Run a slash command directly, as the hook does when it answers without the model. */
+    runCommand,
+    async close() {
+      await shared.cleanup();
+      await viewer.close();
+    },
+  };
+}