pi-weave 0.2.4 → 0.3.0

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),
+  },
+];

package/src/opencode/tui.ts

@@ -0,0 +1,96 @@
+import { execFile } from "node:child_process";
+import { browserOpenCommand } from "../web/server/controller";
+import { WEAVE_RPC } from "./rpc";
+
+function record(value: unknown): Record<string, unknown> {
+  return value !== null && typeof value === "object" ? value as Record<string, unknown> : {};
+}
+
+export async function viewerIsLocal(url: string, request: typeof fetch = fetch): Promise<boolean> {
+  try {
+    const target = new URL(url);
+    if (target.protocol !== "http:" || !["127.0.0.1", "::1", "localhost"].includes(target.hostname)) return false;
+    const response = await request(target, { redirect: "manual", signal: AbortSignal.timeout(1_000) });
+    await response.body?.cancel().catch(() => undefined);
+    return response.status === 302 && response.headers.has("set-cookie");
+  } catch {
+    return false;
+  }
+}
+
+async function openBrowser(url: string): Promise<boolean> {
+  const { command, args } = browserOpenCommand(url);
+  return new Promise((resolve) => {
+    execFile(command, args, (error) => resolve(error === null));
+  });
+}
+
+async function viewerNotice(url: string, open: boolean) {
+  const opened = open && await viewerIsLocal(url) && await openBrowser(url);
+  return {
+    message: opened
+      ? `Workspace opened at ${url}`
+      : `Workspace running at ${url}${open ? " — open this URL from the server host or through a tunnel." : ""}`,
+    variant: opened ? "success" as const : "info" as const,
+  };
+}
+
+const weaveTui = {
+  id: "pi-weave.tui",
+  async tui(api) {
+    api.lifecycle.onDispose(api.event.on("message.part.updated", async ({ properties: { part } }) => {
+      if (part.type !== "text" || !part.synthetic) return;
+      const result = record(part.metadata?.["pi-weave-result"]);
+      if (typeof result.text !== "string") return;
+      const route = api.route.current;
+      if (route.name === "session" && route.params?.sessionID !== part.sessionID) return;
+      const viewer = record(result.viewer);
+      if (typeof viewer.url !== "string") return;
+      const notice = await viewerNotice(viewer.url, viewer.open === true);
+      api.ui.toast({ title: "pi-weave", ...notice });
+      if (notice.variant === "success") return;
+      api.ui.dialog.replace(() => api.ui.DialogAlert({ title: "pi-weave", message: result.text as string }));
+    }));
+  },
+  async setup(context) {
+    const rpc = context.client.rpc(WEAVE_RPC);
+    try {
+      const initial = await rpc.status({});
+      const text = String(record(initial).text ?? "");
+      if (text.includes("repo:unindexed")) {
+        context.ui.toast.show({ message: "This repository is not indexed yet. Run /weave-scan.", variant: "info" });
+      } else if (text.includes(":stale")) {
+        context.ui.toast.show({ message: "The pi-weave repository index is stale. Run /weave-scan.", variant: "warning" });
+      }
+    } catch {
+      context.ui.toast.show({ message: "pi-weave unavailable", variant: "warning" });
+    }
+
+    let lastProgress = 0;
+    const stopStatus = rpc.events.on("status", (event) => {
+      const data = record(event.data);
+      if (data.active === true && typeof data.text === "string" && Date.now() - lastProgress >= 2_000) {
+        lastProgress = Date.now();
+        context.ui.toast.show({ message: data.text, variant: "info", duration: 2_000, ...(typeof data.sessionID === "string" ? { sessionID: data.sessionID } : {}) });
+      }
+      if (data.active === false && typeof data.text === "string" && data.text.includes("complete")) {
+        context.ui.toast.show({ message: data.text, variant: "success", ...(typeof data.sessionID === "string" ? { sessionID: data.sessionID } : {}) });
+      }
+    });
+    const stopViewer = rpc.events.on("viewer", async (event) => {
+      const data = record(event.data);
+      if (typeof data.url !== "string") return;
+      context.ui.toast.show({
+        title: "pi-weave",
+        ...await viewerNotice(data.url, data.open === true),
+        ...(typeof data.sessionID === "string" ? { sessionID: data.sessionID } : {}),
+      });
+    });
+    return () => {
+      stopViewer();
+      stopStatus();
+    };
+  },
+} satisfies import("@opencode/plugin/tui").Plugin.Definition & Pick<import("@opencode-ai/plugin/tui").TuiPluginModule, "tui">;
+
+export default weaveTui;