pi-weave 0.3.13 → 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.13",
-  "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();
+    },
+  };
+}

package/src/claude/sessions.ts

@@ -0,0 +1,158 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+import { hashContent, type SessionDigest } from "../core";
+import { digestFromMessages } from "../core/sessionDigest";
+
+/**
+ * Claude Code's own transcripts, mapped onto the shared session digest.
+ *
+ * Claude Code writes one JSONL file per session under
+ * `<config dir>/projects/<cwd with every non-alphanumeric as "-">/<session id>.jsonl`,
+ * where the config dir is `CLAUDE_CONFIG_DIR` or `~/.claude`.
+ * Each assistant content block is its own line; lines of one reply share
+ * `message.id`. Tool results come back as user lines holding `tool_result`
+ * blocks, and slash commands and `!` shell runs are user lines wrapped in
+ * tags. Everything else (attachments, titles, bookkeeping) is skipped.
+ */
+
+export function claudeConfigDir(env: NodeJS.ProcessEnv = process.env, home: string = homedir()): string {
+  return env.CLAUDE_CONFIG_DIR || join(home, ".claude");
+}
+
+export function claudeProjectDir(cwd: string, configDir: string = claudeConfigDir()): string {
+  return join(configDir, "projects", cwd.replace(/[^a-zA-Z0-9]/g, "-"));
+}
+
+/** The session's transcript, or this project's most recently written one. */
+export async function findTranscript(cwd: string, sessionId: string | undefined, configDir: string = claudeConfigDir()): Promise<string | null> {
+  const dir = claudeProjectDir(cwd, configDir);
+  if (sessionId) {
+    const path = join(dir, `${sessionId}.jsonl`);
+    if (await stat(path).then((info) => info.isFile(), () => false)) return path;
+  }
+  const names = await readdir(dir).catch(() => [] as string[]);
+  let newest: { path: string; mtime: number } | null = null;
+  for (const name of names) {
+    if (!name.endsWith(".jsonl")) continue;
+    const path = join(dir, name);
+    const info = await stat(path).catch(() => null);
+    if (info?.isFile() && (!newest || info.mtimeMs > newest.mtime)) newest = { path, mtime: info.mtimeMs };
+  }
+  return newest?.path ?? null;
+}
+
+export function transcriptSessionId(path: string): string {
+  return basename(path, ".jsonl");
+}
+
+function record(value: unknown): Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {};
+}
+
+function blocks(content: unknown): Record<string, unknown>[] {
+  return Array.isArray(content) ? content.map(record) : [];
+}
+
+function textOf(content: unknown): string {
+  if (typeof content === "string") return content;
+  return blocks(content).filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text as string).join("\n");
+}
+
+const tag = (text: string, name: string) => new RegExp(`<${name}>([\\s\\S]*?)</${name}>`).exec(text)?.[1]?.trim();
+
+/** A user line as the digest should see it: a prompt, a slash command, a shell run, or nothing. */
+function userMessage(text: string): Record<string, unknown> | null {
+  if (!text.trim()) return null;
+  if (text.includes("<bash-input>")) return { type: "shell" };
+  const command = tag(text, "command-name");
+  if (command) return { type: "user", text: [command, tag(text, "command-args")].filter(Boolean).join(" ") };
+  // Command echoes and shell output are the harness talking, not the user.
+  if (/^\s*<(local-command-|bash-std|command-message)/.test(text)) return null;
+  return { type: "user", text };
+}
+
+export interface ClaudeTranscript {
+  digest: SessionDigest;
+  /** Changes only when the conversation does, so an unchanged session is not re-summarized. */
+  hash: string;
+}
+
+export function parseClaudeTranscript(text: string, fallbackId = ""): ClaudeTranscript {
+  const entries: Record<string, unknown>[] = [];
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      entries.push(record(JSON.parse(line)));
+    } catch {
+      // A line cut off mid-write is expected while the session is live.
+    }
+  }
+  const failedTools = new Set<string>();
+  for (const entry of entries) {
+    for (const block of blocks(record(entry.message).content)) {
+      if (block.type === "tool_result" && block.is_error === true && typeof block.tool_use_id === "string") failedTools.add(block.tool_use_id);
+    }
+  }
+
+  let id = "";
+  let cwd = "";
+  let startedAt = "";
+  let endedAt = "";
+  let aiTitle: string | null = null;
+  let customTitle: string | null = null;
+  const messages: Record<string, unknown>[] = [];
+  const replies = new Map<string, Record<string, unknown>>();
+  for (const entry of entries) {
+    if (typeof entry.aiTitle === "string" && entry.aiTitle.trim()) aiTitle = entry.aiTitle.trim();
+    if (typeof entry.customTitle === "string" && entry.customTitle.trim()) customTitle = entry.customTitle.trim();
+    if (entry.type !== "user" && entry.type !== "assistant") continue;
+    if (entry.isSidechain === true) continue;
+    id ||= typeof entry.sessionId === "string" ? entry.sessionId : "";
+    cwd ||= typeof entry.cwd === "string" ? entry.cwd : "";
+    if (typeof entry.timestamp === "string") {
+      startedAt ||= entry.timestamp;
+      endedAt = entry.timestamp;
+    }
+    const message = record(entry.message);
+    if (entry.type === "user") {
+      if (entry.isMeta === true) continue;
+      const text = textOf(message.content);
+      if (entry.isCompactSummary === true) {
+        messages.push({ type: "compaction", summary: text });
+        continue;
+      }
+      const mapped = userMessage(text);
+      if (mapped) messages.push(mapped);
+      continue;
+    }
+    const key = typeof message.id === "string" ? message.id : `line-${messages.length}`;
+    let reply = replies.get(key);
+    if (!reply) {
+      const model = typeof message.model === "string" && message.model !== "<synthetic>" ? { providerID: "anthropic", id: message.model } : {};
+      reply = { type: "assistant", model, error: entry.isApiErrorMessage === true, content: [] };
+      replies.set(key, reply);
+      messages.push(reply);
+    }
+    const content = reply.content as Record<string, unknown>[];
+    for (const block of blocks(message.content)) {
+      if (block.type === "text") content.push({ type: "text", text: block.text });
+      if (block.type === "tool_use") {
+        content.push({ type: "tool", name: block.name, state: { status: failedTools.has(String(block.id)) ? "error" : "completed" } });
+      }
+    }
+  }
+  const digest = digestFromMessages({
+    id: id || fallbackId,
+    cwd,
+    parentSession: null,
+    startedAt,
+    endedAt: endedAt || startedAt,
+    name: customTitle ?? aiTitle,
+  }, messages);
+  return { digest, hash: hashContent(JSON.stringify(messages)) };
+}
+
+export async function readClaudeTranscript(path: string): Promise<ClaudeTranscript> {
+  return parseClaudeTranscript(await readFile(path, "utf8"), transcriptSessionId(path));
+}

package/src/core/sessionDigest.ts

@@ -0,0 +1,103 @@
+import type { SessionDigest } from "./sessions";
+
+/**
+ * One harness-neutral way to build a {@link SessionDigest}.
+ *
+ * Pi sessions are parsed from their own JSONL by `parseSessionDigest`. Every
+ * other harness (OpenCode's session API, Claude Code's transcripts) maps its
+ * records onto the small message shape below and lets this function do the
+ * counting, clipping and capping, so the digests stay identical in form.
+ *
+ * Messages are `unknown` on purpose: records come from outside the process,
+ * and anything malformed is skipped rather than trusted.
+ *
+ * - `{ type: "user", text }`
+ * - `{ type: "shell" }` — a direct shell execution by the user
+ * - `{ type: "compaction", summary }`
+ * - `{ type: "assistant", model: { providerID, id }, finish?, error?, content: [{ type: "text", text } | { type: "tool", name, state: { status } }] }`
+ */
+export interface DigestSessionInfo {
+  id: string;
+  cwd: string;
+  parentSession: string | null;
+  startedAt: string;
+  endedAt: string;
+  name: string | null;
+}
+
+function record(value: unknown): Record<string, unknown> {
+  return value !== null && typeof value === "object" ? value as Record<string, unknown> : {};
+}
+
+function clipped(value: unknown, max: number): string {
+  if (typeof value !== "string") return "";
+  const text = value.trim();
+  return text.length > max ? `${text.slice(0, max - 1).trimEnd()}…` : text;
+}
+
+export function digestFromMessages(info: DigestSessionInfo, messages: readonly unknown[]): SessionDigest {
+  const digest: SessionDigest = {
+    ...info,
+    models: [],
+    userCount: 0,
+    assistantCount: 0,
+    toolResultCount: 0,
+    errors: 0,
+    bashCount: 0,
+    tools: {},
+    firstUserMessage: null,
+    userMessages: [],
+    compactions: [],
+    branchSummaries: [],
+    lastAssistantText: null,
+  };
+  for (const raw of messages) {
+    const message = record(raw);
+    if (message.type === "user") {
+      digest.userCount += 1;
+      const text = clipped(message.text, 400);
+      if (text) {
+        digest.userMessages.push(text);
+        if (digest.userMessages.length > 60) digest.userMessages.shift();
+        digest.firstUserMessage ??= clipped(text, 120);
+      }
+      continue;
+    }
+    if (message.type === "shell") {
+      digest.bashCount += 1;
+      continue;
+    }
+    if (message.type === "compaction") {
+      const summary = clipped(message.summary, 1_200);
+      if (summary) {
+        digest.compactions.push(summary);
+        if (digest.compactions.length > 3) digest.compactions.shift();
+      }
+      continue;
+    }
+    if (message.type !== "assistant") continue;
+    digest.assistantCount += 1;
+    const model = record(message.model);
+    if (typeof model.providerID === "string" && typeof model.id === "string") {
+      const label = `${model.providerID}/${model.id}`;
+      if (!digest.models.includes(label)) digest.models.push(label);
+    }
+    if (message.finish === "error" || message.error) digest.errors += 1;
+    const content = Array.isArray(message.content) ? message.content : [];
+    const text = content
+      .filter((part) => record(part).type === "text")
+      .map((part) => record(part).text)
+      .filter((part): part is string => typeof part === "string")
+      .join("\n");
+    if (text.trim()) digest.lastAssistantText = clipped(text, 1_200);
+    for (const part of content) {
+      const tool = record(part);
+      if (tool.type !== "tool") continue;
+      digest.toolResultCount += 1;
+      const name = typeof tool.name === "string" ? tool.name : "unknown";
+      digest.tools[name] = (digest.tools[name] ?? 0) + 1;
+      if (record(tool.state).status === "error") digest.errors += 1;
+    }
+  }
+  return digest;
+}

package/src/core/tools.ts

@@ -0,0 +1,63 @@
+import { executeNoteAction, WEAVE_NOTE_DESCRIPTION, type NoteActionInput, type NoteActionResult } from "./noteAction";
+import { executeRepoAction, WEAVE_REPO_DESCRIPTION, type RepoActionInput } from "./repoAction";
+
+/**
+ * The `weave_note` and `weave_repo` tools, defined once for every harness.
+ *
+ * Plain JSON Schema, because that is the one format Pi, OpenCode and MCP
+ * (Claude Code) all accept. Each adapter only maps these definitions onto its
+ * own registration call and adds what is genuinely harness-specific, such as
+ * Pi's prompt guidelines.
+ */
+
+const noteInput = {
+  type: "object",
+  properties: {
+    action: { type: "string", enum: ["list", "get", "add", "append", "finalize", "search", "links", "suggest"] },
+    title: { type: "string", description: "Note title (add)" },
+    text: { type: "string", description: "Markdown body (add), addition (append), or restructured body above the raw tail (finalize)" },
+    tags: { type: "array", items: { type: "string" }, description: "Tags (add)" },
+    slug: { type: "string", description: "Note slug (get, append, finalize)" },
+    raw: {
+      type: "boolean",
+      description: "add/append: keep text as verbatim dictation in the ## Raw tail (timestamped fenced block; tail created if missing). Use for the user's own words, including the first words of a dictated note; omit for structured Markdown",
+    },
+    source: {
+      type: "string",
+      enum: ["human", "agent"],
+      description: "Provenance (add): human for user-scribbled notes, agent for agent-drafted (default agent)",
+    },
+    query: { type: "string", description: "Search query (search)" },
+    fix: { type: "boolean", description: "links: apply the unambiguous repairs. Omit for a read-only report" },
+    limit: { type: "number", description: "suggest: how many suggestions to return (default 20)" },
+  },
+  required: ["action"],
+  additionalProperties: false,
+} as const;
+
+const repoInput = {
+  type: "object",
+  properties: {
+    action: { type: "string", enum: ["overview"] },
+  },
+  required: ["action"],
+  additionalProperties: false,
+} as const;
+
+export const weaveTools = [
+  {
+    name: "weave_note",
+    description: WEAVE_NOTE_DESCRIPTION,
+    input: noteInput,
+    execute: (input: unknown, _cwd: string, _progress?: (text: string) => Promise<void>): Promise<NoteActionResult> =>
+      executeNoteAction(input as NoteActionInput),
+  },
+  {
+    name: "weave_repo",
+    description: WEAVE_REPO_DESCRIPTION,
+    input: repoInput,
+    execute: (input: unknown, cwd: string, _progress?: (text: string) => Promise<void>) => executeRepoAction(input as RepoActionInput, cwd),
+  },
+];
+
+export type WeaveTool = (typeof weaveTools)[number];

package/src/opencode/commands.ts

@@ -1,5 +1,5 @@
-import { hashContent } from "../core";
-import type { SessionDigest } from "../core";
+import { hashContent, type SessionDigest } from "../core";
+import { digestFromMessages } from "../core/sessionDigest";
 import { createWorkspaceCommands, type WorkspaceScanStatus } from "../core/workspaceCommands";
 import type { WorkspaceServerController } from "../web/server/controller";
 
@@ -15,86 +15,19 @@ function timestamp(value: unknown): string {
   return typeof value === "number" && Number.isFinite(value) ? new Date(value).toISOString() : "";
 }
 
-function clipped(value: unknown, max: number): string {
-  if (typeof value !== "string") return "";
-  const text = value.trim();
-  return text.length > max ? `${text.slice(0, max - 1).trimEnd()}…` : text;
-}
-
 /** Convert OpenCode's public session context to the portable session digest. */
 export function openCodeSessionDigest(session: unknown, messages: readonly unknown[]): SessionDigest {
   const info = record(session);
   const time = record(info.time);
   const location = record(info.location);
-  const relevant = messages.filter((message) => ["user", "assistant", "compaction", "shell"].includes(String(record(message).type)));
-  const digest: SessionDigest = {
+  return digestFromMessages({
     id: String(info.id ?? ""),
     cwd: typeof location.directory === "string" ? location.directory : "",
     parentSession: typeof info.parentID === "string" ? info.parentID : null,
     startedAt: timestamp(time.created),
     endedAt: timestamp(time.updated),
     name: typeof info.title === "string" && info.title.trim() ? info.title.trim() : null,
-    models: [],
-    userCount: 0,
-    assistantCount: 0,
-    toolResultCount: 0,
-    errors: 0,
-    bashCount: 0,
-    tools: {},
-    firstUserMessage: null,
-    userMessages: [],
-    compactions: [],
-    branchSummaries: [],
-    lastAssistantText: null,
-  };
-  for (const raw of relevant) {
-    const message = record(raw);
-    if (message.type === "user") {
-      digest.userCount += 1;
-      const text = clipped(message.text, 400);
-      if (text) {
-        digest.userMessages.push(text);
-        if (digest.userMessages.length > 60) digest.userMessages.shift();
-        digest.firstUserMessage ??= clipped(text, 120);
-      }
-      continue;
-    }
-    if (message.type === "shell") {
-      digest.bashCount += 1;
-      continue;
-    }
-    if (message.type === "compaction") {
-      const summary = clipped(message.summary, 1_200);
-      if (summary) {
-        digest.compactions.push(summary);
-        if (digest.compactions.length > 3) digest.compactions.shift();
-      }
-      continue;
-    }
-    digest.assistantCount += 1;
-    const model = record(message.model);
-    if (typeof model.providerID === "string" && typeof model.id === "string") {
-      const label = `${model.providerID}/${model.id}`;
-      if (!digest.models.includes(label)) digest.models.push(label);
-    }
-    if (message.finish === "error" || message.error) digest.errors += 1;
-    const content = Array.isArray(message.content) ? message.content : [];
-    const text = content
-      .filter((part) => record(part).type === "text")
-      .map((part) => record(part).text)
-      .filter((part): part is string => typeof part === "string")
-      .join("\n");
-    if (text.trim()) digest.lastAssistantText = clipped(text, 1_200);
-    for (const part of content) {
-      const tool = record(part);
-      if (tool.type !== "tool") continue;
-      digest.toolResultCount += 1;
-      const name = typeof tool.name === "string" ? tool.name : "unknown";
-      digest.tools[name] = (digest.tools[name] ?? 0) + 1;
-      if (record(tool.state).status === "error") digest.errors += 1;
-    }
-  }
-  return digest;
+  }, messages);
 }
 
 export async function registerOpenCodeCommands(

package/src/opencode/index.ts

@@ -3,7 +3,7 @@ import { fileURLToPath } from "node:url";
 import { formatStatusLine, getWorkspaceStatus } from "../core";
 import { parseFrontMatter, unquoteField } from "../core/frontmatter";
 import { registerOpenCodeCommands } from "./commands";
-import { weaveTools } from "./tools";
+import { weaveTools } from "../core/tools";
 import { WEAVE_RPC } from "./rpc";
 import { WorkspaceServerController } from "../web/server/controller";
 

package/src/opencode/v1.ts

@@ -6,7 +6,7 @@ import { hashContent } from "../core";
 import { createWorkspaceCommands } from "../core/workspaceCommands";
 import { WorkspaceServerController } from "../web/server/controller";
 import { openCodeSessionDigest } from "./commands";
-import { weaveTools } from "./tools";
+import { weaveTools } from "../core/tools";
 
 type Client = Parameters<Plugin>[0]["client"];
 type CommandResult = { lines: string[]; viewer?: { url: string; open: boolean } };

package/src/pi/tools/noteTool.ts

@@ -1,18 +1,16 @@
-import { StringEnum } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-import {
-  executeNoteAction,
-  formatRawAppend,
-  WEAVE_NOTE_DESCRIPTION,
-} from "../../core";
+import { formatRawAppend } from "../../core";
+import { weaveTools } from "../../core/tools";
+import { piParameters } from "./parameters";
+
+const tool = weaveTools.find((definition) => definition.name === "weave_note")!;
 
 /** `weave_note` — the smart-notepad tool (design §1: vault knowledge). */
 export function registerNoteTool(pi: ExtensionAPI): void {
   pi.registerTool({
-    name: "weave_note",
+    name: tool.name,
     label: "Weave Note",
-    description: WEAVE_NOTE_DESCRIPTION,
+    description: tool.description,
     promptSnippet: "Remember and retrieve durable knowledge in the pi-weave vault",
     promptGuidelines: [
       "Use weave_note to store durable knowledge (decisions, preferences, key facts) that should survive the session, marking source as agent-written knowledge.",
@@ -20,20 +18,10 @@ export function registerNoteTool(pi: ExtensionAPI): void {
       "Use weave_note with action=links to find and repair stale [[wiki-links]] deterministically instead of rereading the vault to reconnect notes by hand; add fix=true to apply the unambiguous repairs.",
       "Use weave_note with action=suggest to discover notes that belong together but are not linked (optionally scoped to one slug); it only reports — propose the links to the user rather than writing them.",
     ],
-    parameters: Type.Object({
-      action: StringEnum(["list", "get", "add", "append", "finalize", "search", "links", "suggest"] as const),
-      title: Type.Optional(Type.String({ description: "Note title (add)" })),
-      text: Type.Optional(Type.String({ description: "Markdown body (add), addition (append), or restructured body above the raw tail (finalize)" })),
-      tags: Type.Optional(Type.Array(Type.String(), { description: "Tags (add)" })),
-      slug: Type.Optional(Type.String({ description: "Note slug (get, append, finalize)" })),
-      raw: Type.Optional(Type.Boolean({ description: "add/append: keep text as verbatim dictation in the ## Raw tail (timestamped fenced block; tail created if missing). Use for the user's own words, including the first words of a dictated note; omit for structured Markdown" })),
-      source: Type.Optional(StringEnum(["human", "agent"] as const, { description: "Provenance (add): human for user-scribbled notes, agent for Pi-drafted (default agent)" })),
-      query: Type.Optional(Type.String({ description: "Search query (search)" })),
-      fix: Type.Optional(Type.Boolean({ description: "links: apply the unambiguous repairs. Omit for a read-only report" })),
-      limit: Type.Optional(Type.Number({ description: "suggest: how many suggestions to return (default 20)" })),
-    }),
+    parameters: piParameters(tool.input),
     async execute(_toolCallId, params) {
-      const result = await executeNoteAction(params);
+      // The vault is global, so weave_note ignores the working directory.
+      const result = await tool.execute(params, "");
       return { content: [{ type: "text", text: result.text }], details: result.details };
     },
   });

package/src/pi/tools/parameters.ts

@@ -0,0 +1,10 @@
+import type { TSchema } from "typebox";
+
+/**
+ * Pi accepts plain JSON Schema for tool parameters: its validator coerces and
+ * checks schemas that carry no TypeBox kind. The shared definitions in
+ * `src/core/tools.ts` are plain JSON Schema, so they only need the type.
+ */
+export function piParameters(schema: object): TSchema {
+  return structuredClone(schema) as TSchema;
+}

package/src/pi/tools/repoTool.ts

@@ -1,23 +1,22 @@
-import { StringEnum } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-import { executeRepoAction, WEAVE_REPO_DESCRIPTION } from "../../core";
+import { weaveTools } from "../../core/tools";
+import { piParameters } from "./parameters";
+
+const tool = weaveTools.find((definition) => definition.name === "weave_repo")!;
 
 /** `weave_repo` — the repository-exploration tool (design §2/§8). */
 export function registerRepoTool(pi: ExtensionAPI): void {
   pi.registerTool({
-    name: "weave_repo",
+    name: tool.name,
     label: "Weave Repo",
-    description: WEAVE_REPO_DESCRIPTION,
+    description: tool.description,
     promptSnippet: "Explore the repository's structure via its .okf knowledge index",
     promptGuidelines: [
       "Use weave_repo action=overview to learn repository structure before broad code exploration instead of scanning files one by one.",
     ],
-    parameters: Type.Object({
-      action: StringEnum(["overview"] as const),
-    }),
+    parameters: piParameters(tool.input),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      const result = await executeRepoAction(params, ctx.cwd);
+      const result = await tool.execute(params, ctx.cwd);
       return { content: [{ type: "text", text: result.text }], details: result.details };
     },
   });

package/src/opencode/tools.ts

@@ -1,43 +0,0 @@
-import { executeNoteAction, executeRepoAction, WEAVE_NOTE_DESCRIPTION, WEAVE_REPO_DESCRIPTION, type NoteActionInput, type RepoActionInput } from "../core";
-
-const noteInput = {
-  type: "object",
-  properties: {
-    action: { type: "string", enum: ["list", "get", "add", "append", "finalize", "search", "links", "suggest"] },
-    title: { type: "string", description: "Note title (add)" },
-    text: { type: "string", description: "Markdown body (add), addition (append), or restructured body (finalize)" },
-    tags: { type: "array", items: { type: "string" }, description: "Tags (add)" },
-    slug: { type: "string", description: "Note slug (get, append, finalize)" },
-    raw: { type: "boolean", description: "add/append: preserve text verbatim in the ## Raw tail (use for the user's own words)" },
-    source: { type: "string", enum: ["human", "agent"], description: "Provenance (add; defaults to agent)" },
-    query: { type: "string", description: "Search query (search)" },
-    fix: { type: "boolean", description: "links: apply unambiguous repairs" },
-    limit: { type: "number", description: "suggest: maximum suggestions (default 20)" },
-  },
-  required: ["action"],
-  additionalProperties: false,
-} as const;
-
-const repoInput = {
-  type: "object",
-  properties: {
-    action: { type: "string", enum: ["overview"] },
-  },
-  required: ["action"],
-  additionalProperties: false,
-} as const;
-
-export const weaveTools = [
-  {
-    name: "weave_note",
-    description: WEAVE_NOTE_DESCRIPTION,
-    input: noteInput,
-    execute: (input: unknown, _cwd: string, _progress?: (text: string) => Promise<void>) => executeNoteAction(input as NoteActionInput),
-  },
-  {
-    name: "weave_repo",
-    description: WEAVE_REPO_DESCRIPTION,
-    input: repoInput,
-    execute: (input: unknown, cwd: string) => executeRepoAction(input as RepoActionInput, cwd),
-  },
-];