pi-weave 0.2.4 → 0.3.1

package/src/core/sessions.ts

@@ -48,6 +48,15 @@ export const SESSION_SCAN_MAX_SESSIONS = 100;
 export const SESSION_SCAN_MAX_FILE_BYTES = 16 * 1024 * 1024;
 export const SESSION_SCAN_CONCURRENCY = 2;
 
+export const SESSION_SCAN_SYSTEM_PROMPT = [
+  "You write durable memory notes that compact coding-agent sessions into their bottom line.",
+  "First summarize what happened, what shipped (features, files, commands, decisions), and",
+  "what went less well (dead ends, breakage, unfinished work) using concrete technical details.",
+  "Then add a '## Takeaways' section with 2–4 reusable lessons: gotchas, root causes of tricky",
+  "failures, non-obvious syntax rules, or architecture patterns a future agent can apply.",
+  "Past tense. No preamble or code fences. Omit lessons unsupported by the transcript.",
+].join("\n");
+
 const DIGEST_MAX_CHARS = 12_000;
 const USER_MSG_MAX_CHARS = 400;
 const MAX_USER_MESSAGES = 60;
@@ -810,6 +819,76 @@ export interface SessionScanResult {
   failed: SessionScanFailure[];
 }
 
+export function formatSessionScanResult(result: SessionScanResult): string {
+  const parts = [
+    `${result.written} summarized (${result.created} new, ${result.updated} updated)`,
+    `${result.skippedFresh} unchanged`,
+  ];
+  if (result.skippedEmpty > 0) parts.push(`${result.skippedEmpty} empty`);
+  if (result.skippedTooBig > 0) parts.push(`${result.skippedTooBig} skipped (size)`);
+  if (result.skippedUnreadable > 0) parts.push(`${result.skippedUnreadable} unreadable`);
+  let text = `${parts.join(", ")} — ${result.considered} sessions considered`;
+  const first = result.failed[0];
+  if (first) text += `; ${result.failed.length} failed, first: ${first.path}: ${first.error}`;
+  return text;
+}
+
+export interface SessionDigestScanOptions {
+  vaultRoot: string;
+  digest: SessionDigest;
+  content: string;
+  source: string;
+  hash: string;
+  summarize: SummarizeFn;
+  model?: string;
+  now?: () => Date;
+}
+
+/** Summarize one in-memory public session without reading a harness database. */
+export async function runSessionDigestScan(options: SessionDigestScanOptions): Promise<SessionScanResult> {
+  const result: SessionScanResult = {
+    discovered: 1,
+    considered: 1,
+    written: 0,
+    created: 0,
+    updated: 0,
+    skippedFresh: 0,
+    skippedEmpty: 0,
+    skippedTooBig: 0,
+    skippedUnreadable: 0,
+    migrated: await migrateLegacySessionNotes(options.vaultRoot),
+    failed: [],
+  };
+  const pointer = (await readSessionNoteIndex(options.vaultRoot)).get(options.digest.id);
+  if (pointer?.hash === options.hash) {
+    result.skippedFresh = 1;
+    return result;
+  }
+  if (!sessionHasContent(options.digest)) {
+    result.skippedEmpty = 1;
+    return result;
+  }
+  try {
+    const summary = (await options.summarize({ path: options.source, content: options.content })).trim();
+    if (summary.length === 0) throw new Error("model returned an empty summary");
+    await writeSessionNote(options.vaultRoot, {
+      digest: options.digest,
+      file: { path: options.source },
+      hash: options.hash,
+      summary,
+      model: options.model ?? null,
+      at: (options.now ?? (() => new Date()))().toISOString(),
+      existingSlug: pointer?.slug ?? null,
+    });
+    result.written = 1;
+    if (pointer) result.updated = 1;
+    else result.created = 1;
+  } catch (error) {
+    result.failed.push({ path: options.source, error: error instanceof Error ? error.message : String(error) });
+  }
+  return result;
+}
+
 /**
  * Run the session scan, in three phases:
  *
@@ -960,4 +1039,4 @@ export async function runSessionScan(options: SessionScanOptions): Promise<Sessi
   }, aborted);
 
   return result;
-}
+}

package/src/core/summaries.ts

@@ -24,6 +24,12 @@ export const DEEP_SCAN_MAX_FILES = 300;
 export const DEEP_SCAN_MAX_FILE_BYTES = 32_768;
 export const DEEP_SCAN_CONCURRENCY = 4;
 
+export const DEEP_SCAN_SYSTEM_PROMPT = [
+  "You write terse, navigation-oriented summaries of source files for a codebase index.",
+  "Rules: 1–3 sentences. What the file does, its outward surface (exports/routes/commands),",
+  "anything surprising (globals, side effects, generated sections). No preamble, no headings, no code fences.",
+].join("\n");
+
 /** A parsed summary sidecar. */
 export interface SummaryRecord {
   /** Repo-relative source path this summary describes. */
@@ -75,6 +81,16 @@ export interface DeepScanResult {
   pruned: number;
 }
 
+export function formatDeepScanResult(result: DeepScanResult): string {
+  const parts = [`${result.written} summarized`, `${result.skippedFresh} unchanged`];
+  if (result.skippedTooBig > 0) parts.push(`${result.skippedTooBig} skipped (size/type)`);
+  if (result.pruned > 0) parts.push(`${result.pruned} pruned`);
+  let text = `${parts.join(", ")} — ${result.considered} files considered`;
+  const first = result.failed[0];
+  if (first) text += `; ${result.failed.length} failed, first: ${first.path}: ${first.error}`;
+  return text;
+}
+
 /** Deterministic sidecar file name for a repo-relative target path. */
 export function summaryFileName(target: string): string {
   return target.split("/").join("--") + SUMMARY_SUFFIX;

package/src/core/types.ts

@@ -29,7 +29,7 @@ export interface NoteMeta {
  * This is how pi-weave keeps front matter **lossless**. `NoteMeta` names the
  * five fields the engine understands; a vault is a directory of files a human
  * also edits, so real notes carry keys the engine has never heard of —
- * Obsidian's `aliases`, `cssclass`, `publish`, whatever the user invented last
+ * `aliases`, `cssclass`, `publish`, whatever the user invented last
  * Tuesday. Modelling those as parsed values would mean re-emitting them, and
  * re-emitting a value the parser only half-understands is how formatting (and
  * then content) gets destroyed.

package/src/core/workspace.ts

@@ -71,7 +71,7 @@ export function formatDashboard(status: WorkspaceStatus): string {
   const repo = status.repository;
   lines.push(`Repository (${repo.name} @ ${repo.root}):`);
   if (!repo.indexed) {
-    lines.push("  not indexed — run a repository scan or ask pi to explore");
+    lines.push("  not indexed — run /weave-scan or ask your agent to explore");
     return lines.join("\n");
   }
   lines.push(`  index: ${repo.staleness.state}`);

package/src/core/workspaceCommands.ts

@@ -0,0 +1,227 @@
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { findGitRoot } from "./git";
+import { resolveVaultRoot } from "./paths";
+import { buildRepoIndex, summarizeIndex, writeRepoIndex } from "./repoIndex";
+import { formatDashboard, getWorkspaceStatus } from "./workspace";
+import { DEEP_SCAN_SYSTEM_PROMPT, formatDeepScanResult, runDeepScan, type SummarizeFn } from "./summaries";
+import { formatSessionScanResult, renderSessionDigest, runSessionDigestScan, runSessionScan, SESSION_SCAN_SYSTEM_PROMPT, type SessionDigest } from "./sessions";
+
+export interface WorkspaceScanStatus {
+  sessionID: string;
+  text: string;
+  active: boolean;
+}
+
+export interface WorkspaceCommand {
+  name: string;
+  description: string;
+  execute(sessionID: string, args: string): Promise<void>;
+}
+
+export interface WorkspaceCommandHost {
+  getSession(sessionID: string): Promise<{ id: string; cwd: string; model: string | null }>;
+  getDigest(sessionID: string, signal: AbortSignal): Promise<{ digest: SessionDigest; hash: string }>;
+  sessionSource(sessionID: string): string;
+  generate(sessionID: string, prompt: string, signal: AbortSignal, model: string): Promise<string>;
+  output(sessionID: string, text: string): Promise<unknown>;
+}
+
+interface RunningScan {
+  controller: AbortController;
+  done: Promise<void>;
+}
+
+function summarizer(host: WorkspaceCommandHost, sessionID: string, systemPrompt: string, signal: AbortSignal, model: string): SummarizeFn {
+  return async ({ path, content }) => {
+    signal.throwIfAborted();
+    const text = (await host.generate(sessionID, `${systemPrompt}\n\nFile: ${path}\n\n${content}`, signal, model)).trim();
+    signal.throwIfAborted();
+    if (!text) throw new Error("model returned an empty summary");
+    return text;
+  };
+}
+
+function historyPath(cwd: string, input: string): string {
+  const trimmed = input.trim();
+  if (trimmed === "~") return homedir();
+  if (trimmed.startsWith("~/")) return join(homedir(), trimmed.slice(2));
+  return resolve(cwd, trimmed);
+}
+
+export function createWorkspaceCommands(
+  host: WorkspaceCommandHost,
+  onStatus: (status: WorkspaceScanStatus) => void = () => {},
+  viewer?: { run(cwd: string): Promise<{ session: { server: { entryUrl: string } }; started: boolean }> },
+  onViewer?: (event: { sessionID: string; url: string; open: boolean; started: boolean }) => void,
+) {
+  const running = new Map<string, RunningScan>();
+  const commands: WorkspaceCommand[] = [];
+  const output = host.output;
+  const cwdOf = async (sessionID: string) => (await host.getSession(sessionID)).cwd;
+
+  const start = (sessionID: string, run: (signal: AbortSignal) => Promise<string>): void => {
+    const key = String(sessionID);
+    const controller = new AbortController();
+    const done = (async () => {
+      try {
+        const text = await run(controller.signal);
+        await output(sessionID, text);
+        onStatus({ sessionID: key, text, active: false });
+      } catch (error) {
+        const text = controller.signal.aborted
+          ? "pi-weave: scan cancelled."
+          : `pi-weave: scan failed — ${error instanceof Error ? error.message : String(error)}`;
+        await output(sessionID, text).catch(() => {});
+        onStatus({ sessionID: key, text, active: false });
+      } finally {
+        running.delete(key);
+      }
+    })();
+    running.set(key, { controller, done });
+  };
+
+  commands.push({
+    name: "weave",
+    description: "Show the pi-weave workspace dashboard",
+    async execute(sessionID) {
+      await output(sessionID, formatDashboard(await getWorkspaceStatus(await cwdOf(sessionID))));
+    },
+  });
+
+  commands.push({
+    name: "weave-scan",
+    description: "Refresh the index; use 'deep' or 'sessions [path]' for model-backed scans",
+    async execute(sessionID, args) {
+      const [mode = "", ...rest] = args.trim().split(/\s+/).filter(Boolean);
+      const key = String(sessionID);
+      if (running.has(key)) {
+        await output(sessionID, "pi-weave: a scan is already running — use /weave-scan-cancel to stop it.");
+        return;
+      }
+      const cwd = await cwdOf(sessionID);
+      if (mode.toLowerCase() === "sessions") {
+        const session = await host.getSession(sessionID);
+        if (!session.model) {
+          await output(sessionID, "pi-weave: session scan needs an active session model — none configured.");
+          return;
+        }
+        start(sessionID, async (signal) => {
+          const status = "🕸️ session scan: starting…";
+          onStatus({ sessionID: key, text: status, active: true });
+          if (rest.length > 0) {
+            const result = await runSessionScan({
+              sessionsRoot: historyPath(cwd, rest.join(" ")),
+              vaultRoot: resolveVaultRoot(),
+              summarize: summarizer(host, sessionID, SESSION_SCAN_SYSTEM_PROMPT, signal, session.model!),
+              model: session.model!,
+              signal,
+              onProgress: ({ current, total, path }) => {
+                onStatus({ sessionID: key, text: `🕸️ session scan: ${current}/${total} — ${path}`, active: true });
+              },
+            });
+            return signal.aborted
+              ? "pi-weave: session scan cancelled."
+              : `pi-weave: session scan complete — ${formatSessionScanResult(result)}`;
+          }
+          const { digest, hash } = await host.getDigest(sessionID, signal);
+          const result = await runSessionDigestScan({
+            vaultRoot: resolveVaultRoot(),
+            digest,
+            content: renderSessionDigest(digest),
+            source: host.sessionSource(session.id),
+            hash,
+            summarize: summarizer(host, sessionID, SESSION_SCAN_SYSTEM_PROMPT, signal, session.model!),
+            model: session.model!,
+          });
+          return signal.aborted
+            ? "pi-weave: session scan cancelled."
+            : `pi-weave: session scan complete — ${formatSessionScanResult(result)}`;
+        });
+        return;
+      }
+
+      const root = await findGitRoot(cwd);
+      if (!root) {
+        await output(sessionID, "pi-weave: not inside a git repository.");
+        return;
+      }
+      const index = await buildRepoIndex(root);
+      if (!index) {
+        await output(sessionID, "pi-weave: cannot index — the repository has no commits yet.");
+        return;
+      }
+      await writeRepoIndex(root, index);
+      await output(sessionID, `pi-weave: index refreshed\n${summarizeIndex(index).join("\n")}`);
+      onStatus({ sessionID: key, text: "pi-weave: index refreshed", active: false });
+      if (mode.toLowerCase() !== "deep") return;
+
+      const session = await host.getSession(sessionID);
+      if (!session.model) {
+        await output(sessionID, "pi-weave: deep scan needs an active session model — none configured. Light index only.");
+        return;
+      }
+      start(sessionID, async (signal) => {
+        onStatus({ sessionID: key, text: "🕸️ deep scan: starting…", active: true });
+        const result = await runDeepScan(root, {
+          summarize: summarizer(host, sessionID, DEEP_SCAN_SYSTEM_PROMPT, signal, session.model!),
+          model: session.model!,
+          signal,
+          onProgress: ({ current, total, path }) => {
+            const pct = total > 0 ? Math.round((current / total) * 100) : 100;
+            onStatus({ sessionID: key, text: `🕸️ deep scan: ${current}/${total} (${pct}%) — ${path}`, active: true });
+          },
+        });
+        if (signal.aborted) return "pi-weave: deep scan cancelled.";
+        return result
+          ? `pi-weave: deep scan complete — ${formatDeepScanResult(result)}`
+          : "pi-weave: deep scan stopped — repository unavailable.";
+      });
+    },
+  });
+
+  commands.push({
+    name: "weave-scan-cancel",
+    description: "Cancel the active pi-weave deep or session scan",
+    async execute(sessionID) {
+      const scan = running.get(String(sessionID));
+      if (!scan) {
+        await output(sessionID, "pi-weave: no scan is currently running.");
+        return;
+      }
+      scan.controller.abort();
+      await output(sessionID, "pi-weave: scan cancellation requested.");
+    },
+  });
+
+  if (viewer) {
+    commands.push({
+      name: "weave-view",
+      description: "Open the pi-weave browser workspace; use --no-open to only print the URL",
+      async execute(sessionID, input) {
+        const args = input.trim();
+        if (args && args !== "--no-open") {
+          await output(sessionID, "usage: /weave-view [--no-open]");
+          return;
+        }
+        const { session, started } = await viewer.run(await cwdOf(sessionID));
+        const url = session.server.entryUrl;
+        const open = args !== "--no-open" && onViewer !== undefined;
+        onViewer?.({ sessionID: String(sessionID), url, open, started });
+        await output(
+          sessionID,
+          `pi-weave: workspace ${started ? "running" : "already running"} at ${url}${open ? " — opening when the terminal is local." : " — open it in a browser."}`,
+        );
+      },
+    });
+  }
+
+  return {
+    commands,
+    done: (sessionID: string) => running.get(sessionID)?.done,
+    async cleanup() {
+      for (const scan of running.values()) scan.controller.abort();
+      await Promise.all([...running.values()].map((scan) => scan.done));
+    },
+  };
+}

package/src/opencode/commands.ts

@@ -0,0 +1,138 @@
+import { hashContent } from "../core";
+import type { SessionDigest } from "../core";
+import { createWorkspaceCommands, type WorkspaceScanStatus } from "../core/workspaceCommands";
+import type { WorkspaceServerController } from "../web/server/controller";
+
+type Context = import("@opencode/plugin").Plugin.Context;
+type SessionID = Parameters<Context["session"]["get"]>[0]["sessionID"];
+export type OpenCodeScanStatus = WorkspaceScanStatus;
+
+function record(value: unknown): Record<string, unknown> {
+  return value !== null && typeof value === "object" ? value as Record<string, unknown> : {};
+}
+
+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 = {
+    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;
+}
+
+export async function registerOpenCodeCommands(
+  context: Context,
+  onStatus: (status: OpenCodeScanStatus) => void = () => {},
+  viewer?: WorkspaceServerController,
+  onViewer: (event: { sessionID: string; url: string; open: boolean; started: boolean }) => void = () => {},
+) {
+  const shared = createWorkspaceCommands({
+    async getSession(id) {
+      const session = await context.session.get({ sessionID: id as SessionID });
+      return { id: session.id, cwd: session.location.directory, model: session.model ? `${session.model.providerID}/${session.model.id}` : null };
+    },
+    async getDigest(id, signal) {
+      const sessionID = id as SessionID;
+      const session = await context.session.get({ sessionID });
+      const messages = await context.session.context({ sessionID }, { signal });
+      const relevant = messages.filter((message) => ["user", "assistant", "compaction", "shell"].includes(message.type));
+      return { digest: openCodeSessionDigest(session, relevant), hash: hashContent(JSON.stringify(relevant)) };
+    },
+    sessionSource: (id) => `opencode:session:${id}`,
+    async generate(id, prompt, signal) {
+      return (await context.session.generate({ sessionID: id as SessionID, prompt }, { signal })).text;
+    },
+    output: (id, text) => context.session.synthetic({ sessionID: id as SessionID, text, description: "pi-weave", resume: false }),
+  }, onStatus, viewer, onViewer);
+  const registration = await context.command.transform((editor) => {
+    for (const command of shared.commands) editor.add({
+      name: command.name,
+      description: command.description,
+      execute: ({ sessionID, prompt }) => command.execute(sessionID, prompt.text),
+    });
+  });
+  return {
+    done: shared.done,
+    async cleanup() {
+      await shared.cleanup();
+      await registration.dispose();
+    },
+  };
+}

package/src/opencode/index.ts

@@ -0,0 +1,88 @@
+import { readFile } from "node:fs/promises";
+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 { WEAVE_RPC } from "./rpc";
+import { WorkspaceServerController } from "../web/server/controller";
+
+async function packagedSkill(relativePath: string): Promise<import("@opencode/plugin").Skill.Info> {
+  const path = fileURLToPath(new URL(`../../skills/${relativePath}/SKILL.md`, import.meta.url));
+  const content = await readFile(path, "utf8");
+  const parsed = parseFrontMatter(content);
+  const name = parsed?.fields.get("name");
+  if (!parsed || !name) throw new Error(`Invalid packaged skill: ${relativePath}`);
+  return {
+    id: name,
+    name,
+    description: unquoteField(parsed.fields.get("description") ?? ""),
+    path,
+    content: parsed.body,
+  } as import("@opencode/plugin").Skill.Info;
+}
+
+const weave = {
+  id: "pi-weave",
+  server: async (input: import("@opencode-ai/plugin").PluginInput) => (await import("./v1")).server(input),
+  async setup(context) {
+    const toolRegistration = await context.tool.transform((editor) => {
+      for (const tool of weaveTools) editor.add({
+        name: tool.name,
+        description: tool.description,
+        input: tool.input,
+        options: { codemode: false },
+        async execute(input, toolContext) {
+          const session = await context.session.get({ sessionID: toolContext.sessionID });
+          const result = await tool.execute(input, session.location.directory, (status) => toolContext.progress({ status }));
+          await refreshStatus(toolContext.sessionID);
+          return { content: result.text, metadata: result.details };
+        },
+      });
+    });
+
+    const skills = await Promise.all([packagedSkill("weave-notepad"), packagedSkill("weave-explore")]);
+    const skillRegistration = await context.skill.transform((editor) => {
+      for (const skill of skills) editor.add(skill);
+    });
+    const viewer = new WorkspaceServerController();
+    let status: { text: string; active: boolean; sessionID?: string; viewerUrl?: string } = {
+      text: formatStatusLine(await getWorkspaceStatus(context.location.directory)),
+      active: false,
+    };
+    const rpc = await context.rpc.register(WEAVE_RPC, {
+      status: async () => status,
+    });
+    const publishStatus = (next: Partial<typeof status>) => {
+      status = { ...status, ...next };
+      void rpc.events.emit("status", status).catch(() => {});
+    };
+    const refreshStatus = async (sessionID: Parameters<typeof context.session.get>[0]["sessionID"]) => {
+      const session = await context.session.get({ sessionID });
+      const text = formatStatusLine(await getWorkspaceStatus(session.location.directory));
+      if (!status.active) publishStatus({ sessionID, text, active: false });
+    };
+    const commands = await registerOpenCodeCommands(
+      context,
+      (next) => {
+        publishStatus(next);
+        if (!next.active) void refreshStatus(next.sessionID as Parameters<typeof context.session.get>[0]["sessionID"]).catch(() => {});
+      },
+      viewer,
+      (event) => {
+        status = { ...status, viewerUrl: event.url };
+        void rpc.events.emit("viewer", event).catch(() => {});
+        void rpc.events.emit("status", status).catch(() => {});
+      },
+    );
+    return async () => {
+      await commands.cleanup();
+      await viewer.close();
+      await rpc.dispose();
+      await skillRegistration.dispose();
+      await toolRegistration.dispose();
+    };
+  },
+} satisfies import("@opencode/plugin").Plugin.Plugin & Pick<import("@opencode-ai/plugin").PluginModule, "server">;
+
+export default weave;

package/src/opencode/rpc.ts

@@ -0,0 +1,37 @@
+const statusSchema = {
+  type: "object",
+  properties: {
+    sessionID: { type: "string" },
+    text: { type: "string" },
+    active: { type: "boolean" },
+    viewerUrl: { type: "string" },
+  },
+  required: ["text", "active"],
+  additionalProperties: false,
+} as const;
+
+export const WEAVE_RPC = {
+  id: "pi-weave",
+  methods: {
+    status: {
+      input: { type: "object", properties: {}, additionalProperties: false },
+      output: statusSchema,
+    },
+  },
+  events: {
+    status: { schema: statusSchema },
+    viewer: {
+      schema: {
+        type: "object",
+        properties: {
+          sessionID: { type: "string" },
+          url: { type: "string" },
+          open: { type: "boolean" },
+          started: { type: "boolean" },
+        },
+        required: ["sessionID", "url", "open", "started"],
+        additionalProperties: false,
+      },
+    },
+  },
+} as const;

package/src/opencode/tools.ts

@@ -0,0 +1,43 @@
+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: "append: preserve text verbatim in the ## Raw tail" },
+    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: ["status", "scan", "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, progress?: (text: string) => Promise<void>) => executeRepoAction(input as RepoActionInput, cwd, progress),
+  },
+];