neko-harness 0.2.9 → 0.3.1

package/dist/gateway.js

@@ -105,11 +105,11 @@ function parseGatewayArgs(argv) {
 }
 
 // packages/gateway/src/gateway.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
 import { basename as basename4, dirname as dirname9, join as join10 } from "path";
 import { createHost } from "@earendil-works/chord";
-import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT3 } from "@earendil-works/chord/context";
+import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT4 } from "@earendil-works/chord/context";
 
 // packages/core/src/config.ts
 import { existsSync, readFileSync } from "fs";
@@ -516,6 +516,17 @@ function truncateMiddle(text, maxWidth) {
 function summarizeToolCall(name, args) {
   const record = args ?? {};
   switch (name) {
+    case "subagent":
+      return {
+        args: record.action === "list" ? "List agents" : `${record.agentId ?? record.type}: ${record.title}`,
+        detail: String(record.task ?? "")
+      };
+    case "find_files":
+    case "search_text":
+      return {
+        args: truncateMiddle(`${record.path ?? "."} ${record.pattern ?? record.query ?? ""}`, 100),
+        detail: JSON.stringify(args, null, 2)
+      };
     case "bash": {
       const command = typeof record.command === "string" ? record.command : "";
       const firstLine = command.split(`
@@ -632,6 +643,7 @@ function projectChatView(view, modelLabel, options = {}) {
       const defaultImagePrompt = entry.kind === NekoInput.kind ? savedDefaultImagePrompt(message.content, entry.data?.defaultImagePrompt) : undefined;
       items.push({
         type: "user",
+        ...entry.data?.subagentRoundId ? { subagentRoundId: entry.data.subagentRoundId } : {},
         key: `e${entry.id}`,
         id: entry.id,
         text: defaultImagePrompt && Array.isArray(message.content) ? userText(message.content.slice(1)) : userText(message.content),
@@ -653,6 +665,7 @@ function projectChatView(view, modelLabel, options = {}) {
           items.push(withArgs(result, block.name, block.arguments));
         } else {
           const summary = summarizeToolCall(block.name, block.arguments);
+          const slot = live.tools?.find((s) => s.callId === block.id);
           items.push({
             type: "tool",
             key: `t${block.id}`,
@@ -660,9 +673,9 @@ function projectChatView(view, modelLabel, options = {}) {
             name: block.name,
             summary: summary.args,
             detail: summary.detail ?? null,
-            phase: "done",
+            phase: slot?.status ?? "done",
             isError: false,
-            output: null,
+            output: slot?.output ?? null,
             result: null,
             durationMs: null,
             note: ran ? null : "Not run: response interrupted."
@@ -821,23 +834,181 @@ var stripFrontmatter = (content) => extractFrontmatter(content).body;
 // packages/core/src/runtime.ts
 import { homedir as homedir4 } from "os";
 import { join as join5 } from "path";
-import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT2 } from "@earendil-works/chord/context";
+import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT3 } from "@earendil-works/chord/context";
 import { clampThinkingLevel, createModels, getSupportedThinkingLevels as getSupportedThinkingLevels2 } from "@earendil-works/pi-ai/models";
 import { deepseekProvider } from "@earendil-works/pi-ai/providers/deepseek";
 import {
-  AssistantEntry,
+  AssistantEntry as AssistantEntry2,
   createRegistry,
-  defineDoc as defineDoc2,
+  defineDoc as defineDoc4,
   Harness,
   LiveDoc as importLiveDoc,
   MemoryStorage,
-  UsageDoc,
+  UsageDoc as UsageDoc2,
   watchEvents
 } from "@earendil-works/pi-durable";
 import { createNodePhotonImages } from "@earendil-works/pi-durable/images/node";
 import { openNodeSqliteStorage } from "@earendil-works/pi-durable/storage/sqlite/node";
 import { createCodingTools } from "@earendil-works/pi-durable/tools";
 
+// packages/core/src/agent-file-search.ts
+import { BACKGROUND_CONTEXT, withAbortSignal } from "@earendil-works/chord/context";
+import { defineExtension, defineTool } from "@earendil-works/pi-durable";
+import { getOrThrow } from "@earendil-works/pi-durable/env";
+import { Type } from "typebox";
+var SEARCH_LIMITS = {
+  entries: 1e4,
+  fileBytes: 2 * 1024 * 1024,
+  scanBytes: 32 * 1024 * 1024,
+  outputBytes: 32 * 1024,
+  timeoutMs: 1e4
+};
+var path = Type.Optional(Type.String({ description: "Directory relative to this conversation's cwd, or absolute path." }));
+var limit = Type.Optional(Type.Integer({ minimum: 1, maximum: 500, description: "Maximum results (default 100)." }));
+var text = (value) => ({ type: "text", text: value });
+async function search(api, context, run) {
+  if (!api.env)
+    throw new Error("File environment unavailable");
+  const timer = new AbortController;
+  const timeout = setTimeout(() => timer.abort(new Error("File search timed out; narrow the directory.")), SEARCH_LIMITS.timeoutMs);
+  const signal = context.abortSignal ? AbortSignal.any([context.abortSignal, timer.signal]) : timer.signal;
+  try {
+    signal.throwIfAborted();
+    return await run(api.env, withAbortSignal(signal, context));
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function listing(env, path, ctx) {
+  if (!env.listFiles)
+    throw new Error("File discovery unavailable. Retry.");
+  const base = getOrThrow(await env.absolutePath(path, ctx));
+  const files = getOrThrow(await env.listFiles(base, {
+    hidden: true,
+    gitignore: true,
+    maxEntries: SEARCH_LIMITS.entries,
+    maxBytes: 1024 * 1024,
+    timeoutMs: SEARCH_LIMITS.timeoutMs
+  }, ctx));
+  return { base, ...files };
+}
+function output(lines, complete, skipped = 0) {
+  const status = complete ? "Search complete within Pi listing; unreadable entries may be omitted." : "Partial results; narrow the directory or filter and retry.";
+  return {
+    output: [text(`${lines.join(`
+`)}
+${status}${skipped ? ` Skipped/unreadable files: ${skipped}.` : ""}`)],
+    details: { complete, skipped }
+  };
+}
+var FindFiles = defineTool({
+  name: "find_files",
+  description: "Discover files and directories without a shell. query is a literal path/name substring (not a glob). Respects gitignore; returns absolute paths usable by read. A partial result is not a complete absence of matches.",
+  parameters: Type.Object({ path, query: Type.Optional(Type.String()), limit }),
+  replay: "safe",
+  execute: (args, api, context) => search(api, context, async (env, ctx) => {
+    const files = await listing(env, args.path ?? ".", ctx);
+    const lines = [];
+    let bytes = 0;
+    let complete = !files.truncated;
+    for (const file of files.entries) {
+      ctx.abortSignal?.throwIfAborted();
+      if (args.query && !file.path.includes(args.query))
+        continue;
+      const absolute = getOrThrow(await env.joinPath([files.base, file.path], ctx)).replace(/\\/g, "/");
+      const line = `${file.kind}	${absolute}`;
+      bytes += Buffer.byteLength(line) + 1;
+      if (lines.length >= (args.limit ?? 100) || bytes > SEARCH_LIMITS.outputBytes - 256) {
+        complete = false;
+        break;
+      }
+      lines.push(line);
+    }
+    return output(lines, complete);
+  })
+});
+var SearchText = defineTool({
+  name: "search_text",
+  description: "Search UTF-8 file contents without a shell. pattern and filePattern are literal substrings, not regex/globs. Returns absolute paths, 1-based line numbers and context for read. Binary/large/unreadable files and exhausted budgets are explicitly reported as partial results.",
+  parameters: Type.Object({
+    pattern: Type.String({ minLength: 1, maxLength: 4096 }),
+    path,
+    filePattern: Type.Optional(Type.String()),
+    caseSensitive: Type.Optional(Type.Boolean()),
+    contextLines: Type.Optional(Type.Integer({ minimum: 0, maximum: 5 })),
+    limit
+  }),
+  replay: "safe",
+  execute: (args, api, context) => search(api, context, async (env, ctx) => {
+    const files = await listing(env, args.path ?? ".", ctx);
+    const results = [];
+    let complete = !files.truncated;
+    let skipped = 0;
+    let scanned = 0;
+    let bytes = 0;
+    const needle = args.caseSensitive === false ? args.pattern.toLowerCase() : args.pattern;
+    outer:
+      for (const file of files.entries) {
+        ctx.abortSignal?.throwIfAborted();
+        if (file.kind !== "file" || args.filePattern && !file.path.includes(args.filePattern))
+          continue;
+        const absolute = getOrThrow(await env.joinPath([files.base, file.path], ctx));
+        const opened = await env.openBinaryReader(absolute, { noFollow: true }, ctx);
+        if (!opened.ok) {
+          ctx.abortSignal?.throwIfAborted();
+          skipped++;
+          complete = false;
+          continue;
+        }
+        try {
+          const info = getOrThrow(await opened.value.info(ctx));
+          if (info.size > SEARCH_LIMITS.fileBytes) {
+            skipped++;
+            complete = false;
+            continue;
+          }
+          if (scanned + info.size > SEARCH_LIMITS.scanBytes) {
+            complete = false;
+            break;
+          }
+          const data = getOrThrow(await opened.value.read(0, info.size + 1, ctx));
+          scanned += data.length;
+          if (data.length !== info.size || data.includes(0)) {
+            skipped++;
+            complete = false;
+            continue;
+          }
+          const lines = new TextDecoder("utf-8", { fatal: true }).decode(data).split(/\r?\n/);
+          for (let i = 0;i < lines.length; i++) {
+            ctx.abortSignal?.throwIfAborted();
+            const value = lines[i];
+            if (!(args.caseSensitive === false ? value.toLowerCase() : value).includes(needle))
+              continue;
+            const n = args.contextLines ?? 0;
+            const block = lines.slice(Math.max(0, i - n), i + n + 1).map((line, offset) => `${absolute.replace(/\\/g, "/")}:${Math.max(0, i - n) + offset + 1}:${line}`).join(`
+`);
+            bytes += Buffer.byteLength(block) + 1;
+            if (results.length >= (args.limit ?? 100) || bytes > SEARCH_LIMITS.outputBytes - 256) {
+              complete = false;
+              break outer;
+            }
+            results.push(block);
+          }
+        } catch (error) {
+          ctx.abortSignal?.throwIfAborted();
+          if (!(error instanceof Error))
+            throw error;
+          skipped++;
+          complete = false;
+        } finally {
+          await opened.value.close(BACKGROUND_CONTEXT);
+        }
+      }
+    return output(results, complete, skipped);
+  })
+});
+var AgentFileSearch = defineExtension({ name: "neko-file-search", tools: [FindFiles, SearchText] });
+
 // packages/core/src/compaction.ts
 import {
   CompactionTask
@@ -870,9 +1041,9 @@ async function readCompaction(harness, storage, id, context) {
 }
 
 // packages/core/src/image-metadata.ts
-import { defineExtension, hook, ToolTask } from "@earendil-works/pi-durable";
+import { defineExtension as defineExtension2, hook, ToolTask } from "@earendil-works/pi-durable";
 import sharp from "sharp";
-var ImageDetails = defineExtension({
+var ImageDetails = defineExtension2({
   name: "neko-image-details",
   hooks: [
     hook(ToolTask, {
@@ -1045,10 +1216,575 @@ ${args}` : block;
 };
 
 // packages/core/src/prompt/prompt.ts
-import { defineExtension as defineExtension2, section } from "@earendil-works/pi-durable";
+import { defineExtension as defineExtension4, section } from "@earendil-works/pi-durable";
+
+// packages/core/src/subagents.ts
+import {
+  AssistantEntry,
+  configure,
+  defineDoc,
+  defineExtension as defineExtension3,
+  defineTask,
+  defineTool as defineTool2,
+  LiveDoc,
+  UsageDoc
+} from "@earendil-works/pi-durable";
+import { Type as Type2 } from "typebox";
+import { Value } from "typebox/value";
+
+// packages/core/src/subagent-usage.ts
+var emptySubagentUsage = () => ({ models: {}, tools: {} });
+function subtractSubagentUsage(end, start) {
+  const result = emptySubagentUsage();
+  for (const bucket of ["models", "tools"]) {
+    for (const [key, usage] of Object.entries(end[bucket])) {
+      const before = start[bucket][key];
+      const cost = usage.cost;
+      const next = {
+        input: usage.input - (before?.input ?? 0),
+        output: usage.output - (before?.output ?? 0),
+        cacheRead: usage.cacheRead - (before?.cacheRead ?? 0),
+        cacheWrite: usage.cacheWrite - (before?.cacheWrite ?? 0),
+        totalTokens: usage.totalTokens - (before?.totalTokens ?? 0),
+        cost: {
+          input: cost.input - (before?.cost.input ?? 0),
+          output: cost.output - (before?.cost.output ?? 0),
+          cacheRead: cost.cacheRead - (before?.cost.cacheRead ?? 0),
+          cacheWrite: cost.cacheWrite - (before?.cost.cacheWrite ?? 0),
+          total: cost.total - (before?.cost.total ?? 0)
+        }
+      };
+      if (usage.reasoning !== undefined)
+        next.reasoning = usage.reasoning - (before?.reasoning ?? 0);
+      if (usage.cacheWrite1h !== undefined)
+        next.cacheWrite1h = usage.cacheWrite1h - (before?.cacheWrite1h ?? 0);
+      result[bucket][key] = next;
+    }
+  }
+  return result;
+}
+function subagentUsageTotals(state) {
+  const totals = totalUsage(state);
+  return {
+    input: totals.input,
+    output: totals.output,
+    cacheRead: totals.cacheRead,
+    cacheWrite: totals.cacheWrite,
+    cost: totals.cost.total
+  };
+}
+
+// packages/core/src/subagents.ts
+var agentIdFor = (childId) => `agent-${childId}`;
+var DelegationsDoc = defineDoc({
+  kind: "app.neko.delegations",
+  version: 1,
+  scope: "conversation",
+  history: "latest",
+  fork: "initial",
+  initial: () => ({ items: [] })
+});
+var SubagentsDoc = defineDoc({
+  kind: "app.neko.subagents",
+  version: 1,
+  scope: "conversation",
+  history: "latest",
+  fork: "initial",
+  initial: () => ({ items: [] })
+});
+var SubagentDoc = defineDoc({
+  kind: "app.neko.subagent",
+  version: 1,
+  scope: "conversation",
+  history: "latest",
+  fork: "initial",
+  initial: () => ({ role: null, parentId: null })
+});
+var SlotsDoc = defineDoc({
+  kind: "app.neko.subagent-slots",
+  version: 1,
+  scope: "session",
+  initial: () => ({ items: [] })
+});
+var ROLE_PROMPTS = {
+  explore: "You are neko's exploration subagent. Read and search by default. Bash requires explicit user approval for each call and may have side effects. Respect the assigned constraints. After denial use another approach or report the limitation; do not bypass or repeatedly request denied operations. Return findings with paths and line numbers.",
+  plan: "You are neko's read-only planning subagent. Read evidence and propose implementation steps, trade-offs and verification. Do not modify files or execute commands.",
+  coder: "You are neko's coding subagent. Implement only the assigned scope and verify it. Coordinate through the main agent; do not overwrite unrelated changes. Report changed files and verification results."
+};
+var SUBAGENT_DELIVERY = " Work from the assigned task, your own prior conversation context and project resources; you cannot see the main conversation. Do not delegate or ask the user directly. Your final message must be a self-contained delivery to the main agent, including evidence, results and limitations. Skills never expand your allowed tools.";
+var READ_TOOLS = new Set(["read", "find_files", "search_text", "web_search", "web_extract"]);
+async function refreshDelegations(tx, id) {
+  const doc = await tx.doc(DelegationsDoc, id);
+  const identities = await tx.doc(SubagentsDoc, id);
+  for (const item of doc.items) {
+    item.agentId ??= agentIdFor(item.childId);
+    item.round ??= doc.items.filter((d) => d.childId === item.childId && d.taskId <= item.taskId).length;
+    if (item.historyThrough !== undefined)
+      continue;
+    if (item.inputEntryId === undefined) {
+      const submission = await tx.submissionByRequest(item.childId, `subagent:${item.taskId}`);
+      if (submission?.type === "input" && submission.entry !== undefined)
+        item.inputEntryId = submission.entry;
+    }
+    let identity = identities.items.find((a) => a.childId === item.childId);
+    if (!identity) {
+      const role = await tx.doc(SubagentDoc, item.childId);
+      if (role.parentId !== id || role.role !== item.role)
+        continue;
+      identity = {
+        agentId: item.agentId,
+        parentId: id,
+        childId: item.childId,
+        role: item.role,
+        cwd: "",
+        title: item.title,
+        createdAt: item.createdAt,
+        activeRoundId: item.taskId
+      };
+      identities.items.push(identity);
+      identity = identities.items.at(-1);
+    }
+    const task = await tx.task(item.taskId);
+    const runner = item.runnerId === undefined ? undefined : await tx.task(item.runnerId);
+    const live = await tx.doc(LiveDoc, item.childId);
+    const idle = live.run === undefined && !live.compactions?.length;
+    if (task?.state.status === "terminal") {
+      if (item.status === "queued" || item.status === "running") {
+        item.status = task.state.outcome.status === "aborted" ? "cancelled" : "failed";
+        item.endedAt ??= Date.now();
+      }
+      if (identity.activeRoundId === item.taskId && idle && (!runner || runner.state.status === "terminal"))
+        identity.activeRoundId = null;
+    }
+  }
+  return JSON.parse(JSON.stringify(doc.items));
+}
+function summarizeSubagents(rounds, identities = []) {
+  const groups = new Map;
+  for (const round of rounds) {
+    const id = round.agentId ?? agentIdFor(round.childId);
+    groups.set(id, [...groups.get(id) ?? [], round]);
+  }
+  return [...groups].map(([agentId, entries]) => {
+    const first = entries[0];
+    const last = entries.at(-1);
+    const identity = identities.find((a) => a.agentId === agentId);
+    const active = entries.find((r) => identity ? r.taskId === identity.activeRoundId : r.status === "running" || r.status === "queued");
+    return {
+      agentId,
+      parentId: first.parentId,
+      childId: first.childId,
+      role: first.role,
+      title: identity?.title ?? first.title,
+      status: active ? active.status === "queued" ? "queued" : "running" : "idle",
+      activeRoundId: active?.taskId ?? null,
+      lastRoundId: last.taskId,
+      lastReport: last.report?.slice(0, 512) ?? null,
+      roundCount: entries.length,
+      taskTitle: (active ?? last).title,
+      approvalCount: active?.approvalCount ?? 0,
+      createdAt: first.createdAt,
+      ...first.historyThrough !== undefined ? { historyThrough: first.historyThrough, historyUsage: first.historyUsage } : {}
+    };
+  });
+}
+async function acquireSlot(tx, round, cwd) {
+  const slots = await tx.doc(SlotsDoc);
+  const live = [];
+  for (const slot of slots.items) {
+    const task = await tx.task(slot.taskId);
+    if (task && task.state.status !== "terminal")
+      live.push(slot);
+  }
+  slots.items = live;
+  if (live.some((slot) => slot.taskId === round.taskId))
+    return true;
+  if (live.filter((slot) => slot.parentId === round.parentId).length >= 3 || round.role === "coder" && live.some((slot) => slot.coder && slot.cwd === cwd))
+    return false;
+  slots.items.push({ taskId: round.taskId, parentId: round.parentId, cwd, coder: round.role === "coder" });
+  return true;
+}
+var actionParameters = Type2.Union([
+  Type2.Object({
+    action: Type2.Optional(Type2.Literal("create")),
+    type: Type2.Enum(["explore", "plan", "coder"]),
+    title: Type2.String({ minLength: 1, maxLength: 80 }),
+    task: Type2.String({ minLength: 1, maxLength: 32768 })
+  }, { additionalProperties: false }),
+  Type2.Object({
+    action: Type2.Literal("continue"),
+    agentId: Type2.String(),
+    title: Type2.String({ minLength: 1, maxLength: 80 }),
+    task: Type2.String({ minLength: 1, maxLength: 32768 })
+  }, { additionalProperties: false }),
+  Type2.Object({
+    action: Type2.Literal("list"),
+    cursor: Type2.Optional(Type2.Integer({ minimum: 0 })),
+    limit: Type2.Optional(Type2.Integer({ minimum: 1, maximum: 100 }))
+  }, { additionalProperties: false })
+]);
+var parameters = Type2.Object({
+  action: Type2.Optional(Type2.String({ enum: ["create", "continue", "list"], description: "Defaults to create." })),
+  type: Type2.Optional(Type2.String({ enum: ["explore", "plan", "coder"], description: "Required for create only." })),
+  agentId: Type2.Optional(Type2.String({ description: "Required for continue only; use an ID returned by create/list." })),
+  title: Type2.Optional(Type2.String({ minLength: 1, maxLength: 80, description: "Required for create/continue." })),
+  task: Type2.Optional(Type2.String({ minLength: 1, maxLength: 32768, description: "Required for create/continue." })),
+  cursor: Type2.Optional(Type2.Integer({ minimum: 0, description: "List pagination cursor only." })),
+  limit: Type2.Optional(Type2.Integer({ minimum: 1, maximum: 100, description: "List page size only." }))
+}, { additionalProperties: false });
+var structuredOutputSchema = Type2.Union([
+  Type2.Object({
+    agentId: Type2.String(),
+    roundId: Type2.Integer(),
+    status: Type2.Enum(["completed", "failed", "cancelled"]),
+    report: Type2.String()
+  }, { additionalProperties: false }),
+  Type2.Object({
+    items: Type2.Array(Type2.Object({
+      agentId: Type2.String(),
+      parentId: Type2.Integer(),
+      childId: Type2.Integer(),
+      role: Type2.Enum(["explore", "plan", "coder"]),
+      title: Type2.String(),
+      status: Type2.Enum(["idle", "queued", "running"]),
+      activeRoundId: Type2.Union([Type2.Integer(), Type2.Null()]),
+      lastRoundId: Type2.Integer(),
+      lastReport: Type2.Optional(Type2.Union([Type2.String(), Type2.Null()])),
+      roundCount: Type2.Integer(),
+      taskTitle: Type2.String(),
+      approvalCount: Type2.Integer(),
+      createdAt: Type2.Number()
+    }, { additionalProperties: false })),
+    next: Type2.Union([Type2.Integer(), Type2.Null()])
+  }, { additionalProperties: false })
+]);
+function createSubagentExtension(prepare, discard) {
+  const finish = async (tx, input, status, report) => {
+    const round = (await tx.doc(DelegationsDoc, input.parentId)).items.find((r) => r.taskId === input.taskId);
+    round.status = status;
+    round.report = report;
+    round.endedAt ??= Date.now();
+    round.usageEnd = JSON.parse(JSON.stringify(await tx.doc(UsageDoc, input.childId)));
+    round.roundUsage = round.usageStart ? subagentUsageTotals(subtractSubagentUsage(round.usageEnd, round.usageStart)) : round.startedAt === null ? subagentUsageTotals(emptySubagentUsage()) : null;
+  };
+  const RoundTask = defineTask({
+    name: "app.neko.subagent-round",
+    version: 1,
+    initial: () => ({ phase: "admission" }),
+    phases: {
+      admission: async (task, runtime, ctx) => {
+        const env = await runtime.env(ctx);
+        const canonical = env && await env.canonicalPath(task.input.cwd, ctx);
+        const slotCwd = canonical?.ok ? canonical.value : task.input.cwd;
+        let admitted = false;
+        while (!admitted) {
+          await runtime.commit(async (tx) => {
+            const round = (await tx.doc(DelegationsDoc, task.input.parentId)).items.find((r) => r.taskId === task.input.taskId);
+            if (!await acquireSlot(tx, round, slotCwd))
+              return;
+            admitted = true;
+            const duplicate = await tx.submissionByRequest(task.input.childId, `subagent:${round.taskId}`);
+            if (!duplicate && !round.usageStart)
+              round.usageStart = JSON.parse(JSON.stringify(await tx.doc(UsageDoc, task.input.childId)));
+            round.status = "running";
+            round.startedAt ??= Date.now();
+            return { status: "running", checkpoint: { phase: "deliver" } };
+          }, ctx);
+          if (!admitted)
+            await runtime.sleep(runtime.now() + 100, ctx);
+        }
+      },
+      deliver: async (task, runtime, ctx) => {
+        const input = task.input;
+        const child = await runtime.conversation(input.childId, ctx);
+        const requestId = `subagent:${input.taskId}`;
+        try {
+          let duplicate = false;
+          await runtime.commit(async (tx) => {
+            duplicate = !!await tx.submissionByRequest(input.childId, requestId);
+          }, ctx);
+          if (!duplicate)
+            await prepare(input.childId, requestId, input.cwd);
+          const submission = await child.submit({
+            type: "input",
+            content: input.task,
+            requestId,
+            whenBusy: "reject",
+            entry: {
+              kind: NekoInput.kind,
+              data: { at: Date.now(), prompt: input.task, images: [], subagentRoundId: input.taskId }
+            }
+          }, ctx);
+          const placed = await submission.status(ctx);
+          await runtime.commit(async (tx) => {
+            if (placed.type === "input" && placed.entry !== undefined)
+              (await tx.doc(DelegationsDoc, input.parentId)).items.find((r) => r.taskId === input.taskId).inputEntryId = placed.entry;
+            return { status: "running", checkpoint: { phase: "settle" } };
+          }, ctx);
+        } catch (error) {
+          discard(input.childId, requestId);
+          if (ctx.abortSignal?.aborted)
+            throw error;
+          await child.abort(ctx);
+          const report = `Subagent failed: ${String(error)}`;
+          await runtime.commit(async (tx) => {
+            await finish(tx, input, "failed", report);
+            return { status: "terminal", outcome: { status: "completed", result: { status: "failed", report } } };
+          }, ctx);
+        }
+      },
+      settle: async (task, runtime, ctx) => {
+        const input = task.input;
+        const child = await runtime.conversation(input.childId, ctx);
+        const submission = await child.submit({ type: "input", content: input.task, requestId: `subagent:${input.taskId}` }, ctx);
+        const settled = await submission.wait(ctx);
+        await child.waitForIdle(ctx);
+        await runtime.commit(async (tx) => {
+          let report = "";
+          let status = "failed";
+          const round = (await tx.doc(DelegationsDoc, input.parentId)).items.find((r) => r.taskId === input.taskId);
+          if (settled.type === "input" && settled.entry !== undefined)
+            round.inputEntryId = settled.entry;
+          if (settled.status === "done" && settled.type === "input") {
+            round.answerEntryId = settled.answer;
+            const message = (await tx.entry(AssistantEntry, settled.answer))?.model?.[0];
+            report = message?.role === "assistant" ? message.content.flatMap((b) => b.type === "text" ? [b.text] : []).join("") : "";
+            status = "completed";
+          } else if (settled.status === "unanswered") {
+            status = settled.reason === "aborted" ? "cancelled" : "failed";
+            report = `Subagent ${status}: ${settled.reason}`;
+          }
+          await finish(tx, input, status, report);
+          return { status: "terminal", outcome: { status: "completed", result: { status, report } } };
+        }, ctx);
+      }
+    },
+    abort: async (task, runtime, ctx) => {
+      const input = task.input;
+      let own = false;
+      await runtime.commit(async (tx) => {
+        own = (await tx.doc(SubagentsDoc, input.parentId)).items.some((a) => a.childId === input.childId && a.activeRoundId === input.taskId);
+      }, ctx);
+      if (own)
+        await (await runtime.conversation(input.childId, ctx))?.abort(ctx);
+      await runtime.commit(async (tx) => {
+        await finish(tx, input, "cancelled", "Subagent cancelled");
+        return { status: "terminal", outcome: { status: "aborted" } };
+      }, ctx);
+    }
+  });
+  const extension = defineExtension3({
+    name: "neko-subagents",
+    tasks: [RoundTask],
+    tools: [
+      defineTool2({
+        name: "subagent",
+        description: "Manage persistent foreground subagents. create (default): type explore/plan/coder, title, task. continue: agentId, title, task; reuses its own context, only while idle. list: discover this session's agents, optional cursor/limit. Explore Bash requires per-call user approval. Keep constraints explicit; verify and integrate final reports. Subagents cannot delegate.",
+        parameters,
+        structuredOutputSchema,
+        replay: "safe",
+        execute: async (input, api, context) => {
+          if (!Value.Check(actionParameters, input))
+            throw new Error("Invalid subagent arguments. create requires type/title/task; continue requires agentId/title/task; list accepts only cursor/limit. Do not mix fields from different actions.");
+          const args = input;
+          if ((await api.snapshot(SubagentDoc, api.conversationId, context))?.role)
+            throw new Error("Subagents cannot delegate.");
+          if (args.action === "list") {
+            const list = await api.commit(async (tx) => {
+              const rounds = await refreshDelegations(tx, api.conversationId);
+              return summarizeSubagents(rounds, (await tx.doc(SubagentsDoc, api.conversationId)).items).filter((a) => a.historyThrough === undefined);
+            }, context);
+            const offset = args.cursor ?? 0;
+            const items = list.slice(offset, offset + (args.limit ?? 50));
+            const result = { items, next: offset + items.length < list.length ? offset + items.length : null };
+            return { output: [{ type: "text", text: JSON.stringify(result) }], structuredOutput: result };
+          }
+          if (!args.task.trim() || !args.title.trim() || Buffer.byteLength(args.task) > 32768)
+            throw new Error("Task/title must be nonempty; task limit is 32 KiB.");
+          const agent = await api.agent(context);
+          const round = await api.commit(async (tx) => {
+            const rounds = await refreshDelegations(tx, api.conversationId);
+            const receipt = rounds.find((r) => r.taskId === api.taskId);
+            if (receipt?.runnerId !== undefined)
+              return receipt;
+            const identities = await tx.doc(SubagentsDoc, api.conversationId);
+            let identity;
+            if (args.action === "continue") {
+              identity = identities.items.find((a) => a.agentId === args.agentId);
+              if (!identity)
+                throw new Error("Unknown subagent or it belongs to another conversation.");
+              const info = await tx.doc(SubagentDoc, identity.childId);
+              if (info.parentId !== api.conversationId || info.role !== identity.role)
+                throw new Error("Subagent ownership mismatch.");
+              if (identity.activeRoundId !== null)
+                throw new Error("Subagent is busy; continue only when idle.");
+            } else if (receipt) {
+              identity = identities.items.find((a) => a.childId === receipt.childId);
+            }
+            const existing = identity ? undefined : (await tx.scanConversations({ ownerTaskId: api.taskId }, 1)).items[0];
+            const child = identity ? await tx.conversation(identity.childId) : existing;
+            if (!identity) {
+              const created = child ?? await tx.createConversation({ ownership: { kind: "task", taskId: api.taskId } });
+              const role = args.action === "continue" ? "explore" : args.type;
+              await configure(tx, created.id, {
+                model: agent.model,
+                thinkingLevel: agent.thinkingLevel,
+                cwd: agent.cwd,
+                extensions: agent.extensions.filter((e) => e.name !== extension.name),
+                tools: agent.tools.filter((t) => t.name !== "subagent" && (role === "coder" || READ_TOOLS.has(t.name) || role === "explore" && t.name === "bash"))
+              });
+              Object.assign(await tx.doc(SubagentDoc, created.id), { role, parentId: api.conversationId });
+              identity = {
+                agentId: agentIdFor(created.id),
+                parentId: api.conversationId,
+                childId: created.id,
+                role,
+                cwd: agent.cwd ?? "",
+                title: args.title,
+                createdAt: Date.now(),
+                activeRoundId: null
+              };
+              identities.items.push(identity);
+            }
+            const record = receipt ?? {
+              parentId: api.conversationId,
+              taskId: api.taskId,
+              callId: api.callId,
+              childId: identity.childId,
+              agentId: identity.agentId,
+              round: rounds.filter((r) => r.childId === identity.childId).length + 1,
+              role: identity.role,
+              title: args.title,
+              createdAt: Date.now(),
+              startedAt: null,
+              endedAt: null,
+              status: "queued",
+              report: null
+            };
+            identities.items.find((a) => a.agentId === identity.agentId).activeRoundId = api.taskId;
+            const runner = await tx.createTask(RoundTask, {
+              parentId: api.conversationId,
+              childId: identity.childId,
+              taskId: api.taskId,
+              task: args.task,
+              cwd: identity.cwd || agent.cwd || ""
+            }, { ownership: { kind: "task", taskId: api.taskId } });
+            record.runnerId = runner;
+            const doc = await tx.doc(DelegationsDoc, api.conversationId);
+            if (receipt)
+              Object.assign(doc.items.find((r) => r.taskId === receipt.taskId), record);
+            else
+              doc.items.push(record);
+            return record;
+          }, context);
+          await api.details({
+            conversationId: round.childId,
+            agentId: round.agentId,
+            roundId: round.taskId,
+            role: round.role,
+            title: round.title
+          }, context);
+          const settled = await api.waitForTask(round.runnerId, context);
+          const outcome = settled.state.outcome;
+          const result = outcome.status === "completed" ? outcome.result : { status: outcome.status === "aborted" ? "cancelled" : "failed", report: `Subagent ${outcome.status}` };
+          return {
+            output: [
+              {
+                type: "text",
+                text: `Agent: ${round.agentId}
+Status: ${result.status}
+${result.report || "Subagent completed without a text report."}`
+              }
+            ],
+            isError: result.status !== "completed",
+            structuredOutput: { agentId: round.agentId, roundId: round.taskId, ...result },
+            details: {
+              conversationId: round.childId,
+              agentId: round.agentId,
+              roundId: round.taskId,
+              role: round.role,
+              title: round.title,
+              status: result.status
+            }
+          };
+        }
+      })
+    ]
+  });
+  return extension;
+}
+async function listDelegations(harness, parent, context) {
+  const rounds = await harness.commit((tx) => refreshDelegations(tx, parent), context);
+  for (const round of rounds) {
+    if (round.historyThrough !== undefined)
+      continue;
+    const task = await harness.getTask(round.taskId, context);
+    if (task?.state.status !== "terminal")
+      continue;
+    const child = await harness.conversation(round.childId, context);
+    const live = await harness.snapshot(LiveDoc, round.childId, context);
+    const identity = (await harness.snapshot(SubagentsDoc, parent, context))?.items.find((a) => a.childId === round.childId);
+    if (identity?.activeRoundId === round.taskId && live?.run !== undefined)
+      await child?.abort(context);
+  }
+  return harness.commit((tx) => refreshDelegations(tx, parent), context);
+}
+async function installSubagentCoordinator(harness, parents, context) {
+  const known = new Set(parents);
+  let running = false;
+  let dirty = false;
+  const reconcile = async () => {
+    if (running) {
+      dirty = true;
+      return;
+    }
+    running = true;
+    try {
+      do {
+        dirty = false;
+        for (const id of known)
+          await listDelegations(harness, id, context);
+      } while (dirty);
+    } finally {
+      running = false;
+    }
+  };
+  for (const parent of parents) {
+    await harness.commit((tx) => refreshDelegations(tx, parent), context);
+    for (const identity of (await harness.snapshot(SubagentsDoc, parent, context))?.items ?? []) {
+      if (identity.cwd)
+        continue;
+      const child = await harness.conversation(identity.childId, context);
+      const cwd = (await child?.agent(context))?.cwd;
+      if (cwd)
+        await harness.commit(async (tx) => {
+          (await tx.doc(SubagentsDoc, parent)).items.find((a) => a.agentId === identity.agentId).cwd = cwd;
+        }, context);
+    }
+  }
+  const stop = harness.subscribeCommits(({ changes }) => {
+    for (const c of changes)
+      if (c.type === "document" && c.record.kind === "app.neko.delegations" && c.conversationId !== undefined)
+        known.add(c.conversationId);
+    if (changes.some((c) => c.type === "task" && c.value.state.status === "terminal"))
+      reconcile().catch(() => {});
+  });
+  harness.closed.finally(stop).catch(() => {});
+}
+
+// packages/core/src/prompt/prompt.ts
 var KEYS = ["preamble", "rules", "project_context", "skills", "cwd"];
 var PREAMBLE = "You are an expert coding assistant operating inside neko, a coding agent harness. You help users by reading files, executing commands, editing code, and writing new files.";
 var TOOL_GUIDELINES = {
+  subagent: [
+    "Delegate only independent, sufficiently scoped work when isolation or parallelism helps. Handle simple tasks directly. Pass necessary context and user constraints; research-only requests must not become coding tasks. For related follow-up work, list and continue a suitable idle subagent using its stable agentId; busy means no task was accepted. Do not change its role. Verify and integrate reports. Do not modify files concurrently with a coder assigned those files."
+  ],
+  find_files: [
+    "Use find_files to discover files; query is a literal substring. Narrow the directory when results are partial."
+  ],
+  search_text: [
+    "Use search_text for literal text search and read for surrounding evidence. Partial results do not prove absence."
+  ],
   read: ["Use read to examine files instead of cat or sed."],
   write: ["Use write only for new files or complete rewrites."],
   edit: [
@@ -1084,11 +1820,12 @@ ${content}
 `);
 var createNekoPrompt = (loadResources) => {
   const built = new WeakMap;
-  const build = async (input) => {
+  const build = async (input, context) => {
     const cwd = input.agent.cwd;
+    const role = (await input.read.snapshot(SubagentDoc, input.conversationId, context))?.role;
     const resources = cwd ? await loadResources(input.conversationId, cwd) : { contextFiles: [], skills: [] };
     const sections = {
-      preamble: PREAMBLE,
+      preamble: role ? ROLE_PROMPTS[role] + SUBAGENT_DELIVERY : PREAMBLE,
       rules: buildRules(input.agent.tools.map((tool) => tool.name)),
       project_context: renderProjectContext(resources.contextFiles),
       skills: formatSkillsForPrompt(resources.skills) || undefined,
@@ -1096,12 +1833,12 @@ var createNekoPrompt = (loadResources) => {
     };
     return sections;
   };
-  return defineExtension2({
+  return defineExtension4({
     name: "neko-prompt",
-    sections: KEYS.map((key) => section(key, async (input) => {
+    sections: KEYS.map((key) => section(key, async (input, context) => {
       let pending = built.get(input);
       if (!pending) {
-        pending = build(input);
+        pending = build(input, context);
         built.set(input, pending);
       }
       const text = (await pending)[key];
@@ -1248,13 +1985,13 @@ var createResourceSnapshots = (load, submission) => {
 import { stripVTControlCharacters } from "util";
 import { getSupportedThinkingLevels } from "@earendil-works/pi-ai";
 import {
-  defineDoc,
-  defineExtension as defineExtension3,
-  defineTask,
+  defineDoc as defineDoc2,
+  defineExtension as defineExtension5,
+  defineTask as defineTask2,
   InboxDoc,
-  LiveDoc
+  LiveDoc as LiveDoc2
 } from "@earendil-works/pi-durable";
-var SessionMetadataDoc = defineDoc({
+var SessionMetadataDoc = defineDoc2({
   kind: "app.neko.session-metadata",
   version: 1,
   scope: "conversation",
@@ -1317,7 +2054,7 @@ function mergeUsage(base, extra) {
 function namingTask() {
   let active = 0;
   const waits = new Set;
-  return defineTask({
+  return defineTask2({
     name: "app.neko.name",
     version: 1,
     initial: () => ({ phase: "wait", until: Date.now() + 100 }),
@@ -1441,7 +2178,7 @@ class SessionMetadataManager {
     this.storage = storage;
     this.context = context;
     this.report = report;
-    registry.install(defineExtension3({ name: "neko-naming", tasks: [this.task] }));
+    registry.install(defineExtension5({ name: "neko-naming", tasks: [this.task] }));
     this.#unsubscribe = harness.subscribeCommits(({ changes }) => {
       const ids = new Set;
       const submissions = new Map;
@@ -1531,7 +2268,7 @@ class SessionMetadataManager {
       const answer = record.status === "done" ? (await this.storage.entry(record.answer, this.context))?.entry.model?.[0] : undefined;
       return { record, data, answer: answer?.role === "assistant" ? answer : undefined };
     }));
-    const live = await this.harness.snapshot(LiveDoc, id, this.context);
+    const live = await this.harness.snapshot(LiveDoc2, id, this.context);
     await this.harness.commit(async (tx) => {
       const d = await tx.doc(SessionMetadataDoc, id);
       for (const { record, data, answer } of updates) {
@@ -1580,9 +2317,192 @@ class SessionMetadataManager {
   }
 }
 
+// packages/core/src/tool-approvals.ts
+import { randomUUID } from "crypto";
+import { realpath } from "fs/promises";
+import {
+  configure as configure2,
+  defineDoc as defineDoc3,
+  defineExtension as defineExtension6,
+  hook as hook2,
+  ToolTask as ToolTask2,
+  wrapTool
+} from "@earendil-works/pi-durable";
+import { createBashTool } from "@earendil-works/pi-durable/tools";
+var ApprovalsDoc = defineDoc3({
+  kind: "app.neko.approvals",
+  version: 1,
+  scope: "conversation",
+  history: "latest",
+  fork: "initial",
+  initial: () => ({ items: [] })
+});
+async function live(tx, id) {
+  const task = await tx.task(id);
+  return !!task && !task.abortRequested && task.state.status !== "terminal" && task.state.status !== "completing";
+}
+
+class ToolApprovals {
+  harness;
+  #parents = new Set;
+  constructor(harness, context) {
+    this.harness = harness;
+    const stop = harness.subscribeCommits(({ changes }) => {
+      if (!changes.some((c) => c.type === "task" && (c.value.abortRequested || c.value.state.status === "terminal")))
+        return;
+      for (const parent of this.#parents)
+        this.list(parent, context).catch(() => {});
+    });
+    harness.closed.finally(stop).catch(() => {});
+  }
+  async list(parent, context) {
+    this.#parents.add(parent);
+    return this.harness.commit(async (tx) => {
+      const doc = await tx.doc(ApprovalsDoc, parent);
+      for (const item of doc.items) {
+        if (item.status === "pending" && (!await live(tx, item.id) || !await live(tx, item.delegationTaskId))) {
+          item.status = "cancelled";
+          item.decidedAt = Date.now();
+        }
+      }
+      return JSON.parse(JSON.stringify(doc.items));
+    }, context);
+  }
+  async decide(parent, delegationTaskId, id, version, decision, context) {
+    return this.harness.commit(async (tx) => {
+      const delegation = (await tx.doc(DelegationsDoc, parent)).items.find((d) => d.taskId === delegationTaskId);
+      const item = (await tx.doc(ApprovalsDoc, parent)).items.find((a) => a.id === id);
+      if (!delegation || delegation.historyThrough !== undefined || !item || item.delegationTaskId !== delegationTaskId || item.childId !== delegation.childId || item.version !== version)
+        throw new Error("Approval does not belong to this task or has changed");
+      if (item.status !== "pending")
+        return item.status;
+      item.status = await live(tx, id) && await live(tx, delegationTaskId) ? decision : "cancelled";
+      item.decidedAt = Date.now();
+      return item.status;
+    }, context);
+  }
+  async wait(parent, id, context) {
+    const state = await this.harness.documentState(ApprovalsDoc, parent, context);
+    if (!state)
+      throw new Error("Approval unavailable");
+    try {
+      return await new Promise((resolve, reject) => {
+        let stop = () => {};
+        const cleanup = () => {
+          stop();
+          context.abortSignal?.removeEventListener("abort", abort);
+        };
+        const abort = () => {
+          cleanup();
+          reject(context.abortSignal?.reason ?? new Error("Cancelled"));
+        };
+        const check = () => {
+          const item = state.value?.items.find((a) => a.id === id);
+          if (item && item.status !== "pending") {
+            cleanup();
+            resolve(structuredClone(item));
+          }
+        };
+        stop = state.subscribe(check);
+        context.abortSignal?.addEventListener("abort", abort, { once: true });
+        if (context.abortSignal?.aborted)
+          abort();
+        else
+          check();
+      });
+    } finally {
+      state.dispose();
+    }
+  }
+  async ensure(parent, candidate, context) {
+    this.#parents.add(parent);
+    return this.harness.commit(async (tx) => {
+      if (!await live(tx, candidate.id) || !await live(tx, candidate.delegationTaskId))
+        throw new Error("Task stopped");
+      const doc = await tx.doc(ApprovalsDoc, parent);
+      const existing = doc.items.find((a) => a.id === candidate.id);
+      if (existing) {
+        if (existing.command !== candidate.command || existing.cwd !== candidate.cwd || existing.timeout !== candidate.timeout || existing.childId !== candidate.childId)
+          throw new Error("Approval operation changed; a new call is required");
+        return;
+      }
+      doc.items.push({
+        ...candidate,
+        version: randomUUID(),
+        status: "pending",
+        createdAt: Date.now(),
+        decidedAt: null
+      });
+    }, context);
+  }
+}
+function createApprovalExtension(service) {
+  return defineExtension6({
+    name: "neko-tool-approvals",
+    hooks: [
+      hook2(ToolTask2, {
+        beforeTool: async (call, api, context) => {
+          const role = await api.snapshot(SubagentDoc, api.conversationId, context);
+          if (role?.role !== "explore" || call.name !== "bash")
+            return;
+          if (role.parentId === null)
+            return { block: "Missing parent session" };
+          const approvals = service(), parent = role.parentId;
+          const child = await approvals.harness.conversation(api.conversationId, context);
+          const agent = await child.agent(context);
+          const cwd = await realpath(agent.cwd);
+          const identity = (await api.snapshot(SubagentsDoc, parent, context))?.items.find((a) => a.childId === api.conversationId);
+          const delegation = (await api.snapshot(DelegationsDoc, parent, context))?.items.find((d) => d.childId === api.conversationId && d.historyThrough === undefined && d.taskId === identity?.activeRoundId);
+          if (!delegation)
+            return { block: "Missing delegation" };
+          await approvals.ensure(parent, {
+            id: api.taskId,
+            childId: api.conversationId,
+            delegationTaskId: delegation.taskId,
+            callId: call.id,
+            command: String(call.arguments.command),
+            cwd,
+            timeout: typeof call.arguments.timeout === "number" ? call.arguments.timeout : null
+          }, context);
+          const result = await approvals.wait(parent, api.taskId, context);
+          return result.status === "allowed" ? undefined : { block: "Command denied or cancelled by user. Use another approach or report the limitation." };
+        }
+      })
+    ],
+    wraps: [
+      wrapTool(createBashTool(), (bash) => ({
+        ...bash,
+        execute: async (args, api, context) => {
+          const role = await api.snapshot(SubagentDoc, api.conversationId, context);
+          if (role?.role === "explore") {
+            const item = role.parentId === null ? undefined : (await api.snapshot(ApprovalsDoc, role.parentId, context))?.items.find((a) => a.id === api.taskId);
+            const cwd = api.env && await api.env.canonicalPath(api.env.cwd, context);
+            if (!item || item.status !== "allowed" || item.command !== args.command || item.timeout !== (args.timeout ?? null) || !cwd?.ok || cwd.value !== item.cwd)
+              throw new Error("Bash approval missing or operation changed");
+          }
+          context.abortSignal?.throwIfAborted();
+          return bash.execute(args, api, context);
+        }
+      }))
+    ]
+  });
+}
+async function prepareApprovalConversations(harness, ids, extension, context) {
+  for (const id of ids) {
+    if ((await harness.snapshot(SubagentDoc, id, context))?.role !== "explore")
+      continue;
+    const child = await harness.conversation(id, context);
+    const agent = await child.agent(context);
+    await harness.commit((tx) => configure2(tx, id, {
+      tools: [...agent.tools.filter((t) => t.name !== "bash"), createBashTool()],
+      extensions: { add: [extension] }
+    }), context);
+  }
+}
+
 // packages/core/src/web-search.ts
-import { Type } from "@earendil-works/pi-ai";
-import { defineExtension as defineExtension4, defineTool } from "@earendil-works/pi-durable";
+import { Type as Type3 } from "@earendil-works/pi-ai";
+import { defineExtension as defineExtension7, defineTool as defineTool3 } from "@earendil-works/pi-durable";
 var SEARCH_URL = "https://api.tavily.com/search";
 var EXTRACT_URL = "https://api.tavily.com/extract";
 var REQUEST_TIMEOUT_MS = 30000;
@@ -1700,15 +2620,15 @@ function urlKey(value) {
   }
 }
 function createWebSearchTools(resolveKey, fetchImpl = fetch) {
-  return defineExtension4({
+  return defineExtension7({
     name: "neko-web-search",
     tools: [
-      defineTool({
+      defineTool3({
         name: "web_search",
         description: "Search the live web for current or unknown information. Returns ranked sources (title, URL, bounded excerpts). Use only when up-to-date or external information is needed; use web_extract to read a known URL.",
-        parameters: Type.Object({
-          query: Type.String({ minLength: 1, maxLength: 4096, description: "The search query" }),
-          maxResults: Type.Optional(Type.Number({ description: `Maximum number of results (1-${MAX_RESULTS}, default ${DEFAULT_RESULTS})` }))
+        parameters: Type3.Object({
+          query: Type3.String({ minLength: 1, maxLength: 4096, description: "The search query" }),
+          maxResults: Type3.Optional(Type3.Number({ description: `Maximum number of results (1-${MAX_RESULTS}, default ${DEFAULT_RESULTS})` }))
         }),
         async execute({ query, maxResults }, _api, context) {
           try {
@@ -1733,11 +2653,11 @@ ${truncate(String(item.url ?? ""), 300)}
           }
         }
       }),
-      defineTool({
+      defineTool3({
         name: "web_extract",
         description: "Extract bounded markdown excerpts from web pages by URL. Every requested URL has a result or failure entry; long content is truncated.",
-        parameters: Type.Object({
-          urls: Type.Array(Type.String({ maxLength: 2048, description: "http(s) URL" }), {
+        parameters: Type3.Object({
+          urls: Type3.Array(Type3.String({ maxLength: 2048, description: "http(s) URL" }), {
             minItems: 1,
             maxItems: MAX_URLS,
             description: `URLs to extract (1-${MAX_URLS})`
@@ -1782,10 +2702,10 @@ ${truncate(String(item.url ?? ""), 300)}
 }
 
 // packages/core/src/workspace-files.ts
-import { realpath, stat } from "fs/promises";
+import { realpath as realpath2, stat } from "fs/promises";
 import { basename as basename2, isAbsolute as isAbsolute2, relative, resolve as resolve3, sep } from "path";
-import { BACKGROUND_CONTEXT, withAbortSignal } from "@earendil-works/chord/context";
-import { getOrThrow } from "@earendil-works/pi-durable/env";
+import { BACKGROUND_CONTEXT as BACKGROUND_CONTEXT2, withAbortSignal as withAbortSignal2 } from "@earendil-works/chord/context";
+import { getOrThrow as getOrThrow2 } from "@earendil-works/pi-durable/env";
 import { Connection, LocalExecutionEnv, localDaemon } from "@earendil-works/pi-env";
 function relativeQuery(query) {
   if (query.length > 2048 || [...query].some((c) => c.charCodeAt(0) < 32 || c === '"' || c === "\\") || isAbsolute2(query) || query.startsWith("~") || query.split("/").some((part) => part === ".." || part === ".git"))
@@ -1793,8 +2713,8 @@ function relativeQuery(query) {
   return query.replace(/^\.\//, "");
 }
 async function workspaceTarget(root, path) {
-  const base = await realpath(root);
-  const target = await realpath(resolve3(base, relativeQuery(path)));
+  const base = await realpath2(root);
+  const target = await realpath2(resolve3(base, relativeQuery(path)));
   const local = relative(base, target);
   if (local === ".." || local.startsWith(`..${sep}`) || isAbsolute2(local))
     throw new Error("Path is outside the workspace.");
@@ -1903,7 +2823,7 @@ class WorkspaceFiles {
   }
   #disposeWatch(watch) {
     watch.controller.abort();
-    const closing = watch.work.catch(() => {}).then(() => watch.watcher?.close(BACKGROUND_CONTEXT)).then(() => {}).catch(() => {}).finally(() => this.#disposing.delete(closing));
+    const closing = watch.work.catch(() => {}).then(() => watch.watcher?.close(BACKGROUND_CONTEXT2)).then(() => {}).catch(() => {}).finally(() => this.#disposing.delete(closing));
     this.#disposing.add(closing);
   }
   #closeWatcher(item) {
@@ -1950,11 +2870,11 @@ class WorkspaceFiles {
             for (const user of [...current.users])
               this.#closeWatcher(user);
           }
-        }, withAbortSignal(current.controller.signal, BACKGROUND_CONTEXT));
+        }, withAbortSignal2(current.controller.signal, BACKGROUND_CONTEXT2));
         if (result.ok) {
           current.watcher = result.value;
           if (current.controller.signal.aborted)
-            await result.value.close(BACKGROUND_CONTEXT);
+            await result.value.close(BACKGROUND_CONTEXT2);
         } else {
           forget();
         }
@@ -1978,7 +2898,7 @@ class WorkspaceFiles {
   async#scan(item) {
     const controller = new AbortController;
     item.controller = controller;
-    const context = withAbortSignal(controller.signal, BACKGROUND_CONTEXT);
+    const context = withAbortSignal2(controller.signal, BACKGROUND_CONTEXT2);
     while (this.#active >= this.limits.concurrent) {
       await new Promise((resolve, reject) => {
         const wake = () => {
@@ -2023,7 +2943,7 @@ class WorkspaceFiles {
           i.generation++;
         }
       }
-      const listing = getOrThrow(result);
+      const listing = getOrThrow2(result);
       controller.signal.throwIfAborted();
       if (this.#closed || item.generation !== generation)
         throw new Error("Workspace changed during file search. Retry.");
@@ -2043,7 +2963,7 @@ class WorkspaceFiles {
       throw new Error("File environment closed");
     query = relativeQuery(query);
     const slash = query.lastIndexOf("/"), prefix = slash < 0 ? "" : query.slice(0, slash + 1), needle = query.slice(slash + 1);
-    root = await realpath(root);
+    root = await realpath2(root);
     const base = await workspaceTarget(root, prefix);
     if (!(await stat(base)).isDirectory())
       throw new Error("Workspace directory is unavailable.");
@@ -2144,7 +3064,7 @@ function cancellable(work, signal) {
 // packages/core/src/runtime.ts
 var DEFAULT_MODEL = { provider: "deepseek", modelId: "deepseek-flash" };
 var DEFAULT_STORAGE_PATH = join5(homedir4(), ".neko", "neko.sqlite");
-var ArchivedDoc = defineDoc2({
+var ArchivedDoc = defineDoc4({
   kind: "app.neko.conversation",
   version: 1,
   scope: "conversation",
@@ -2152,7 +3072,7 @@ var ArchivedDoc = defineDoc2({
   fork: "initial",
   initial: () => ({ archived: false })
 });
-var WorkspacesDoc = defineDoc2({
+var WorkspacesDoc = defineDoc4({
   kind: "app.neko.workspaces",
   version: 1,
   scope: "conversation",
@@ -2160,7 +3080,7 @@ var WorkspacesDoc = defineDoc2({
   fork: "initial",
   initial: () => ({ items: [] })
 });
-var ActivityDoc = defineDoc2({
+var ActivityDoc = defineDoc4({
   kind: "app.neko.activity",
   version: 1,
   scope: "conversation",
@@ -2169,7 +3089,7 @@ var ActivityDoc = defineDoc2({
   initial: () => ({ lastUsedAt: 0 })
 });
 async function createNekoRuntime(options = {}) {
-  const context = options.context ?? BACKGROUND_CONTEXT2;
+  const context = options.context ?? BACKGROUND_CONTEXT3;
   const defaultCwd = normalizeWorkspace(options.cwd);
   const model = options.model ?? DEFAULT_MODEL;
   const providers = options.providers ?? [];
@@ -2205,6 +3125,7 @@ async function createNekoRuntime(options = {}) {
   const registry = createRegistry();
   registry.install(createCodingTools({ images: await createNodePhotonImages() }));
   registry.install(ImageDetails);
+  registry.install(AgentFileSearch);
   registry.install(createWebSearchTools(async () => {
     const saved = await effectiveCredentials.read("tavily");
     if (saved?.type === "api_key" && saved.key)
@@ -2214,8 +3135,14 @@ async function createNekoRuntime(options = {}) {
   const loadResources = createResourceLoader(options.promptHome);
   const resourceSnapshots = createResourceSnapshots(loadResources, (id, requestId) => storage.submissionByRequest(id, requestId, context));
   registry.install(createNekoPrompt(resourceSnapshots.current));
+  registry.install(createSubagentExtension(async (id, requestId, cwd) => {
+    resourceSnapshots.stage(id, requestId, cwd, await loadResources(cwd));
+  }, resourceSnapshots.discard));
   for (const extension of options.extensions ?? [])
     registry.install(extension);
+  let approvals;
+  const approvalExtension = createApprovalExtension(() => approvals);
+  registry.install(approvalExtension);
   const harness = await Harness.open(storage, {
     models,
     registry,
@@ -2235,8 +3162,11 @@ async function createNekoRuntime(options = {}) {
     } while (cursor);
     return records;
   }, context);
+  approvals = new ToolApprovals(harness, context);
   const existing = await scanConversations();
   try {
+    await installSubagentCoordinator(harness, existing.map((r) => r.id), context);
+    await prepareApprovalConversations(harness, existing.map((r) => r.id), approvalExtension, context);
     for (const record of existing) {
       const target = await harness.conversation(record.id, context);
       if (target) {
@@ -2287,7 +3217,7 @@ async function createNekoRuntime(options = {}) {
   if (existing.length === 0)
     await metadata.initialize(conversation.id);
   for (const record of existing)
-    if (!(await harness.snapshot(ArchivedDoc, record.id, context))?.archived)
+    if (!record.owner && !(await harness.snapshot(ArchivedDoc, record.id, context))?.archived)
       await metadata.restore(record.id);
   let closing;
   const cleanup = () => {
@@ -2389,7 +3319,7 @@ async function createNekoRuntime(options = {}) {
     await metadata.flush();
     await metadata.reconcile(target.id);
     if (settled.status === "done" && settled.type === "input") {
-      const entry = await target.commit((tx) => tx.entry(AssistantEntry, settled.answer), context);
+      const entry = await target.commit((tx) => tx.entry(AssistantEntry2, settled.answer), context);
       const message = entry?.model?.[0];
       const text = message?.role === "assistant" ? message.content.flatMap((block) => block.type === "text" ? [block.text] : []).join("") : "";
       return { status: "done", text };
@@ -2420,7 +3350,7 @@ async function createNekoRuntime(options = {}) {
       return watchEvents(harness, target.id, context);
     },
     async usage() {
-      return mergeUsage(await harness.snapshot(UsageDoc, target.id, context) ?? { models: {}, tools: {} }, (await harness.snapshot(SessionMetadataDoc, target.id, context))?.namingUsage ?? { models: {}, tools: {} });
+      return mergeUsage(await harness.snapshot(UsageDoc2, target.id, context) ?? { models: {}, tools: {} }, (await harness.snapshot(SessionMetadataDoc, target.id, context))?.namingUsage ?? { models: {}, tools: {} });
     },
     compactionRecord() {
       return readCompaction(harness, storage, target.id, context);
@@ -2454,7 +3384,8 @@ async function createNekoRuntime(options = {}) {
     if (target === undefined)
       return;
     const archived = (await harness.snapshot(ArchivedDoc, id, context))?.archived ?? false;
-    return archived ? undefined : makeSession(target);
+    const record = await harness.commit((tx) => tx.conversation(id), context);
+    return archived || record?.owner ? undefined : makeSession(target);
   };
   return {
     context,
@@ -2468,7 +3399,7 @@ async function createNekoRuntime(options = {}) {
     async globalUsage() {
       let total = { models: {}, tools: {} };
       for (const record of await scanConversations()) {
-        total = mergeUsage(total, await harness.snapshot(UsageDoc, record.id, context) ?? { models: {}, tools: {} });
+        total = mergeUsage(total, await harness.snapshot(UsageDoc2, record.id, context) ?? { models: {}, tools: {} });
         total = mergeUsage(total, (await harness.snapshot(SessionMetadataDoc, record.id, context))?.namingUsage ?? { models: {}, tools: {} });
       }
       return total;
@@ -2485,24 +3416,70 @@ async function createNekoRuntime(options = {}) {
       const newest = await source.conversation.entries({}, 1, undefined, context);
       const at = newest.items[0]?.id;
       const sourceMetadata = at === undefined ? undefined : await harness.snapshot(SessionMetadataDoc, id, context);
-      const child = at === undefined ? await harness.createConversation({
-        ownership: { kind: "ownerless" },
-        agent: { model: agent.model, thinkingLevel: agent.thinkingLevel, cwd: savedWorkspace(agent.cwd) }
-      }, context) : await source.conversation.fork(at, {
-        ownership: { kind: "ownerless" },
-        init: async (tx, childId) => {
-          const doc = await tx.doc(SessionMetadataDoc, childId);
+      const childId = await harness.commit(async (tx) => {
+        const inherited = [];
+        if (at !== undefined) {
+          const references = await refreshDelegations(tx, id);
+          const calls = new Set;
+          let cursor;
+          do {
+            const page = await tx.scanEntries({ conversationId: id, maxEntryId: at }, 100, cursor);
+            for (const entry of page.items)
+              for (const message of entry.model ?? []) {
+                if (message.role === "assistant")
+                  for (const block of message.content) {
+                    if (block.type === "toolCall")
+                      calls.add(block.id);
+                  }
+              }
+            cursor = page.next;
+          } while (cursor);
+          const frozen = new Map;
+          for (const reference of references) {
+            if (!calls.has(reference.callId))
+              continue;
+            let snapshot = frozen.get(reference.childId);
+            if (!snapshot) {
+              const latest = await tx.scanEntries({ conversationId: reference.childId }, 1);
+              snapshot = {
+                through: latest.items[0]?.id ?? 0,
+                state: JSON.parse(JSON.stringify(await tx.doc(UsageDoc2, reference.childId)))
+              };
+              frozen.set(reference.childId, snapshot);
+            }
+            const usage = totalUsage(snapshot.state);
+            inherited.push({
+              ...reference,
+              historyThrough: reference.historyThrough ?? snapshot.through,
+              roundUsage: reference.roundUsage ?? (reference.usageStart ? subagentUsageTotals(subtractSubagentUsage(snapshot.state, reference.usageStart)) : null),
+              historyUsage: reference.historyUsage ?? {
+                input: usage.input,
+                output: usage.output,
+                cacheRead: usage.cacheRead,
+                cacheWrite: usage.cacheWrite,
+                cost: usage.cost.total
+              }
+            });
+          }
+        }
+        const child = at === undefined ? await tx.createConversation({ ownership: { kind: "ownerless" } }) : await tx.forkConversation(id, at, { ownership: { kind: "ownerless" } });
+        (await tx.doc(DelegationsDoc, child.id)).items = inherited;
+        if (sourceMetadata) {
+          const doc = await tx.doc(SessionMetadataDoc, child.id);
           doc.title = sourceMetadata.title || sourceMetadata.firstPromptPreview;
           doc.firstPromptPreview = sourceMetadata.firstPromptPreview;
           doc.naming = "ready";
         }
+        return child.id;
       }, context);
+      const child = await harness.conversation(childId, context);
       await child.configure({ model: agent.model, thinkingLevel: agent.thinkingLevel, cwd: savedWorkspace(agent.cwd) }, context);
       await metadata.initialize(child.id);
       await touchConversation(child.id);
       return makeSession(child);
     },
     harness,
+    approvals,
     closed: harness.closed,
     workspaceFiles,
     conversation,
@@ -2528,6 +3505,8 @@ async function createNekoRuntime(options = {}) {
       const records = await scanConversations();
       const infos = [];
       for (const record of records) {
+        if (record.owner)
+          continue;
         const archived = (await harness.snapshot(ArchivedDoc, record.id, context))?.archived ?? false;
         if (!archived) {
           const target = await harness.conversation(record.id, context);
@@ -2566,6 +3545,7 @@ async function createNekoRuntime(options = {}) {
     },
     getConversation,
     async archiveConversation(id) {
+      await (await sessionFor(id)).abort();
       await metadata.archive(id);
       await harness.commit(async (tx) => {
         (await tx.doc(ArchivedDoc, id)).archived = true;
@@ -2690,13 +3670,13 @@ async function removeGatewayPortFile(nekoDir, serverId) {
 }
 
 // packages/gateway/src/server-services.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 import {
-  ChordError as ChordError2,
-  cell as cell2,
-  hostPrincipal as hostPrincipal2,
-  listener as listener2,
-  local as local2,
+  ChordError as ChordError3,
+  cell as cell3,
+  hostPrincipal as hostPrincipal3,
+  listener as listener3,
+  local as local3,
   method as method2
 } from "@earendil-works/chord";
 
@@ -2707,8 +3687,8 @@ import { dirname as dirname5, join as join7 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // packages/core/src/application-version.ts
-var RUNNING_VERSION = "0.2.9";
-var APPLICATION_PROTOCOL = 1;
+var RUNNING_VERSION = "0.3.1";
+var APPLICATION_PROTOCOL = 4;
 function stableVersion(value) {
   return typeof value === "string" && /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(value) && value.split(".").every((n) => Number.isSafeInteger(Number(n)));
 }
@@ -2857,11 +3837,11 @@ class UpdateChecker {
 }
 
 // packages/gateway/src/server-services.ts
-import { Type as Type4 } from "typebox";
+import { Type as Type7 } from "typebox";
 
 // packages/gateway/src/contract.ts
 import { method, remote } from "@earendil-works/chord";
-import { Type as Type2 } from "typebox";
+import { Type as Type4 } from "typebox";
 var rpc = (args, result) => [args, result];
 function contract(name, def) {
   const variants = Object.fromEntries(Object.entries(def.variants).map(([key, value]) => [
@@ -2873,19 +3853,19 @@ function contract(name, def) {
   ]));
   return remote(name, { ...def, variants });
 }
-var str = Type2.String();
-var num = Type2.Number();
-var bool = Type2.Boolean();
-var nil = Type2.Null();
-var integer = Type2.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER });
-var nullableString = Type2.Union([str, nil]);
-var phase = Type2.Enum(["pending", "running", "done"]);
-var level = Type2.Enum(["project", "user", "builtin"]);
-var thinking = Type2.Enum(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
-var model = Type2.Object({ provider: str, modelId: str });
-var change = Type2.Object({ model: Type2.Optional(model), thinkingLevel: Type2.Optional(thinking) }, { additionalProperties: false });
-var usage = Type2.Object({ input: num, output: num, cacheRead: num, cacheWrite: num, cost: num });
-var image = Type2.Object({
+var str = Type4.String();
+var num = Type4.Number();
+var bool = Type4.Boolean();
+var nil = Type4.Null();
+var integer = Type4.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER });
+var nullableString = Type4.Union([str, nil]);
+var phase = Type4.Enum(["pending", "running", "done"]);
+var level = Type4.Enum(["project", "user", "builtin"]);
+var thinking = Type4.Enum(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
+var model = Type4.Object({ provider: str, modelId: str });
+var change = Type4.Object({ model: Type4.Optional(model), thinkingLevel: Type4.Optional(thinking) }, { additionalProperties: false });
+var usage = Type4.Object({ input: num, output: num, cacheRead: num, cacheWrite: num, cost: num });
+var image = Type4.Object({
   name: str,
   mimeType: str,
   width: integer,
@@ -2894,8 +3874,8 @@ var image = Type2.Object({
   entryId: integer,
   contentIndex: integer
 });
-var skill = Type2.Object({ name: str, location: str, body: str, args: str });
-var call = Type2.Object({
+var skill = Type4.Object({ name: str, location: str, body: str, args: str });
+var call = Type4.Object({
   callId: str,
   name: str,
   summary: str,
@@ -2903,44 +3883,90 @@ var call = Type2.Object({
   phase,
   output: nullableString
 });
-var ChatViewSchema = Type2.Object({
+var DelegationSchema = Type4.Object({
+  parentId: integer,
+  agentId: Type4.Optional(str),
+  round: Type4.Optional(integer),
+  runnerId: Type4.Optional(integer),
+  inputEntryId: Type4.Optional(integer),
+  answerEntryId: Type4.Optional(integer),
+  roundUsage: Type4.Optional(Type4.Union([usage, nil])),
+  taskId: integer,
+  callId: str,
+  childId: integer,
+  role: Type4.Enum(["explore", "plan", "coder"]),
+  title: str,
+  createdAt: num,
+  startedAt: Type4.Union([num, nil]),
+  endedAt: Type4.Union([num, nil]),
+  status: Type4.Enum(["queued", "running", "completed", "failed", "cancelled"]),
+  report: nullableString,
+  approvalCount: Type4.Optional(integer),
+  historyThrough: Type4.Optional(integer),
+  historyUsage: Type4.Optional(usage)
+});
+var SubagentSummarySchema = Type4.Object({
+  agentId: str,
+  parentId: integer,
+  childId: integer,
+  role: Type4.Enum(["explore", "plan", "coder"]),
+  title: str,
+  status: Type4.Enum(["idle", "queued", "running"]),
+  activeRoundId: Type4.Union([integer, nil]),
+  lastRoundId: integer,
+  lastReport: Type4.Optional(nullableString),
+  roundCount: integer,
+  taskTitle: str,
+  approvalCount: integer,
+  createdAt: num,
+  historyThrough: Type4.Optional(integer),
+  historyUsage: Type4.Optional(usage)
+});
+var ChatViewSchema = Type4.Object({
+  historyBefore: Type4.Optional(Type4.Union([integer, nil])),
+  agents: Type4.Optional(Type4.Array(SubagentSummarySchema)),
+  rounds: Type4.Optional(Type4.Array(DelegationSchema)),
+  subagents: Type4.Optional(Type4.Array(DelegationSchema)),
+  taskUsage: Type4.Optional(usage),
   model: str,
-  agent: Type2.Object({ model: Type2.Union([model, nil]), thinkingLevel: Type2.Union([thinking, nil]) }),
+  agent: Type4.Object({ model: Type4.Union([model, nil]), thinkingLevel: Type4.Union([thinking, nil]) }),
   cwd: str,
   busy: bool,
   status: nullableString,
   usage,
-  contextUsage: Type2.Optional(Type2.Object({ tokens: Type2.Union([num, nil]), window: num, percent: Type2.Union([num, nil]) })),
-  compaction: Type2.Optional(Type2.Object({
-    failure: Type2.Optional(Type2.Object({ taskId: integer, reason: Type2.Enum(["manual", "threshold", "overflow"]), error: str })),
-    active: Type2.Array(Type2.Object({
+  contextUsage: Type4.Optional(Type4.Object({ tokens: Type4.Union([num, nil]), window: num, percent: Type4.Union([num, nil]) })),
+  compaction: Type4.Optional(Type4.Object({
+    failure: Type4.Optional(Type4.Object({ taskId: integer, reason: Type4.Enum(["manual", "threshold", "overflow"]), error: str })),
+    active: Type4.Array(Type4.Object({
       taskId: integer,
-      reason: Type2.Enum(["manual", "threshold", "overflow"]),
+      reason: Type4.Enum(["manual", "threshold", "overflow"]),
       blocking: bool,
       attempt: integer,
-      retry: Type2.Optional(Type2.Object({ at: num, error: str }))
+      retry: Type4.Optional(Type4.Object({ at: num, error: str }))
     })),
-    latest: Type2.Union([
+    latest: Type4.Union([
       nil,
-      Type2.Object({
+      Type4.Object({
         taskId: integer,
-        phase: Type2.Enum(["summarizing", "waiting-to-apply", "applied", "nothing", "skipped", "cancelled", "failed"]),
+        phase: Type4.Enum(["summarizing", "waiting-to-apply", "applied", "nothing", "skipped", "cancelled", "failed"]),
         at: num
       })
     ])
   })),
-  items: Type2.Array(Type2.Union([
-    Type2.Object({
-      type: Type2.Literal("user"),
+  items: Type4.Array(Type4.Union([
+    Type4.Object({
+      type: Type4.Literal("user"),
+      order: Type4.Optional(num),
       key: str,
       id: integer,
       text: str,
-      images: Type2.Optional(Type2.Array(image)),
-      skill: Type2.Optional(skill),
-      defaultImagePrompt: Type2.Optional(Type2.Object({ version: Type2.Integer({ minimum: 1 }), text: str }))
+      images: Type4.Optional(Type4.Array(image)),
+      skill: Type4.Optional(skill),
+      defaultImagePrompt: Type4.Optional(Type4.Object({ version: Type4.Integer({ minimum: 1 }), text: str }))
     }),
-    Type2.Object({
-      type: Type2.Literal("assistant"),
+    Type4.Object({
+      type: Type4.Literal("assistant"),
+      order: Type4.Optional(num),
       key: str,
       id: integer,
       thinking: str,
@@ -2949,10 +3975,11 @@ var ChatViewSchema = Type2.Object({
       errorMessage: nullableString,
       note: nullableString
     }),
-    Type2.Object({
-      type: Type2.Literal("tool"),
+    Type4.Object({
+      type: Type4.Literal("tool"),
+      order: Type4.Optional(num),
       key: str,
-      images: Type2.Optional(Type2.Array(image)),
+      images: Type4.Optional(Type4.Array(image)),
       callId: str,
       name: str,
       summary: str,
@@ -2961,50 +3988,50 @@ var ChatViewSchema = Type2.Object({
       isError: bool,
       output: nullableString,
       result: nullableString,
-      durationMs: Type2.Union([num, nil]),
+      durationMs: Type4.Union([num, nil]),
       note: nullableString
     }),
-    Type2.Object({ type: Type2.Literal("system"), key: str, id: integer, text: str })
+    Type4.Object({ type: Type4.Literal("system"), order: Type4.Optional(num), key: str, id: integer, text: str })
   ])),
-  streaming: Type2.Union([nil, Type2.Object({ thinking: str, text: str, toolCalls: Type2.Array(call) })])
+  streaming: Type4.Union([nil, Type4.Object({ thinking: str, text: str, toolCalls: Type4.Array(call) })])
 });
-var SessionSummarySchema = Type2.Object({
+var SessionSummarySchema = Type4.Object({
   workspaceRoot: str,
   lastUsedAt: num,
   title: str,
   firstPromptPreview: str,
   createdAt: num,
-  lastMessageAt: Type2.Union([num, nil]),
-  model: Type2.Union([model, nil]),
-  status: Type2.Enum(["idle", "running", "error"]),
+  lastMessageAt: Type4.Union([num, nil]),
+  model: Type4.Union([model, nil]),
+  status: Type4.Enum(["idle", "running", "error"]),
   id: str
 });
-var DirectoryStateSchema = Type2.Object({ revision: integer, sessions: Type2.Array(SessionSummarySchema) });
-var WorkspaceSummarySchema = Type2.Object({ path: str, createdAt: num });
-var WorkspaceStateSchema = Type2.Object({ revision: integer, workspaces: Type2.Array(WorkspaceSummarySchema) });
-var credentialStatus = Type2.Object({
+var DirectoryStateSchema = Type4.Object({ revision: integer, sessions: Type4.Array(SessionSummarySchema) });
+var WorkspaceSummarySchema = Type4.Object({ path: str, createdAt: num });
+var WorkspaceStateSchema = Type4.Object({ revision: integer, workspaces: Type4.Array(WorkspaceSummarySchema) });
+var credentialStatus = Type4.Object({
   savedConfigured: bool,
   environmentConfigured: bool,
-  source: Type2.Enum(["saved", "environment", "runtime", "keyless", "none"])
+  source: Type4.Enum(["saved", "environment", "runtime", "keyless", "none"])
 });
-var CredentialStateSchema = Type2.Object({
+var CredentialStateSchema = Type4.Object({
   revision: integer,
-  statuses: Type2.Object({ deepseek: credentialStatus, tavily: credentialStatus })
+  statuses: Type4.Object({ deepseek: credentialStatus, tavily: credentialStatus })
 });
-var AttachmentSchema = Type2.Object({ sessionId: str, attachmentId: str });
-var chatInput = Type2.Object({ sessionId: str, attachmentId: str }, { additionalProperties: false });
+var AttachmentSchema = Type4.Object({ sessionId: str, attachmentId: str });
+var chatInput = Type4.Object({ sessionId: str, attachmentId: str }, { additionalProperties: false });
 var NekoSessionDirectory = contract("neko.session-directory", {
   version: 1,
-  input: Type2.Object({}, { additionalProperties: false }),
+  input: Type4.Object({}, { additionalProperties: false }),
   variants: { ready: { state: { state: DirectoryStateSchema } } }
 });
 var NekoSessionManagement = contract("neko.session-management", {
   version: 1,
-  input: Type2.Object({}, { additionalProperties: false }),
+  input: Type4.Object({}, { additionalProperties: false }),
   variants: {
     ready: {
       methods: {
-        create: rpc(Type2.Object({ ...change.properties, cwd: Type2.Optional(str) }, { additionalProperties: false }), SessionSummarySchema),
+        create: rpc(Type4.Object({ ...change.properties, cwd: Type4.Optional(str) }, { additionalProperties: false }), SessionSummarySchema),
         archive: rpc(str, nil),
         attach: rpc(str, AttachmentSchema),
         detach: rpc(nil, nil),
@@ -3013,30 +4040,30 @@ var NekoSessionManagement = contract("neko.session-management", {
     }
   }
 });
-var resize = Type2.Object({
-  maxWidth: Type2.Optional(integer),
-  maxHeight: Type2.Optional(integer),
-  maxBytes: Type2.Optional(integer),
-  jpegQuality: Type2.Optional(integer)
+var resize = Type4.Object({
+  maxWidth: Type4.Optional(integer),
+  maxHeight: Type4.Optional(integer),
+  maxBytes: Type4.Optional(integer),
+  jpegQuality: Type4.Optional(integer)
 });
-var inputLimits = Type2.Object({
-  maxRequestBytes: Type2.Optional(integer),
-  images: Type2.Optional(Type2.Object({
-    resize: Type2.Optional(resize),
-    maxPerMessage: Type2.Optional(integer),
-    maxPerRequest: Type2.Optional(integer)
+var inputLimits = Type4.Object({
+  maxRequestBytes: Type4.Optional(integer),
+  images: Type4.Optional(Type4.Object({
+    resize: Type4.Optional(resize),
+    maxPerMessage: Type4.Optional(integer),
+    maxPerRequest: Type4.Optional(integer)
   }))
 });
-var modelInfo = Type2.Object({
+var modelInfo = Type4.Object({
   provider: str,
   modelId: str,
   name: str,
   contextWindow: num,
-  input: Type2.Array(str),
-  inputLimits: Type2.Optional(inputLimits),
+  input: Type4.Array(str),
+  inputLimits: Type4.Optional(inputLimits),
   reasoning: bool,
-  supportedThinkingLevels: Type2.Array(thinking),
-  thinkingLevelAdjustments: Type2.Object({
+  supportedThinkingLevels: Type4.Array(thinking),
+  thinkingLevelAdjustments: Type4.Object({
     off: thinking,
     minimal: thinking,
     low: thinking,
@@ -3048,10 +4075,35 @@ var modelInfo = Type2.Object({
 });
 var NekoModels = contract("neko.models", {
   version: 1,
-  input: Type2.Object({}, { additionalProperties: false }),
-  variants: { ready: { methods: { list: rpc(nil, Type2.Array(modelInfo)) } } }
+  input: Type4.Object({}, { additionalProperties: false }),
+  variants: { ready: { methods: { list: rpc(nil, Type4.Array(modelInfo)) } } }
+});
+var imageChunk = Type4.Object({ data: str, total: integer, mimeType: str });
+var NekoSubagent = contract("neko.subagent", {
+  version: 1,
+  input: Type4.Object({
+    sessionId: str,
+    attachmentId: str,
+    taskId: Type4.Optional(integer),
+    agentId: Type4.Optional(str)
+  }),
+  variants: {
+    ready: {
+      state: { revision: integer },
+      methods: {
+        chunk: rpc(Type4.Object({
+          kind: Type4.Enum(["view", "history"]),
+          before: Type4.Optional(integer),
+          token: Type4.Optional(integer),
+          offset: integer
+        }), Type4.Object({ token: integer, data: str, next: Type4.Union([integer, nil]) })),
+        getImage: rpc(Type4.Object({ entryId: integer, contentIndex: integer, offset: integer }), imageChunk),
+        decideApproval: rpc(Type4.Object({ id: integer, version: str, decision: Type4.Enum(["allowed", "denied"]) }), Type4.Enum(["pending", "allowed", "denied", "cancelled"])),
+        stop: rpc(Type4.Union([nil, Type4.Object({ taskId: integer })]), nil)
+      }
+    }
+  }
 });
-var imageChunk = Type2.Object({ data: str, total: integer, mimeType: str });
 var NekoChat = contract("neko.chat", {
   version: 1,
   input: chatInput,
@@ -3059,79 +4111,79 @@ var NekoChat = contract("neko.chat", {
     ready: {
       state: { view: ChatViewSchema },
       methods: {
-        submit: rpc(Type2.Object({
+        submit: rpc(Type4.Object({
           content: str,
-          images: Type2.Optional(Type2.Array(str, { maxItems: 4 })),
-          requestId: Type2.Optional(str),
-          whenBusy: Type2.Optional(Type2.Enum(["steer", "followUp"]))
+          images: Type4.Optional(Type4.Array(str, { maxItems: 4 })),
+          requestId: Type4.Optional(str),
+          whenBusy: Type4.Optional(Type4.Enum(["steer", "followUp"]))
         }, { additionalProperties: false }), nil),
         abort: rpc(nil, nil),
         usage: rpc(nil, usage),
-        skills: rpc(nil, Type2.Array(Type2.Object({ name: str, description: str, location: str, level }))),
+        skills: rpc(nil, Type4.Array(Type4.Object({ name: str, description: str, location: str, level }))),
         configure: rpc(change, nil),
-        compact: rpc(Type2.Object({ instructions: Type2.Optional(str) }, { additionalProperties: false }), nil),
-        importImage: rpc(str, Type2.Object({ id: str, name: str })),
-        draftImage: rpc(Type2.Object({ id: str, offset: integer }, { additionalProperties: false }), imageChunk),
-        beginImage: rpc(Type2.Object({ name: str, mimeType: str, size: Type2.Integer({ minimum: 1, maximum: 20971520 }) }, { additionalProperties: false }), str),
-        appendImage: rpc(Type2.Object({ id: str, offset: integer, data: Type2.String({ maxLength: 350000 }) }, { additionalProperties: false }), nil),
+        compact: rpc(Type4.Object({ instructions: Type4.Optional(str) }, { additionalProperties: false }), nil),
+        importImage: rpc(str, Type4.Object({ id: str, name: str })),
+        draftImage: rpc(Type4.Object({ id: str, offset: integer }, { additionalProperties: false }), imageChunk),
+        beginImage: rpc(Type4.Object({ name: str, mimeType: str, size: Type4.Integer({ minimum: 1, maximum: 20971520 }) }, { additionalProperties: false }), str),
+        appendImage: rpc(Type4.Object({ id: str, offset: integer, data: Type4.String({ maxLength: 350000 }) }, { additionalProperties: false }), nil),
         finishImage: rpc(str, nil),
         releaseImage: rpc(str, nil),
-        getImage: rpc(Type2.Object({ entryId: integer, contentIndex: integer, offset: integer }, { additionalProperties: false }), imageChunk)
+        getImage: rpc(Type4.Object({ entryId: integer, contentIndex: integer, offset: integer }, { additionalProperties: false }), imageChunk)
       }
     }
   }
 });
-var browse = Type2.Object({ path: str, query: Type2.Optional(str), showHidden: Type2.Optional(bool), cursor: Type2.Optional(str) }, { additionalProperties: false });
-var page = Type2.Object({
+var browse = Type4.Object({ path: str, query: Type4.Optional(str), showHidden: Type4.Optional(bool), cursor: Type4.Optional(str) }, { additionalProperties: false });
+var page = Type4.Object({
   path: str,
   parent: nullableString,
-  entries: Type2.Array(Type2.Object({ name: str, path: str, error: Type2.Optional(str) })),
+  entries: Type4.Array(Type4.Object({ name: str, path: str, error: Type4.Optional(str) })),
   next: nullableString
 });
 var NekoWorkspaces = contract("neko.workspaces", {
   version: 1,
-  input: Type2.Object({}, { additionalProperties: false }),
+  input: Type4.Object({}, { additionalProperties: false }),
   variants: {
     ready: {
       state: { state: WorkspaceStateSchema },
       methods: {
-        add: rpc(Type2.Object({ path: str }, { additionalProperties: false }), WorkspaceSummarySchema),
+        add: rpc(Type4.Object({ path: str }, { additionalProperties: false }), WorkspaceSummarySchema),
         browse: rpc(browse, page)
       }
     }
   }
 });
-var provider = Type2.Enum(["deepseek", "tavily"]);
+var provider = Type4.Enum(["deepseek", "tavily"]);
 var NekoCredentials = contract("neko.credentials", {
   version: 1,
-  input: Type2.Object({}, { additionalProperties: false }),
+  input: Type4.Object({}, { additionalProperties: false }),
   variants: {
     ready: {
       state: { state: CredentialStateSchema },
       methods: {
-        save: rpc(Type2.Object({ provider, key: Type2.String({ minLength: 1, maxLength: 8192 }) }, { additionalProperties: false }), nil),
-        remove: rpc(Type2.Object({ provider }, { additionalProperties: false }), nil)
+        save: rpc(Type4.Object({ provider, key: Type4.String({ minLength: 1, maxLength: 8192 }) }, { additionalProperties: false }), nil),
+        remove: rpc(Type4.Object({ provider }, { additionalProperties: false }), nil)
       }
     }
   }
 });
-var FileCandidatesSchema = Type2.Object({
-  entries: Type2.Array(Type2.Object({ name: str, path: str, kind: Type2.Enum(["file", "directory"]) }), { maxItems: 100 }),
+var FileCandidatesSchema = Type4.Object({
+  entries: Type4.Array(Type4.Object({ name: str, path: str, kind: Type4.Enum(["file", "directory"]) }), { maxItems: 100 }),
   limited: bool,
   incomplete: bool
 });
 var NekoWorkspaceFiles = contract("neko.workspace-files", {
   version: 1,
-  input: Type2.Object({}, { additionalProperties: false }),
+  input: Type4.Object({}, { additionalProperties: false }),
   variants: {
     ready: {
       methods: {
-        search: rpc(Type2.Object({ workspaceRoot: str, query: str }, { additionalProperties: false }), FileCandidatesSchema)
+        search: rpc(Type4.Object({ workspaceRoot: str, query: str }, { additionalProperties: false }), FileCandidatesSchema)
       }
     }
   }
 });
-var marketSkill = Type2.Object({
+var marketSkill = Type4.Object({
   name: str,
   description: str,
   category: str,
@@ -3141,38 +4193,38 @@ var marketSkill = Type2.Object({
   sha256: str,
   sizeBytes: integer,
   uploadedAt: str,
-  installed: Type2.Object({ project: bool, user: bool, builtin: bool }),
-  activeLevel: Type2.Union([level, nil])
+  installed: Type4.Object({ project: bool, user: bool, builtin: bool }),
+  activeLevel: Type4.Union([level, nil])
 });
-var preview = Type2.Object({ body: str, files: Type2.Array(str) });
-var scope = Type2.Enum(["user", "project"]);
-var installResult = Type2.Object({ name: str, scope, path: str, shadowedBy: Type2.Optional(scope) });
+var preview = Type4.Object({ body: str, files: Type4.Array(str) });
+var scope = Type4.Enum(["user", "project"]);
+var installResult = Type4.Object({ name: str, scope, path: str, shadowedBy: Type4.Optional(scope) });
 var NekoSkillMarket = contract("neko.skill-market", {
   version: 1,
-  input: Type2.Object({}, { additionalProperties: false }),
+  input: Type4.Object({}, { additionalProperties: false }),
   variants: {
     ready: {
       methods: {
-        list: rpc(Type2.Object({ query: Type2.Optional(str), workspaceRoot: Type2.Optional(str) }, { additionalProperties: false }), Type2.Array(marketSkill)),
-        detail: rpc(Type2.Object({ name: str, workspaceRoot: Type2.Optional(str) }, { additionalProperties: false }), marketSkill),
-        preview: rpc(Type2.Object({ name: str }, { additionalProperties: false }), preview),
-        install: rpc(Type2.Object({ name: str, scope, workspaceRoot: Type2.Optional(str), overwrite: Type2.Optional(bool) }, { additionalProperties: false }), installResult),
-        uninstall: rpc(Type2.Object({ name: str, scope, workspaceRoot: Type2.Optional(str) }, { additionalProperties: false }), nil)
+        list: rpc(Type4.Object({ query: Type4.Optional(str), workspaceRoot: Type4.Optional(str) }, { additionalProperties: false }), Type4.Array(marketSkill)),
+        detail: rpc(Type4.Object({ name: str, workspaceRoot: Type4.Optional(str) }, { additionalProperties: false }), marketSkill),
+        preview: rpc(Type4.Object({ name: str }, { additionalProperties: false }), preview),
+        install: rpc(Type4.Object({ name: str, scope, workspaceRoot: Type4.Optional(str), overwrite: Type4.Optional(bool) }, { additionalProperties: false }), installResult),
+        uninstall: rpc(Type4.Object({ name: str, scope, workspaceRoot: Type4.Optional(str) }, { additionalProperties: false }), nil)
       }
     }
   }
 });
-var ApplicationInfoSchema = Type2.Object({
+var ApplicationInfoSchema = Type4.Object({
   runningVersion: str,
   installedVersion: nullableString,
-  protocolVersion: Type2.Integer({ minimum: 1 }),
+  protocolVersion: Type4.Integer({ minimum: 1 }),
   latestVersion: nullableString,
-  checkedAt: Type2.Union([integer, nil]),
-  checkState: Type2.Enum(["unknown", "checking", "ok", "failed", "development"])
+  checkedAt: Type4.Union([integer, nil]),
+  checkState: Type4.Enum(["unknown", "checking", "ok", "failed", "development"])
 });
 var NekoApplicationInfo = contract("neko.application-info", {
   version: 1,
-  input: Type2.Object({}),
+  input: Type4.Object({}),
   variants: { ready: { state: { info: ApplicationInfoSchema }, methods: { check: rpc(nil, ApplicationInfoSchema) } } }
 });
 
@@ -3180,16 +4232,17 @@ var NekoApplicationInfo = contract("neko.application-info", {
 import { open as open2 } from "fs/promises";
 import { basename as basename3, extname } from "path";
 import {
-  ChordError,
-  cell,
-  hostPrincipal,
-  listener,
-  local,
-  opaque,
-  resource
+  ChordError as ChordError2,
+  cell as cell2,
+  hostPrincipal as hostPrincipal2,
+  listener as listener2,
+  local as local2,
+  opaque as opaque2,
+  resource as resource2
 } from "@earendil-works/chord";
-import { withAbortSignal as withAbortSignal2 } from "@earendil-works/chord/context";
-import { Type as Type3 } from "typebox";
+import { withAbortSignal as withAbortSignal3 } from "@earendil-works/chord/context";
+import { UsageDoc as UsageDoc4 } from "@earendil-works/pi-durable";
+import { Type as Type6 } from "typebox";
 
 // packages/gateway/src/image-uploads.ts
 var IMAGE_CHUNK_BYTES = 256 * 1024;
@@ -3285,19 +4338,259 @@ class ImageUploads {
   }
 }
 
+// packages/gateway/src/subagent-host.ts
+import {
+  ChordError,
+  cell,
+  hostPrincipal,
+  listener,
+  local,
+  opaque,
+  resource
+} from "@earendil-works/chord";
+import { UsageDoc as UsageDoc3 } from "@earendil-works/pi-durable";
+import { Type as Type5 } from "typebox";
+async function openReader(runtime, childId, parentId, context, through, historyUsage) {
+  const child = await runtime.harness.conversation(childId, context);
+  if (!child)
+    throw new ChordError("gone", "Subagent unavailable");
+  const native = await child.viewState(context);
+  if (through !== undefined)
+    native.dispose();
+  const project = (entries, streaming = true) => {
+    const result = projectChatView({ ...native.value, entries: [...entries].sort((a, b) => a.id - b.id) }, "", {
+      models: runtime.listModels(),
+      contextEntries: native.value.entries
+    });
+    if (!streaming || through !== undefined) {
+      result.streaming = null;
+      result.busy = false;
+      result.status = null;
+      if (through !== undefined) {
+        result.usage = historyUsage ?? { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
+        delete result.contextUsage;
+      }
+    }
+    let order = 0;
+    for (const item of result.items) {
+      if (item.type !== "tool")
+        order = item.id;
+      item.order = order;
+    }
+    return result;
+  };
+  const pageAt = async (before) => {
+    const max = Math.min(before === undefined ? Infinity : before - 1, through ?? Infinity);
+    const page = await child.entries(Number.isFinite(max) ? { maxEntryId: max } : {}, 100, undefined, context);
+    const entries = [...page.items];
+    while (page.next && !["assistant", "user"].includes(entries.at(-1)?.model?.[0]?.role ?? "")) {
+      const extra = await child.entries({ maxEntryId: entries.at(-1).id - 1 }, 1, undefined, context);
+      entries.push(...extra.items);
+      if (!extra.items.length || !extra.next)
+        break;
+    }
+    const first = entries.at(-1)?.id;
+    const older = first === undefined ? [] : (await child.entries({ maxEntryId: first - 1 }, 1, undefined, context)).items;
+    return { entries, next: older.length ? first : null };
+  };
+  let revision = 0;
+  let sequence = 0;
+  const payloads = new Map;
+  const remember = (value) => {
+    const token = ++sequence;
+    payloads.set(token, JSON.stringify(value));
+    while (payloads.size > 4) {
+      const oldest = [...payloads.keys()].find((key) => key !== revision);
+      payloads.delete(oldest);
+    }
+    return token;
+  };
+  return {
+    subscribe: (fn) => {
+      if (through !== undefined)
+        return () => {};
+      const stop = native.subscribe(() => fn(null));
+      const stopApprovals = runtime.harness.subscribeCommits(({ changes }) => {
+        if (changes.some((c) => c.type === "document" && ["app.neko.approvals", "app.neko.delegations", "app.neko.subagents"].includes(c.record.kind) && c.conversationId === parentId))
+          fn(null);
+      });
+      return () => {
+        stop();
+        stopApprovals();
+      };
+    },
+    async refresh() {
+      const page = await pageAt();
+      const approvals = through === undefined ? (await runtime.approvals.list(parentId, context)).filter((a) => a.childId === childId) : [];
+      const currentUsage = await runtime.harness.snapshot(UsageDoc3, childId, context);
+      const rounds = (await listDelegations(runtime.harness, parentId, context)).filter((r) => r.childId === childId).map(({ usageStart, usageEnd: _end, ...round }) => ({
+        ...round,
+        roundUsage: round.roundUsage ?? (through === undefined && usageStart && currentUsage ? subagentUsageTotals(subtractSubagentUsage(currentUsage, usageStart)) : null)
+      }));
+      revision = remember({ ...project(page.entries), rounds, approvals, historyBefore: page.next });
+      return revision;
+    },
+    async chunk(input) {
+      let token = input.token;
+      if (token === undefined) {
+        if (input.kind === "view")
+          token = revision;
+        else {
+          const page = await pageAt(input.before);
+          token = remember({ items: project(page.entries, false).items, next: page.next });
+        }
+      }
+      const payload = payloads.get(token);
+      if (payload === undefined)
+        throw new ChordError("gone", "Transcript changed; reload");
+      if (input.offset > payload.length)
+        throw new ChordError("invalid", "Invalid transcript range");
+      const end = Math.min(payload.length, input.offset + 32768);
+      return { token, data: payload.slice(input.offset, end), next: end < payload.length ? end : null };
+    },
+    async history(before) {
+      const page = await pageAt(before);
+      return { items: project(page.entries, false).items, next: page.next };
+    },
+    async image(entryId, contentIndex, offset) {
+      if (through !== undefined && entryId > through)
+        throw new ChordError("forbidden", "Image outside fork history");
+      const page = await child.entries({ minEntryId: entryId, maxEntryId: entryId }, 1, undefined, context);
+      const content = page.items[0]?.model?.[0]?.content;
+      const image = Array.isArray(content) ? content[contentIndex] : undefined;
+      if (image?.type !== "image")
+        throw new ChordError("invalid", "Image not in subagent conversation");
+      const bytes = Buffer.from(image.data, "base64");
+      if (offset > bytes.length)
+        throw new ChordError("invalid", "Invalid image range");
+      return {
+        data: bytes.subarray(offset, offset + IMAGE_CHUNK_BYTES).toString("base64"),
+        total: bytes.length,
+        mimeType: image.mimeType
+      };
+    },
+    close: () => native.dispose()
+  };
+}
+var ChildProjection = local("neko.subagent-projection", {
+  version: 1,
+  input: Type5.Object({ parentId: Type5.Integer(), agentId: Type5.String() }),
+  members: {
+    revision: Type5.Integer(),
+    reader: opaque("neko.subagent-reader@1")
+  }
+});
+function installSubagentHost(host, runtime, context) {
+  host.serve(ChildProjection, (input, _principal, self) => {
+    const { revision } = self.state({ revision: cell(Type5.Integer(), 0) });
+    const { reader } = self.resources({
+      reader: resource({
+        rev: 1,
+        async open() {
+          const entry = (await listDelegations(runtime.harness, input.parentId, context)).find((d) => input.agentId.startsWith("round-") ? d.taskId === Number(input.agentId.slice(6)) : (d.agentId ?? agentIdFor(d.childId)) === input.agentId);
+          if (!entry)
+            throw new ChordError("gone", "Subagent unavailable");
+          const r = await openReader(runtime, entry.childId, input.parentId, context, entry.historyThrough, entry.historyUsage);
+          try {
+            const initial = await r.refresh();
+            await host.root((ctx) => revision.replace(ctx, initial));
+            return r;
+          } catch (error) {
+            r.close();
+            throw error;
+          }
+        },
+        close: (r) => r.close()
+      })
+    });
+    self.listen({
+      view: listener(reader, (r) => r, async (_event, ctx) => {
+        revision.replace(ctx, await reader.value.refresh());
+      })
+    });
+    return { revision, reader: self.expose(reader) };
+  });
+  host.serve(NekoSubagent, (input, principal, self) => {
+    const owner = self.get(Owner, {}, { principal });
+    const check = async () => {
+      if (owner.owner?.active?.attachmentId !== input.attachmentId || owner.owner.active.sessionId !== input.sessionId)
+        throw new ChordError("forbidden", "Attachment expired");
+      if (!await runtime.getConversation(Number(input.sessionId)))
+        throw new ChordError("gone", "Session unavailable");
+      const entry = (await listDelegations(runtime.harness, Number(input.sessionId), context)).find((d) => input.agentId !== undefined ? (d.agentId ?? agentIdFor(d.childId)) === input.agentId : d.taskId === input.taskId);
+      if (!entry)
+        throw new ChordError("forbidden", "Subagent does not belong to this session");
+      return entry;
+    };
+    const { target } = self.resources({ target: resource({ rev: 1, deps: [owner], open: check }) });
+    const shared = self.get(ChildProjection, { parentId: Number(input.sessionId), agentId: input.agentId ?? `round-${input.taskId}` }, { principal: hostPrincipal });
+    const { authorizedRevision } = self.state({ authorizedRevision: cell(Type5.Integer(), 0) });
+    self.listen({
+      authorizedView: listener(shared.revision, async (value, ctx) => {
+        try {
+          target.value;
+          await check();
+          if (value)
+            authorizedRevision.replace(ctx, value);
+        } catch {
+          authorizedRevision.replace(ctx, 0);
+        }
+      })
+    });
+    return {
+      kind: "ready",
+      revision: authorizedRevision,
+      chunk: async (request) => {
+        await check();
+        return shared.reader.chunk(request);
+      },
+      getImage: async ({ entryId, contentIndex, offset }) => {
+        await check();
+        return shared.reader.image(entryId, contentIndex, offset);
+      },
+      decideApproval: async ({ id, version, decision }) => {
+        const entry = await check();
+        if (entry.historyThrough !== undefined)
+          throw new ChordError("forbidden", "Fork history is read-only");
+        const approval = (await runtime.approvals.list(Number(input.sessionId), context)).find((a) => a.id === id && a.childId === entry.childId);
+        if (!approval)
+          throw new ChordError("forbidden", "Approval does not belong to this agent");
+        return runtime.approvals.decide(Number(input.sessionId), approval.delegationTaskId, id, version, decision, context);
+      },
+      stop: async (request) => {
+        const entry = await check();
+        if (entry.historyThrough !== undefined)
+          throw new ChordError("forbidden", "Fork history is read-only");
+        const taskId = request?.taskId ?? input.taskId;
+        if (taskId === undefined)
+          throw new ChordError("invalid", "Select the exact active round to stop");
+        const valid = await runtime.harness.commit(async (tx) => {
+          const identity = (await tx.doc(SubagentsDoc, Number(input.sessionId))).items.find((a) => a.childId === entry.childId);
+          return identity?.activeRoundId === taskId;
+        }, context);
+        if (!valid)
+          return null;
+        await runtime.harness.abortTask(taskId, context);
+        await runtime.harness.waitForTask(taskId, context);
+        return null;
+      }
+    };
+  });
+}
+
 // packages/gateway/src/session-host.ts
-var OwnerInput = Type3.Object({});
-var Owner = local("neko.attachment-owner", {
+var OwnerInput = Type6.Object({});
+var Owner = local2("neko.attachment-owner", {
   version: 1,
   input: OwnerInput,
-  members: { owner: opaque("neko.owner@1") }
+  members: { owner: opaque2("neko.owner@1") }
 });
-var Projection = local("neko.projection", {
+var Projection = local2("neko.projection", {
   version: 1,
-  input: Type3.Object({ id: Type3.String() }),
+  input: Type6.Object({ id: Type6.String() }),
   members: {
     view: ChatViewSchema,
-    reader: opaque("neko.projection-reader@1")
+    reader: opaque2("neko.projection-reader@1")
   }
 });
 var emptyView = {
@@ -3323,6 +4616,11 @@ async function openProjection(runtime, session, context) {
   let changed;
   const stop = view.subscribe(() => changed?.(null));
   const stopMetadata = runtime.onDirectoryChange(() => changed?.(null));
+  let childIds = new Set;
+  const stopChildren = runtime.harness.subscribeCommits(({ changes }) => {
+    if (changes.some((change) => change.type === "document" && (["app.neko.delegations", "app.neko.approvals", "app.neko.subagents"].includes(change.record.kind) && change.conversationId === session.id || change.record.kind === "pi.usage" && change.conversationId !== undefined && childIds.has(change.conversationId))))
+      changed?.(null);
+  });
   return {
     subscribe(fn) {
       changed = fn;
@@ -3335,7 +4633,7 @@ async function openProjection(runtime, session, context) {
       for (const entry of view.value.entries)
         history.set(entry.id, entry);
       const [naming, compaction] = await Promise.all([runtime.namingUsage(session.id), session.compactionRecord()]);
-      return projectChatView({
+      const projected = projectChatView({
         ...view.value,
         entries: [...history.values()].sort((a, b) => a.id - b.id),
         docs: {
@@ -3346,6 +4644,33 @@ async function openProjection(runtime, session, context) {
           }, naming)
         }
       }, "", { models: runtime.listModels(), contextEntries: view.value.entries, compaction });
+      const subagents = await listDelegations(runtime.harness, session.id, context);
+      const approvals = await runtime.approvals.list(session.id, context);
+      for (const entry of subagents)
+        entry.approvalCount = entry.historyThrough === undefined ? approvals.filter((a) => a.delegationTaskId === entry.taskId && a.status === "pending").length : 0;
+      childIds = new Set(subagents.filter((entry) => entry.historyThrough === undefined).map((entry) => entry.childId));
+      let aggregate = await session.usage();
+      for (const child of new Map(subagents.filter((entry) => entry.historyThrough === undefined).map((r) => [r.childId, r])).values())
+        aggregate = mergeUsage(aggregate, await runtime.harness.snapshot(UsageDoc4, child.childId, context) ?? {
+          models: {},
+          tools: {}
+        });
+      const u = totalUsage(aggregate);
+      return {
+        ...projected,
+        agents: summarizeSubagents(subagents, (await runtime.harness.snapshot(SubagentsDoc, session.id, context))?.items),
+        subagents: subagents.map(({ usageStart: _start, usageEnd: _end, ...entry }) => ({
+          ...entry,
+          report: entry.report?.slice(0, 512) ?? null
+        })),
+        taskUsage: {
+          input: u.input,
+          output: u.output,
+          cacheRead: u.cacheRead,
+          cacheWrite: u.cacheWrite,
+          cost: u.cost.total
+        }
+      };
     },
     async entry(id, ctx) {
       ctx.abortSignal?.throwIfAborted();
@@ -3356,15 +4681,17 @@ async function openProjection(runtime, session, context) {
     close() {
       stop();
       stopMetadata();
+      stopChildren();
       view.dispose();
       history.clear();
     }
   };
 }
 function serveSessions(host, runtime, context) {
+  installSubagentHost(host, runtime, context);
   host.serve(Owner, (_input, _principal, self) => {
     const { owner } = self.resources({
-      owner: resource({
+      owner: resource2({
         rev: 1,
         open: () => ({ active: null }),
         close: (value) => {
@@ -3375,14 +4702,14 @@ function serveSessions(host, runtime, context) {
     return { owner: self.expose(owner) };
   });
   host.serve(Projection, (input, _principal, self) => {
-    const { view } = self.state({ view: cell(ChatViewSchema, emptyView) });
+    const { view } = self.state({ view: cell2(ChatViewSchema, emptyView) });
     const { projection } = self.resources({
-      projection: resource({
+      projection: resource2({
         rev: 1,
         async open({ signal }) {
           const session = await runtime.getConversation(Number(input.id));
           if (!session)
-            throw new ChordError("gone", "Session unavailable");
+            throw new ChordError2("gone", "Session unavailable");
           const opened = await openProjection(runtime, session, context);
           try {
             const initial = await opened.project();
@@ -3397,7 +4724,7 @@ function serveSessions(host, runtime, context) {
       })
     });
     self.listen({
-      view: listener(projection, (value) => value, async (_event, ctx) => {
+      view: listener2(projection, (value) => value, async (_event, ctx) => {
         view.replace(ctx, await projection.value.project());
       })
     });
@@ -3405,18 +4732,18 @@ function serveSessions(host, runtime, context) {
   });
   host.serve(NekoChat, (input, principal, self) => {
     const owner = self.get(Owner, {}, { principal });
-    const shared = self.get(Projection, { id: input.sessionId }, { principal: hostPrincipal });
+    const shared = self.get(Projection, { id: input.sessionId }, { principal: hostPrincipal2 });
     const { uploads, projection } = self.resources({
-      uploads: resource({ rev: 1, open: () => new ImageUploads, close: (value) => value.close() }),
-      projection: resource({
+      uploads: resource2({ rev: 1, open: () => new ImageUploads, close: (value) => value.close() }),
+      projection: resource2({
         rev: 1,
         deps: [owner],
         async open() {
           if (owner.owner?.active?.attachmentId !== input.attachmentId || owner.owner.active.sessionId !== input.sessionId)
-            throw new ChordError("forbidden", "Attachment does not belong to this connection");
+            throw new ChordError2("forbidden", "Attachment does not belong to this connection");
           const session = await runtime.getConversation(Number(input.sessionId));
           if (!session)
-            throw new ChordError("gone", "Session unavailable");
+            throw new ChordError2("gone", "Session unavailable");
           return {
             session
           };
@@ -3427,7 +4754,7 @@ function serveSessions(host, runtime, context) {
       try {
         return action();
       } catch (error) {
-        throw new ChordError("invalid", error instanceof Error ? error.message : "Image upload failed");
+        throw new ChordError2("invalid", error instanceof Error ? error.message : "Image upload failed");
       }
     };
     const behavior = {
@@ -3483,7 +4810,7 @@ function serveSessions(host, runtime, context) {
           await projection.value.session.compact(instructions);
           return null;
         } catch (error) {
-          throw new ChordError("invalid", error instanceof Error ? error.message : "Cannot compact");
+          throw new ChordError2("invalid", error instanceof Error ? error.message : "Cannot compact");
         }
       },
       beginImage: async (input) => safeUpload(() => uploads.value.begin(input)),
@@ -3501,15 +4828,15 @@ function serveSessions(host, runtime, context) {
       },
       getImage: async (input, ctx) => {
         if (!Number.isSafeInteger(input.offset) || input.offset < 0 || !Number.isSafeInteger(input.contentIndex) || input.contentIndex < 0)
-          throw new ChordError("invalid", "Invalid image range");
-        const entry = await shared.reader.entry(input.entryId, withAbortSignal2(ctx.signal, context));
+          throw new ChordError2("invalid", "Invalid image range");
+        const entry = await shared.reader.entry(input.entryId, withAbortSignal3(ctx.signal, context));
         const content = entry?.model?.[0]?.content;
         const image = Array.isArray(content) ? content[input.contentIndex] : undefined;
         if (image?.type !== "image")
-          throw new ChordError("invalid", "Image is not part of this conversation");
+          throw new ChordError2("invalid", "Image is not part of this conversation");
         const bytes = Buffer.from(image.data, "base64");
         if (input.offset > bytes.length)
-          throw new ChordError("invalid", "Invalid image range");
+          throw new ChordError2("invalid", "Invalid image range");
         return {
           data: bytes.subarray(input.offset, input.offset + IMAGE_CHUNK_BYTES).toString("base64"),
           total: bytes.length,
@@ -3529,8 +4856,8 @@ function serveSessions(host, runtime, context) {
             uploads.value.release(id);
         } catch (error) {
           if (error instanceof Error && error.message.startsWith("DEEPSEEK_KEY_REQUIRED:"))
-            throw new ChordError("invalid", "DEEPSEEK_KEY_REQUIRED: Configure DeepSeek in /login or Web settings.");
-          throw new ChordError("invalid", error instanceof Error ? error.message : "Cannot submit message");
+            throw new ChordError2("invalid", "DEEPSEEK_KEY_REQUIRED: Configure DeepSeek in /login or Web settings.");
+          throw new ChordError2("invalid", error instanceof Error ? error.message : "Cannot submit message");
         }
         return null;
       },
@@ -3552,16 +4879,16 @@ function serveSessions(host, runtime, context) {
       configure: async (change) => {
         const applied = await runtime.configureConversation(projection.value.session.id, change);
         if (!applied) {
-          throw new ChordError("invalid", `Session ${String(projection.value.session.id)} is unavailable or archived`);
+          throw new ChordError2("invalid", `Session ${String(projection.value.session.id)} is unavailable or archived`);
         }
         return null;
       }
     };
     const guard = async () => {
       if (owner.owner?.active?.attachmentId !== input.attachmentId || owner.owner.active.sessionId !== input.sessionId)
-        throw new ChordError("gone", "Attachment is no longer active");
+        throw new ChordError2("gone", "Attachment is no longer active");
       if (!await runtime.getConversation(Number(input.sessionId)))
-        throw new ChordError("gone", "Session unavailable or archived");
+        throw new ChordError2("gone", "Session unavailable or archived");
     };
     for (const name of Object.keys(NekoChat.def.variants.ready.methods)) {
       const method = behavior[name];
@@ -3576,7 +4903,7 @@ function serveSessions(host, runtime, context) {
 }
 
 // packages/gateway/src/skill-market.ts
-import { createHash, randomUUID } from "crypto";
+import { createHash, randomUUID as randomUUID2 } from "crypto";
 import { mkdir as mkdir3, readdir as readdir2, rename as rename3, rm as rm3, stat as stat2, writeFile as writeFile3 } from "fs/promises";
 import { homedir as homedir6 } from "os";
 import { dirname as dirname6, join as join8 } from "path";
@@ -4150,7 +5477,7 @@ function createSkillMarketClient(options) {
     const skill = await detail(name);
     const files = unpack(skill, await download(skill));
     await sweepTempDirs(skillsDir);
-    const temp = join8(dirname6(skillsDir), `.tmp-${randomUUID()}`);
+    const temp = join8(dirname6(skillsDir), `.tmp-${randomUUID2()}`);
     try {
       for (const [relative, bytes] of files) {
         const dest = join8(temp, ...relative.split("/"));
@@ -4271,14 +5598,14 @@ async function listDrives() {
 }
 
 // packages/gateway/src/server-services.ts
-var ServerState = local2("neko.server-state", {
+var ServerState = local3("neko.server-state", {
   version: 1,
-  input: Type4.Object({}),
+  input: Type7.Object({}),
   members: {
     directory: DirectoryStateSchema,
     workspaces: WorkspaceStateSchema,
     credentials: CredentialStateSchema,
-    refreshCredentials: method2(Type4.Null(), Type4.Null())
+    refreshCredentials: method2(Type7.Null(), Type7.Null())
   }
 });
 async function createNekoServerServices(options) {
@@ -4298,9 +5625,9 @@ async function createNekoServerServices(options) {
       listener(updates.state);
   };
   host.serve(NekoApplicationInfo, (_input, _principal, self) => {
-    const state = self.state({ info: cell2(ApplicationInfoSchema, updates.state) });
+    const state = self.state({ info: cell3(ApplicationInfoSchema, updates.state) });
     self.listen({
-      updates: listener2({
+      updates: listener3({
         subscribe: (fn) => {
           updateListeners.add(fn);
           return () => updateListeners.delete(fn);
@@ -4332,7 +5659,7 @@ async function createNekoServerServices(options) {
   const toRemote = (error) => {
     if (error instanceof SkillMarketError) {
       const code = error.code === "skill_not_found" || error.code === "skill_not_installed" ? "gone" : "invalid";
-      throw new ChordError2(code, error.message, { reason: error.code });
+      throw new ChordError3(code, error.message, { reason: error.code });
     }
     throw error;
   };
@@ -4366,12 +5693,12 @@ async function createNekoServerServices(options) {
   };
   host.serve(ServerState, (_input, _principal, self) => {
     const state = self.state({
-      directory: cell2(DirectoryStateSchema, { revision: 1, sessions }),
-      workspaces: cell2(WorkspaceStateSchema, { revision: 1, workspaces }),
-      credentials: cell2(CredentialStateSchema, { revision: 1, statuses })
+      directory: cell3(DirectoryStateSchema, { revision: 1, sessions }),
+      workspaces: cell3(WorkspaceStateSchema, { revision: 1, workspaces }),
+      credentials: cell3(CredentialStateSchema, { revision: 1, statuses })
     });
     self.listen({
-      directory: listener2({ subscribe: runtime.harness.subscribeCommits.bind(runtime.harness) }, async (event, ctx) => {
+      directory: listener3({ subscribe: runtime.harness.subscribeCommits.bind(runtime.harness) }, async (event, ctx) => {
         if (!event.changes.some((change) => change.type === "conversation" || change.type === "document" && [
           "app.neko.session-metadata",
           "app.neko.activity",
@@ -4398,7 +5725,7 @@ async function createNekoServerServices(options) {
       }
     };
   }, { eager: { input: {} } });
-  const shared = (self) => self.get(ServerState, {}, { principal: hostPrincipal2 });
+  const shared = (self) => self.get(ServerState, {}, { principal: hostPrincipal3 });
   host.serve(NekoSessionDirectory, (_input, _principal, self) => ({ kind: "ready", state: shared(self).directory }));
   host.serve(NekoWorkspaces, (_input, _principal, self) => ({
     kind: "ready",
@@ -4434,7 +5761,7 @@ async function createNekoServerServices(options) {
     search: async (input, ctx) => {
       const roots = await runtime.listWorkspaces();
       if (!roots.some((root) => root.path === input.workspaceRoot))
-        throw new ChordError2("invalid", "Unknown workspace.");
+        throw new ChordError3("invalid", "Unknown workspace.");
       return runtime.workspaceFiles.search(input.workspaceRoot, input.query, ctx.signal);
     }
   }));
@@ -4444,7 +5771,7 @@ async function createNekoServerServices(options) {
     const summary = async (id) => {
       const found = (await list()).find((item) => item.id === String(id));
       if (!found)
-        throw new ChordError2("gone", "Session unavailable");
+        throw new ChordError3("gone", "Session unavailable");
       return found;
     };
     return {
@@ -4457,9 +5784,9 @@ async function createNekoServerServices(options) {
       },
       attach: (id) => serialize(async () => {
         if (!await runtime.getConversation(toConversationId(id)))
-          throw new ChordError2("gone", `Unknown session: ${id}`);
+          throw new ChordError3("gone", `Unknown session: ${id}`);
         if (owner.owner.active?.sessionId !== id) {
-          owner.owner.active = { sessionId: id, attachmentId: randomUUID2() };
+          owner.owner.active = { sessionId: id, attachmentId: randomUUID3() };
           await runtime.touchConversation(toConversationId(id));
         }
         return owner.owner.active;
@@ -4495,7 +5822,7 @@ async function createNekoServerServices(options) {
 function toConversationId(sessionId) {
   const numeric = Number(sessionId);
   if (!Number.isSafeInteger(numeric) || numeric < 1 || String(numeric) !== sessionId)
-    throw new ChordError2("invalid", `Invalid neko session id: ${sessionId}`);
+    throw new ChordError3("invalid", `Invalid neko session id: ${sessionId}`);
   return numeric;
 }
 
@@ -4792,7 +6119,7 @@ var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_PORT = 8321;
 var SERVER_ID_FILENAME = "gateway-server-id";
 async function startGateway(options = {}) {
-  const context = options.context ?? BACKGROUND_CONTEXT3;
+  const context = options.context ?? BACKGROUND_CONTEXT4;
   const fileConfig = loadNekoConfig(options.configDir);
   const model = options.model ?? fileConfig.defaultModel ?? DEFAULT_MODEL;
   const storagePath = options.storagePath ?? fileConfig.storagePath ?? DEFAULT_STORAGE_PATH;
@@ -4862,7 +6189,7 @@ async function bindGateway(runtime, options) {
   }
   try {
     for (const listener of listeners)
-      await listener.start((link) => chord.accept(link, { principal: { connectionId: randomUUID3() } }));
+      await listener.start((link) => chord.accept(link, { principal: { connectionId: randomUUID4() } }));
   } catch (error) {
     await Promise.allSettled(listeners.map((listener) => listener.close()));
     await chord.close();
@@ -4932,7 +6259,7 @@ async function loadOrCreateServerId(nekoDir) {
     if (existing !== "")
       return existing;
   } catch {}
-  const created = randomUUID3();
+  const created = randomUUID4();
   await mkdir5(nekoDir, { recursive: true, mode: 448 });
   await writeFile4(file, `${created}
 `, { mode: 384 });