pinomad 0.1.0 → 0.2.0

package/dist/{chunk-hach8mdw.js → chunk-fhtkkcgt.js}

@@ -3,13 +3,15 @@ import {
   serveWebClient
 } from "./chunk-r6w5aqkw.js";
 import {
+  packagedVersion,
   webRoot
-} from "./chunk-v7yf5752.js";
+} from "./chunk-rkfdsacq.js";
 import {
-  PROTOCOL_VERSION,
+  INVALID_FRAME_CLOSE_CODE,
+  PROTOCOL,
   UNAUTHORIZED_CLOSE_CODE,
-  isClientFrame
-} from "./chunk-wgn3cx5q.js";
+  parseClientFrame
+} from "./chunk-h35fermn.js";
 import {
   DevicesDoc,
   ensureDevices,
@@ -618,6 +620,7 @@ import { dirname, join, sep } from "node:path";
 import { defineExtension as defineExtension3, section as section2 } from "@earendil-works/pi-durable";
 import { formatSkillsForPrompt, loadProjectContextFiles, loadSkills } from "@earendil-works/pi-coding-agent";
 var PREAMBLE = "You are PiNomad, a coding agent running on the user's own machine. You work in the project directory below with the read, write, edit, and bash tools: read files before changing them, prefer edit over rewriting whole files, and run commands to check your work. Keep answers short and concrete. When it is unclear what the user wants, ask instead of guessing.";
+var FORK_SHARED_DIR = "This conversation is a fork: it shares this working directory with the conversation it was forked from, which may be editing the same files. If your task needs isolation, create your own git worktree (for example `git worktree add <dir> -b <branch>`) and use absolute paths inside it for every read, write, edit and bash command.";
 function createContext(options) {
   const { agentsHome } = options;
   const resolveCheckout = (input, context) => options.checkout?.(input, context);
@@ -630,14 +633,19 @@ function createContext(options) {
           const cwd = input.agent.cwd;
           if (cwd === undefined)
             return;
-          const checkout = await resolveCheckout({ conversationId: input.conversationId, read: input.read }, context);
-          if (checkout === undefined)
-            return `Working directory: ${cwd}`;
+          const resolved = await resolveCheckout({ conversationId: input.conversationId, read: input.read }, context);
+          const checkout = resolved?.checkout;
+          const forkLine = resolved?.fork === true && checkout?.own !== true ? [FORK_SHARED_DIR] : [];
+          if (checkout === undefined) {
+            return [`Working directory: ${cwd}`, ...forkLine].join(`
+`);
+          }
           return [
             `Working directory: ${cwd}`,
-            `This directory is a git worktree PiNomad created for this conversation, on branch ${checkout.branch} starting from commit ${checkout.base.slice(0, 12)}.`,
+            checkout.own ? `This directory is a git worktree PiNomad created for this conversation, on branch ${checkout.branch} starting from commit ${checkout.base.slice(0, 12)}.` : `This directory is a git worktree PiNomad created for the conversation this one belongs to, on branch ${checkout.branch} starting from commit ${checkout.base.slice(0, 12)}.`,
             `The user's project directory is ${checkout.projectPath} and must not be modified.`,
-            "This is a fresh checkout: ignored files (dependencies such as node_modules, or .env) are absent — install dependencies per AGENTS.md when needed."
+            "This is a fresh checkout: ignored files (dependencies such as node_modules, or .env) are absent — install dependencies per AGENTS.md when needed.",
+            ...forkLine
           ].join(`
 `);
         }),
@@ -645,7 +653,7 @@ function createContext(options) {
           const cwd = input.agent.cwd;
           if (cwd === undefined)
             return;
-          const checkout = await resolveCheckout({ conversationId: input.conversationId, read: input.read }, context);
+          const checkout = (await resolveCheckout({ conversationId: input.conversationId, read: input.read }, context))?.checkout;
           let files;
           if (checkout === undefined) {
             files = loadProjectContextFiles({ cwd, agentDir: agentsHome });
@@ -695,6 +703,19 @@ import {
   defineTool as defineTool3
 } from "@earendil-works/pi-durable";
 import { Type as Type4 } from "typebox";
+
+// apps/host/src/subagent-doc.ts
+import { defineDoc as defineDoc2 } from "@earendil-works/pi-durable";
+var SubagentDoc = defineDoc2({
+  kind: "pinomad.subagent",
+  version: 1,
+  scope: "conversation",
+  history: "latest",
+  fork: "initial",
+  initial: () => ({})
+});
+
+// apps/host/src/extensions/subagent.ts
 var INSTRUCTIONS = "You are a subagent working on one delegated task. You cannot ask the user questions; if you need a decision or clarification, stop and state exactly what you need in your final answer. Your final message is returned to the delegating agent as the result, so make it a complete, self-contained report.";
 var THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
 function createSubagent(options) {
@@ -715,8 +736,14 @@ function createSubagent(options) {
     execute: async (args, api, context) => {
       const child = await api.commit(async (tx) => {
         const existing = (await tx.scanConversations({ ownerTaskId: api.taskId }, 1)).items[0];
-        if (existing !== undefined)
-          return existing.id;
+        if (existing !== undefined) {
+          const doc2 = await tx.doc(SubagentDoc, existing.id);
+          return {
+            id: existing.id,
+            ...doc2?.model === undefined ? {} : { model: doc2.model },
+            ...doc2?.startedAt === undefined ? {} : { startedAt: doc2.startedAt }
+          };
+        }
         let model;
         let thinkingLevel;
         let override;
@@ -747,12 +774,22 @@ function createSubagent(options) {
         };
         const created = await tx.createConversation({ ownership: { kind: "task", taskId: api.taskId } });
         await configure(tx, created.id, change);
-        return created.id;
+        const childAgent = await tx.doc(AgentDoc, created.id);
+        const ref = childAgent.model ?? model ?? (await tx.doc(AgentDoc, api.conversationId)).model;
+        const startedAt = Date.now();
+        const doc = await tx.doc(SubagentDoc, created.id);
+        doc.startedAt = startedAt;
+        if (ref !== undefined)
+          doc.model = `${ref.provider}/${ref.modelId}`;
+        const label = args.description?.trim();
+        if (label !== undefined && label !== "")
+          doc.label = label;
+        return { id: created.id, ...ref === undefined ? {} : { model: doc.model }, startedAt };
       }, context);
-      await api.details({ conversationId: child }, context);
-      const handle = await api.conversation(child, context);
+      await api.details({ conversationId: child.id, ...child.model === undefined ? {} : { model: child.model }, ...child.startedAt === undefined ? {} : { startedAt: child.startedAt } }, context);
+      const handle = await api.conversation(child.id, context);
       if (handle === undefined)
-        throw new Error(`Subagent conversation ${child} does not exist`);
+        throw new Error(`Subagent conversation ${child.id} does not exist`);
       const request = { type: "input", content: args.task, requestId: `subagent:${api.taskId}` };
       const settled = await (await handle.submit(request, context)).wait(context);
       if (settled.status !== "done" || settled.type !== "input")
@@ -762,7 +799,11 @@ function createSubagent(options) {
       const text = message?.role === "assistant" ? message.content.flatMap((block) => block.type === "text" ? [block.text] : []).join("") : "";
       const result2 = {
         content: [{ type: "text", text: text === "" ? "(The subagent returned no text.)" : text }],
-        details: { conversationId: child }
+        details: {
+          conversationId: child.id,
+          ...child.model === undefined ? {} : { model: child.model },
+          ...child.startedAt === undefined ? {} : { startedAt: child.startedAt }
+        }
       };
       return result2;
     }
@@ -772,9 +813,9 @@ function createSubagent(options) {
 }
 
 // apps/host/src/extensions/todo.ts
-import { defineDoc as defineDoc2, defineExtension as defineExtension5, defineTool as defineTool4 } from "@earendil-works/pi-durable";
+import { defineDoc as defineDoc3, defineExtension as defineExtension5, defineTool as defineTool4 } from "@earendil-works/pi-durable";
 import { Type as Type5 } from "typebox";
-var TodoDoc = defineDoc2({
+var TodoDoc = defineDoc3({
   kind: "todo.list",
   version: 1,
   scope: "conversation",
@@ -817,7 +858,7 @@ import { basename, join as join3, resolve } from "node:path";
 import { clampThinkingLevel as clampThinkingLevel2 } from "@earendil-works/pi-ai";
 import {
   AgentDoc as AgentDoc2,
-  defineDoc as defineDoc3
+  defineDoc as defineDoc4
 } from "@earendil-works/pi-durable";
 
 // apps/host/src/checkout.ts
@@ -848,27 +889,6 @@ async function gitBase(projectPath) {
     return;
   return { repo, subdir: relative(repo, projectPath), base };
 }
-var SNAPSHOT_IDENTITY = {
-  GIT_AUTHOR_NAME: "PiNomad",
-  GIT_AUTHOR_EMAIL: "pinomad@localhost",
-  GIT_COMMITTER_NAME: "PiNomad",
-  GIT_COMMITTER_EMAIL: "pinomad@localhost"
-};
-async function snapshotOf(sourceDir) {
-  const indexFile = join2(tmpdir(), `pinomad-index-${randomBytes(8).toString("hex")}`);
-  const env = { GIT_INDEX_FILE: indexFile };
-  try {
-    const { stdout: head } = await git(sourceDir, ["rev-parse", "--verify", "HEAD"], env);
-    const base = head.trim();
-    await git(sourceDir, ["read-tree", base], env);
-    await git(sourceDir, ["add", "-A"], env);
-    const { stdout: tree } = await git(sourceDir, ["write-tree"], env);
-    const { stdout: commit } = await git(sourceDir, ["commit-tree", tree.trim(), "-p", base, "-m", "pinomad fork snapshot"], { ...env, ...SNAPSHOT_IDENTITY });
-    return { base, snapshot: commit.trim() };
-  } finally {
-    await rm(indexFile, { force: true });
-  }
-}
 var repoLocks = new Map;
 function locked(repo, work) {
   const next = (repoLocks.get(repo) ?? Promise.resolve()).then(work, work);
@@ -932,7 +952,7 @@ async function changesOf(dir, base, maxBytes = 1024 * 1024) {
 }
 
 // apps/host/src/organization.ts
-var IndexDoc = defineDoc3({
+var IndexDoc = defineDoc4({
   kind: "pinomad.index",
   version: 1,
   scope: "session",
@@ -1056,21 +1076,42 @@ async function archive(harness, id, archived, context) {
     entry.archived = archived;
   }, context);
 }
-async function checkoutInfo(input, context) {
+var forkFlags = new WeakMap;
+async function forkFlagOf(harness, id, context) {
+  const cached = forkFlags.get(harness)?.get(id);
+  if (cached !== undefined)
+    return cached;
+  const record = await harness.commit((tx) => tx.conversation(id), context);
+  if (record === undefined)
+    return false;
+  let flags = forkFlags.get(harness);
+  if (flags === undefined)
+    forkFlags.set(harness, flags = new Map);
+  flags.set(id, record.parent !== undefined);
+  return record.parent !== undefined;
+}
+async function checkoutInfo(harness, input, context) {
   const agent = await input.read.snapshot(AgentDoc2, input.conversationId, context);
   const cwd = agent?.cwd;
   if (cwd === undefined)
     return;
-  const index = await input.read.snapshot(IndexDoc, context);
-  const record = checkoutAt(index?.checkouts, cwd);
-  if (record === undefined)
-    return;
+  const [index, fork] = await Promise.all([
+    input.read.snapshot(IndexDoc, context),
+    forkFlagOf(harness, input.conversationId, context)
+  ]);
+  const checkout = checkoutAt(index?.checkouts, cwd);
   return {
-    branch: record.branch,
-    base: record.base,
-    projectPath: join3(record.repo, record.subdir),
-    repo: record.repo,
-    worktreeRoot: record.path
+    fork,
+    ...checkout === undefined ? {} : {
+      checkout: {
+        branch: checkout.branch,
+        base: checkout.base,
+        projectPath: join3(checkout.repo, checkout.subdir),
+        repo: checkout.repo,
+        worktreeRoot: checkout.path,
+        own: checkout.conversationId === input.conversationId
+      }
+    }
   };
 }
 async function cleanupArchivedWorktrees(harness, rootId, context) {
@@ -1409,15 +1450,43 @@ import lockfile from "proper-lockfile";
 // apps/host/src/gateway.ts
 import { createServer } from "node:http";
 import { networkInterfaces } from "node:os";
-import { join as join4, relative as relative2, sep as sep3 } from "node:path";
+import { join as join4, sep as sep3 } from "node:path";
 import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
 import { clampThinkingLevel as clampThinkingLevel3, getSupportedThinkingLevels } from "@earendil-works/pi-ai";
 import {
-  AgentDoc as AgentDoc3
+  AgentDoc as AgentDoc3,
+  LiveDoc
 } from "@earendil-works/pi-durable";
 import { WebSocket as WebSocket2, WebSocketServer } from "ws";
 import { Value as Value2 } from "typebox/value";
 
+// packages/protocol/src/tool-target.ts
+var TARGET_KEYS = [
+  "path",
+  "file_path",
+  "filePath",
+  "command",
+  "cmd",
+  "query",
+  "pattern",
+  "url",
+  "name",
+  "description",
+  "task"
+];
+var TARGET_MAX_LENGTH = 120;
+function toolTarget(args) {
+  if (typeof args !== "object" || args === null)
+    return;
+  for (const key of TARGET_KEYS) {
+    const value = args[key];
+    if (typeof value === "string" && value.length > 0) {
+      return value.length > TARGET_MAX_LENGTH ? `${value.slice(0, TARGET_MAX_LENGTH)}…` : value;
+    }
+  }
+  return;
+}
+
 // apps/host/src/relay-link.ts
 import { WebSocket } from "ws";
 function relayWsBase(origin) {
@@ -1446,6 +1515,12 @@ function startRelayLink(options) {
   let delay = minDelay;
   let retryTimer;
   let pendingAccepts = 0;
+  function setState(next) {
+    const changed = state.status !== next.status || state.status === "rejected" && next.status === "rejected" && state.reason !== next.reason;
+    state = next;
+    if (changed)
+      options.onStateChange?.(next);
+  }
   const watched = new Set;
   const ponged = new WeakMap;
   const pingIntervalMs = options.pingIntervalMs ?? 30000;
@@ -1505,7 +1580,7 @@ function startRelayLink(options) {
         break;
       case "registered":
         delay = minDelay;
-        state = { status: "registered" };
+        setState({ status: "registered" });
         break;
       case "incoming": {
         if (pendingAccepts >= maxPendingAccepts)
@@ -1532,14 +1607,12 @@ function startRelayLink(options) {
     const rejection = REJECTION_REASONS[code];
     if (rejection !== undefined) {
       const reason = `relay ${origin}: ${rejection(hostId)} (${code})`;
-      if (state.status !== "rejected" || state.reason !== reason)
-        options.onRejected?.(reason);
-      state = { status: "rejected", reason };
+      setState({ status: "rejected", reason });
       delay = maxDelay;
       reconnect(maxDelay);
       return;
     }
-    state = { status: "connecting" };
+    setState({ status: "connecting" });
     reconnect(delay);
     delay = Math.min(maxDelay, delay * 2);
   }
@@ -1562,8 +1635,20 @@ function startRelayLink(options) {
 
 // apps/host/src/gateway.ts
 var context = BACKGROUND_CONTEXT;
+var forkTails = new WeakMap;
+function serializedFork(harness, work) {
+  const next = (forkTails.get(harness) ?? Promise.resolve()).then(work, work);
+  const settled = next.then(() => {}, () => {});
+  forkTails.set(harness, settled);
+  settled.then(() => {
+    if (forkTails.get(harness) === settled)
+      forkTails.delete(harness);
+  });
+  return next;
+}
+var LOOPBACK_SECURE_PATH = "/secure";
 async function startGateway(options) {
-  const conversations = await ConversationList.open(options.harness);
+  const conversations = await ConversationList.open(options.harness, options.docs);
   const http = createServer((request, response) => {
     serveWebClient(request, response, options.webRoot).catch(() => {
       if (!response.headersSent)
@@ -1601,22 +1686,35 @@ async function startGateway(options) {
       },
       createPairing: () => {
         const spec = options.secure;
-        if (spec === undefined || remote === undefined && relay === undefined)
+        if (spec === undefined)
           return;
         const { secret, expiresAt } = spec.offers.create();
         const pair = `pair=${toBase64Url(spec.hostKey.publicKey)}.${secret}`;
         if (relay !== undefined) {
-          const target = `${relayWsBase(relay.origin)}/c/${relay.hostId}`;
-          return { url: `${relay.origin}/#${pair}&url=${encodeURIComponent(target)}`, expiresAt };
+          const target2 = `${relayWsBase(relay.origin)}/c/${relay.hostId}`;
+          return { url: `${relay.origin}/#${pair}&url=${encodeURIComponent(target2)}`, expiresAt };
         }
-        return { url: `${remote.advertiseUrl}/#${pair}`, expiresAt };
+        if (remote !== undefined)
+          return { url: `${remote.advertiseUrl}/#${pair}`, expiresAt };
+        const target = `ws://127.0.0.1:${port}${LOOPBACK_SECURE_PATH}`;
+        return { url: `http://127.0.0.1:${port}/#${pair}&url=${encodeURIComponent(target)}`, expiresAt };
       }
     });
     clients.add(client);
   };
   server.on("connection", (socket, request) => {
     socket.on("error", () => socket.terminate());
-    const token = new URL(request.url ?? "/", "ws://127.0.0.1").searchParams.get("token");
+    const url = new URL(request.url ?? "/", "ws://127.0.0.1");
+    if (url.pathname === LOOPBACK_SECURE_PATH) {
+      const secure2 = options.secure;
+      if (secure2 === undefined) {
+        socket.close(UNAUTHORIZED_CLOSE_CODE, "unauthorized");
+        return;
+      }
+      secureHandshake(socket, secure2, options.harness, register);
+      return;
+    }
+    const token = url.searchParams.get("token");
     const origin = request.headers.origin;
     if (token !== options.token || origin !== undefined && !browserOrigins.includes(origin)) {
       socket.close(UNAUTHORIZED_CLOSE_CODE, "unauthorized");
@@ -1627,17 +1725,25 @@ async function startGateway(options) {
   remote = await startRemote(options, register);
   const secure = options.secure;
   if (secure?.relay !== undefined) {
-    relay = startRelayLink({
+    let link;
+    link = startRelayLink({
       origin: secure.relay.origin,
       signingKey: secure.relay.signingKey,
       accept: (socket) => secureHandshake(socket, secure, options.harness, register),
-      onRejected: (reason) => {
-        broadcast("warning", reason);
-        console.error(reason);
+      onStateChange: (state) => {
+        if (state.status === "registered") {
+          console.log(JSON.stringify({ event: "relay", status: "registered", origin: link.origin, hostId: link.hostId }));
+        } else if (state.status === "connecting") {
+          console.log(JSON.stringify({ event: "relay", status: "connecting", origin: link.origin }));
+        } else {
+          broadcast("warning", state.reason);
+          console.error(state.reason);
+        }
       },
       ...secure.relay.reconnectDelayMs === undefined ? {} : { reconnectDelayMs: secure.relay.reconnectDelayMs },
       ...secure.relay.pingIntervalMs === undefined ? {} : { pingIntervalMs: secure.relay.pingIntervalMs }
     });
+    relay = link;
   }
   return {
     url: `ws://127.0.0.1:${port}`,
@@ -1794,36 +1900,131 @@ async function startRemote(options, register) {
 
 class ConversationList {
   #listeners = new Set;
-  #list;
+  #questionTokens;
+  #questionKinds;
+  #records = new Map;
+  #facts = new Map;
+  #index = new Map;
+  #list = [];
   #unsubscribe = () => {};
   #notifying = false;
-  constructor(list) {
-    this.#list = list;
+  constructor(docs) {
+    this.#questionTokens = (docs ?? []).filter((doc) => doc.presentation === "pinomad.question").map((doc) => doc.token);
+    this.#questionKinds = new Set(this.#questionTokens.map((token) => token.definition.kind));
   }
-  static async open(harness) {
+  static async open(harness, docs) {
+    const list = new ConversationList(docs);
     const summaries = [];
     let cursor;
     do {
       const page = await harness.commit((tx) => tx.scanConversations({}, 256, cursor), context);
-      for (const record of page.items)
-        summaries.push({ ...summaryOf(record), ...await firstInput(harness, record.id) });
+      for (const record of page.items) {
+        list.#records.set(record.id, record);
+        const facts = await list.#load(harness, record);
+        list.#facts.set(record.id, facts);
+        list.#index.set(record.id, summaries.length);
+        summaries.push(summaryOf(record, facts));
+      }
       cursor = page.next;
     } while (cursor !== undefined);
-    const list = new ConversationList(summaries);
-    list.#unsubscribe = harness.subscribeCommits((publication) => {
-      let next = list.#list;
-      for (const change of publication.changes) {
-        if (change.type === "conversation") {
-          next = [...next, summaryOf(change.value)];
-        } else if (change.type === "entry" && change.value.kind === "pi.user") {
-          const id = change.value.conversationId;
-          next = next.map((summary) => summary.id === id && summary.title === undefined ? { ...summary, ...titleOf(change.value) } : summary);
+    list.#list = summaries;
+    list.#unsubscribe = harness.subscribeCommits((publication) => list.#observe(publication));
+    return list;
+  }
+  async#load(harness, record) {
+    const history = await historyFacts(harness, record.id);
+    const facts = { pending: new Set, ...history };
+    const live = await harness.snapshot(LiveDoc, record.id, context);
+    facts.running = live?.run !== undefined;
+    facts.tools = live?.tools;
+    for (const token of this.#questionTokens) {
+      const value = await harness.snapshot(token, record.id, context);
+      if (Value2.Check(QuestionSchema, value) && value.requests.some((request) => request.resolution === undefined)) {
+        facts.pending.add(token.definition.kind);
+      }
+    }
+    if (record.owner !== undefined) {
+      const label = (await harness.snapshot(SubagentDoc, record.id, context))?.label;
+      if (typeof label === "string" && label !== "")
+        facts.label = label;
+    }
+    return facts;
+  }
+  #observe(publication) {
+    const touched = new Set;
+    for (const change of publication.changes) {
+      if (change.type === "conversation") {
+        this.#records.set(change.value.id, change.value);
+        touched.add(change.value.id);
+      }
+    }
+    for (const change of publication.changes) {
+      if (change.type === "entry") {
+        const entry = change.value;
+        if (entry.kind !== "pi.user" && entry.kind !== "pi.assistant")
+          continue;
+        const facts = this.#fact(entry.conversationId);
+        if (entry.kind === "pi.user" && facts.title === undefined)
+          Object.assign(facts, titleOf(entry));
+        if (facts.newest !== undefined && entry.id <= facts.newest)
+          continue;
+        touched.add(entry.conversationId);
+        facts.newest = entry.id;
+        const message = entry.model?.[0];
+        facts.updatedAt = typeof message?.timestamp === "number" ? message.timestamp : undefined;
+        facts.failed = entry.kind === "pi.assistant" && message?.role === "assistant" && message.stopReason === "error";
+        facts.calls = entry.kind === "pi.assistant" ? callsOf(message) : undefined;
+      } else if (change.type === "document") {
+        const id = change.conversationId;
+        if (id === undefined)
+          continue;
+        const facts = this.#fact(id);
+        if (change.record.kind === "pi.live") {
+          const live = change.value;
+          facts.running = live?.run !== undefined;
+          facts.tools = live?.tools;
+          touched.add(id);
+        } else if (this.#questionKinds.has(change.record.kind)) {
+          const value = change.value;
+          const pending = Value2.Check(QuestionSchema, value) && value.requests.some((request) => request.resolution === undefined);
+          const next2 = new Set(facts.pending);
+          if (pending)
+            next2.add(change.record.kind);
+          else
+            next2.delete(change.record.kind);
+          facts.pending = next2;
+          touched.add(id);
+        } else if (change.record.kind === SubagentDoc.definition.kind) {
+          const label = change.value?.label;
+          facts.label = typeof label === "string" && label !== "" ? label : undefined;
+          touched.add(id);
         }
       }
-      if (next !== list.#list)
-        list.#set(next);
-    });
-    return list;
+    }
+    let next;
+    for (const id of touched) {
+      const record = this.#records.get(id);
+      if (record === undefined)
+        continue;
+      const summary = summaryOf(record, this.#fact(id));
+      const index = this.#index.get(id);
+      if (index === undefined) {
+        next ??= this.#list.slice();
+        this.#index.set(id, next.length);
+        next.push(summary);
+      } else if (!sameSummary(this.#list[index], summary)) {
+        next ??= this.#list.slice();
+        next[index] = summary;
+      }
+    }
+    if (next !== undefined)
+      this.#set(next);
+  }
+  #fact(id) {
+    let facts = this.#facts.get(id);
+    if (facts === undefined)
+      this.#facts.set(id, facts = { pending: new Set });
+    return facts;
   }
   get value() {
     return this.#list;
@@ -1848,14 +2049,29 @@ class ConversationList {
     this.#listeners.clear();
   }
 }
-function summaryOf(record) {
+function summaryOf(record, facts) {
   const parent = record.parent?.conversationId ?? record.owner?.conversationId;
+  const status = facts.pending.size > 0 ? "needs-answer" : facts.running === true ? "running" : facts.failed === true ? "failed" : undefined;
+  const runningSlot = facts.running === true ? facts.tools?.find((slot) => slot.status === "running") : undefined;
+  const activity = runningSlot === undefined ? undefined : {
+    tool: runningSlot.name,
+    ...facts.calls?.get(runningSlot.callId) === undefined ? {} : { target: facts.calls.get(runningSlot.callId) }
+  };
   return {
     id: record.id,
     kind: record.owner !== undefined ? "subagent" : record.parent !== undefined ? "fork" : "conversation",
-    ...parent === undefined ? {} : { parent }
+    ...parent === undefined ? {} : { parent },
+    ...record.parent === undefined ? {} : { forkedAt: String(record.parent.at) },
+    ...facts.title === undefined ? {} : { title: facts.title },
+    ...status === undefined ? {} : { status },
+    ...facts.updatedAt === undefined ? {} : { updatedAt: facts.updatedAt },
+    ...facts.label === undefined ? {} : { label: facts.label },
+    ...activity === undefined ? {} : { activity }
   };
 }
+function sameSummary(a, b) {
+  return a.id === b.id && a.kind === b.kind && a.parent === b.parent && a.forkedAt === b.forkedAt && a.title === b.title && a.status === b.status && a.updatedAt === b.updatedAt && a.label === b.label && a.activity?.tool === b.activity?.tool && a.activity?.target === b.activity?.target;
+}
 function titleOf(entry) {
   const message = entry?.model?.[0];
   if (message?.role !== "user")
@@ -1863,16 +2079,40 @@ function titleOf(entry) {
   const text = typeof message.content === "string" ? message.content : message.content.flatMap((block) => block.type === "text" ? [block.text] : []).join(" ");
   return { title: text.replace(/\s+/g, " ").trim() };
 }
-async function firstInput(harness, id) {
+async function historyFacts(harness, id) {
   const conversation = await harness.conversation(id, context);
   let first;
+  let newest;
   let cursor;
   do {
     const page = await conversation.entries({}, 256, cursor, context);
     first = page.items.findLast((entry) => entry.kind === "pi.user" && entry.conversationId === id) ?? first;
+    newest ??= page.items.find((entry) => entry.conversationId === id && (entry.kind === "pi.user" || entry.kind === "pi.assistant"));
     cursor = page.next;
   } while (cursor !== undefined);
-  return titleOf(first);
+  const message = newest?.model?.[0];
+  return {
+    ...titleOf(first),
+    ...newest === undefined ? {} : {
+      newest: newest.id,
+      ...typeof message?.timestamp === "number" ? { updatedAt: message.timestamp } : {},
+      failed: newest.kind === "pi.assistant" && message?.role === "assistant" && message.stopReason === "error",
+      ...newest.kind === "pi.assistant" ? { calls: callsOf(message) } : {}
+    }
+  };
+}
+function callsOf(message) {
+  if (message?.role !== "assistant")
+    return;
+  const content = message.content;
+  if (!Array.isArray(content))
+    return;
+  const calls = new Map;
+  for (const block of content) {
+    if (block?.type === "toolCall" && typeof block.id === "string")
+      calls.set(block.id, toolTarget(block.arguments));
+  }
+  return calls.size === 0 ? undefined : calls;
 }
 
 class GatewayClient {
@@ -1891,24 +2131,38 @@ class GatewayClient {
     this.devicePublicKey = hooks.devicePublicKey;
     connection.handle({
       message: (text) => {
-        let frame;
+        let parsed;
         try {
-          frame = JSON.parse(text);
+          parsed = parseClientFrame(JSON.parse(text));
         } catch {
-          connection.close(1008, "Invalid client frame");
+          connection.close(INVALID_FRAME_CLOSE_CODE, "Invalid client frame");
           return;
         }
-        if (!isClientFrame(frame)) {
-          connection.close(1008, "Invalid client frame");
-          return;
+        switch (parsed.kind) {
+          case "frame":
+            this.#receive(parsed.frame).catch(() => connection.close(1011, "Gateway request failed"));
+            return;
+          case "unsupportedCall":
+            this.send({ type: "result", id: parsed.id, ok: false, error: `Unsupported method: ${parsed.method}` });
+            return;
+          case "unsupportedStream":
+            if (parsed.type === "subscribe") {
+              this.send({ type: "ended", stream: parsed.stream, reason: "Unsupported stream" });
+            }
+            return;
+          case "unknownType":
+            return;
+          case "malformed":
+            connection.close(INVALID_FRAME_CLOSE_CODE, "Invalid client frame");
+            return;
         }
-        this.#receive(frame).catch(() => connection.close(1011, "Gateway request failed"));
       },
       closed: () => hooks.closed(this)
     });
     this.send({
       type: "hello",
-      protocol: PROTOCOL_VERSION,
+      protocol: PROTOCOL,
+      ...packagedVersion === undefined ? {} : { hostVersion: packagedVersion },
       session: options.session,
       models: options.modelSummaries(),
       defaults: options.defaults,
@@ -2162,15 +2416,34 @@ class GatewayClient {
       }
       case "fork": {
         const { entryId, removeTools = [] } = args;
-        const agent = await conversation.agent(context);
-        const remove = agent.tools.filter((tool) => removeTools.includes(tool.name));
-        const init = await this.#forkCheckout(agent.cwd);
-        const fork = await conversation.fork(Number(entryId), {
-          ownership: { kind: "ownerless" },
-          ...remove.length === 0 ? {} : { agent: { tools: { remove } } },
-          ...init === undefined ? {} : { init }
-        }, context);
-        return { conversationId: fork.id };
+        return await serializedFork(this.#options.harness, async () => {
+          const at = Number(entryId);
+          await this.#options.harness.commit(async (tx) => {
+            const record = await tx.conversation(conversation.id);
+            if (record === undefined)
+              throw new Error(`Conversation ${conversation.id} does not exist`);
+            if (record.parent !== undefined || record.owner !== undefined) {
+              throw new Error("Only top-level conversations can be forked");
+            }
+            let cursor;
+            do {
+              const page = await tx.scanConversations({}, 256, cursor);
+              for (const candidate of page.items) {
+                if (candidate.parent?.conversationId === conversation.id && candidate.parent.at === at) {
+                  throw new Error("This message already has a fork");
+                }
+              }
+              cursor = page.next;
+            } while (cursor !== undefined);
+          }, context);
+          const agent = await conversation.agent(context);
+          const remove = agent.tools.filter((tool) => removeTools.includes(tool.name));
+          const fork = await conversation.fork(at, {
+            ownership: { kind: "ownerless" },
+            ...remove.length === 0 ? {} : { agent: { tools: { remove } } }
+          }, context);
+          return { conversationId: fork.id };
+        });
       }
       case "answer": {
         const { kind, requestId, answers } = args;
@@ -2254,41 +2527,6 @@ class GatewayClient {
       return { available: false, reason: "Not in a git repository" };
     return { available: true, ...await changesOf(base.repo, base.base) };
   }
-  async#forkCheckout(cwd) {
-    if (cwd === undefined)
-      return;
-    const index = await this.#options.harness.snapshot(IndexDoc, context);
-    const existing = checkoutAt(index?.checkouts, cwd);
-    let source;
-    if (existing !== undefined) {
-      source = { repo: existing.repo, dir: existing.path, subdir: relative2(existing.path, cwd) };
-    } else {
-      if (cwd.startsWith(this.#chatsPrefix))
-        return;
-      const base2 = await gitBase(cwd);
-      if (base2 === undefined)
-        return;
-      source = { repo: base2.repo, dir: base2.repo, subdir: base2.subdir };
-    }
-    const { base, snapshot } = await snapshotOf(source.dir);
-    const suffix = branchSuffix();
-    return async (tx, id) => {
-      const path = worktreePath(this.#options.dataDir, id);
-      const doc = await tx.doc(IndexDoc);
-      if (doc.checkouts === undefined)
-        doc.checkouts = [];
-      doc.checkouts.push({
-        conversationId: id,
-        path,
-        repo: source.repo,
-        subdir: source.subdir,
-        branch: worktreeBranch(id, suffix),
-        base,
-        snapshot
-      });
-      (await tx.doc(AgentDoc3, id)).cwd = join4(path, source.subdir);
-    };
-  }
   async#agent(id) {
     return await this.#options.harness.snapshot(AgentDoc3, id, context) ?? {};
   }
@@ -2333,7 +2571,14 @@ async function openHost(options) {
     const reports = [];
     let report = (error) => void reports.push(error);
     const registry = createRegistry();
-    const extensions = typeof options.extensions === "function" ? options.extensions({ scriptTools: () => mcp?.scriptTools() ?? [] }) : options.extensions ?? [];
+    const extensions = typeof options.extensions === "function" ? options.extensions({
+      scriptTools: () => mcp?.scriptTools() ?? [],
+      harness: () => {
+        if (harness === undefined)
+          throw new Error("harness is not open yet");
+        return harness;
+      }
+    }) : options.extensions ?? [];
     for (const { extension } of extensions)
       registry.install(extension);
     mcp = options.mcpConfig === undefined ? undefined : startMcp({ configPath: options.mcpConfig, registry });
@@ -2372,9 +2617,8 @@ async function openHost(options) {
     await ensureDevices(harness, context2);
     for (const path of options.projects ?? [])
       await addProject(harness, path, context2);
-    const remoteAccess = options.remote !== undefined || options.relay !== undefined;
-    const hostKey = remoteAccess ? await loadHostKey(options.dataDir) : undefined;
-    const offers = remoteAccess ? pairingOffers(options.remote?.pairingTtlMs) : undefined;
+    const hostKey = await loadHostKey(options.dataDir);
+    const offers = pairingOffers(options.remote?.pairingTtlMs);
     const relayKey = options.relay === undefined ? undefined : await loadRelayKey(options.dataDir);
     const defaults = initialModel === undefined ? {} : {
       model: { provider: initialModel.provider, modelId: initialModel.modelId },
@@ -2394,24 +2638,22 @@ async function openHost(options) {
       toolPresentations: Object.assign({}, ...extensions.map((extension) => extension.tools ?? {})),
       ...mcp === undefined ? {} : { mcp: mcp.status },
       ...options.webRoot === undefined ? {} : { webRoot: options.webRoot },
-      ...hostKey === undefined || offers === undefined ? {} : {
-        secure: {
-          hostKey,
-          offers,
-          ...options.remote?.handshakeTimeoutMs === undefined ? {} : { handshakeTimeoutMs: options.remote.handshakeTimeoutMs },
-          ...options.remote === undefined ? {} : {
-            lan: {
-              port: options.remote.port,
-              ...options.remote.publicUrl === undefined ? {} : { publicUrl: options.remote.publicUrl }
-            }
-          },
-          ...options.relay === undefined || relayKey === undefined ? {} : {
-            relay: {
-              origin: options.relay.origin,
-              signingKey: relayKey,
-              ...options.relay.reconnectDelayMs === undefined ? {} : { reconnectDelayMs: options.relay.reconnectDelayMs },
-              ...options.relay.pingIntervalMs === undefined ? {} : { pingIntervalMs: options.relay.pingIntervalMs }
-            }
+      secure: {
+        hostKey,
+        offers,
+        ...options.remote?.handshakeTimeoutMs === undefined ? {} : { handshakeTimeoutMs: options.remote.handshakeTimeoutMs },
+        ...options.remote === undefined ? {} : {
+          lan: {
+            port: options.remote.port,
+            ...options.remote.publicUrl === undefined ? {} : { publicUrl: options.remote.publicUrl }
+          }
+        },
+        ...options.relay === undefined || relayKey === undefined ? {} : {
+          relay: {
+            origin: options.relay.origin,
+            signingKey: relayKey,
+            ...options.relay.reconnectDelayMs === undefined ? {} : { reconnectDelayMs: options.relay.reconnectDelayMs },
+            ...options.relay.pingIntervalMs === undefined ? {} : { pingIntervalMs: options.relay.pingIntervalMs }
           }
         }
       }
@@ -2584,7 +2826,10 @@ async function main(argv) {
   const dataDir = resolve3(values["data-dir"] ?? DEFAULT_DATA_DIR);
   const extensionsFor = (models, summaries) => (host2) => {
     const others = [
-      createContext({ agentsHome: join6(homedir2(), ".agents"), checkout: checkoutInfo }),
+      createContext({
+        agentsHome: join6(homedir2(), ".agents"),
+        checkout: (input, context3) => checkoutInfo(host2.harness(), input, context3)
+      }),
       coding,
       todo,
       question,
@@ -2656,7 +2901,7 @@ async function main(argv) {
   const options = values.faux !== undefined ? fauxOptions(() => () => fauxAssistantMessage(values.faux)) : await piOptions();
   const host = await openHost(options);
   const model = options.initialModel === undefined ? null : `${options.initialModel.provider}/${options.initialModel.modelId}`;
-  const web = "http://127.0.0.1:5199/";
+  const web = packagedVersion === undefined ? "http://127.0.0.1:5199/" : new URL(host.url.replace(/^ws/, "http")).href;
   console.log(JSON.stringify({
     event: "ready",
     url: host.url,