pi-weave 0.2.3 → 0.3.0

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/vault.ts

@@ -978,21 +978,51 @@ export async function noteCount(root: string): Promise<number> {
   return (await listNoteFiles(root)).filter(isMarkdown).length;
 }
 
+const SEARCH_TERM_RE = /[\p{L}\p{N}]+(?:[._/:\-][\p{L}\p{N}]+)*/gu;
+
+/** Terms models naturally put in a search query, including code-ish tokens. */
+function searchTerms(value: string): string[] {
+  const terms = new Set<string>();
+  for (const match of value.toLowerCase().matchAll(SEARCH_TERM_RE)) {
+    const term = match[0];
+    if (term.length > 1) terms.add(term);
+    for (const part of term.split(/[._/:\-]+/)) {
+      if (part.length > 1) terms.add(part);
+    }
+  }
+  return [...terms];
+}
+
+function matchingTerm(terms: ReadonlySet<string>, query: string): string | undefined {
+  if (terms.has(query)) return query;
+  if (query.length < 5 || !/^\p{L}+$/u.test(query)) return undefined;
+  // ponytail: cheap inflection tolerance; use stemming only if false matches become measurable.
+  const prefix = query.slice(0, 4);
+  return [...terms].find((term) => term.length >= 5 && /^\p{L}+$/u.test(term) && term.startsWith(prefix));
+}
+
 /**
- * Substring search over title, tags, and body.
- * Score: title match = 3, tag match = 2, body match = 1 each (capped).
- * Case-insensitive. Deterministic ordering: score desc, then slug asc.
+ * Search slug, title, tags, and body.
+ *
+ * Exact substring behaviour stays first and unchanged. When a natural
+ * multi-term query has no literal match, an IDF-weighted lexical fallback
+ * ranks notes by term coverage: title/slug above tags above body. This makes
+ * one model-style query useful without adding a second search mode.
  */
 export async function searchNotes(root: string, query: string): Promise<NoteSearchHit[]> {
   const q = query.toLowerCase().trim();
   if (q.length === 0) return [];
 
+  const notes = (await readVault(root)).notes;
   const hits: NoteSearchHit[] = [];
   // One pass: `listNotes` + a `getNote` per slug would read every file twice.
-  for (const note of (await readVault(root)).notes) {
+  for (const note of notes) {
     let score = 0;
-    if (note.title.toLowerCase().includes(q)) score += 3;
-    if (note.tags.some((t) => t.toLowerCase().includes(q))) score += 2;
+    const title = note.title.toLowerCase();
+    const slug = note.slug.toLowerCase();
+    if (title === q || slug === q) score += 100;
+    else if (title.includes(q) || slug.includes(q)) score += 30;
+    if (note.tags.some((t) => t.toLowerCase().includes(q))) score += 20;
 
     const bodyLower = note.body.toLowerCase();
     let bodyMatches = 0;
@@ -1006,6 +1036,48 @@ export async function searchNotes(root: string, query: string): Promise<NoteSear
     if (score === 0) continue;
     hits.push({ summary: summarizeNote(note), score, snippet: makeSnippet(note.body, q) });
   }
+  if (hits.length > 0) return hits.sort((a, b) => b.score - a.score || a.summary.slug.localeCompare(b.summary.slug));
+
+  const indexed = notes.map((note) => {
+    const title = new Set(searchTerms(note.title));
+    const slug = new Set(searchTerms(note.slug));
+    const tags = new Set(note.tags.flatMap(searchTerms));
+    const body = new Set(searchTerms(note.body));
+    return { note, title, slug, tags, body, all: new Set([...title, ...slug, ...tags, ...body]) };
+  });
+  const terms = searchTerms(q).flatMap((term) => {
+    const frequency = indexed.filter((entry) => matchingTerm(entry.all, term) !== undefined).length;
+    return frequency === 0 ? [] : [{ term, frequency }];
+  });
+  if (terms.length === 0) return [];
+
+  for (const entry of indexed) {
+    let score = 0;
+    let matched = 0;
+    let snippetTerm = "";
+    for (const { term, frequency } of terms) {
+      const idf = Math.log((indexed.length + 1) / (frequency + 1)) + 1;
+      const bodyTerm = matchingTerm(entry.body, term);
+      const fieldScore = matchingTerm(entry.title, term) !== undefined || matchingTerm(entry.slug, term) !== undefined
+        ? 30
+        : matchingTerm(entry.tags, term) !== undefined
+          ? 20
+          : bodyTerm !== undefined
+            ? 5
+            : 0;
+      if (fieldScore === 0) continue;
+      score += fieldScore * idf;
+      matched++;
+      if (snippetTerm === "" && bodyTerm !== undefined) snippetTerm = bodyTerm;
+    }
+    if (matched === 0) continue;
+    score += 20 * matched / terms.length;
+    hits.push({
+      summary: summarizeNote(entry.note),
+      score,
+      snippet: makeSnippet(entry.note.body, snippetTerm || q),
+    });
+  }
   return hits.sort((a, b) => b.score - a.score || a.summary.slug.localeCompare(b.summary.slug));
 }
 

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