neko-harness 0.3.0 → 0.3.1

package/dist/neko.js

@@ -79,7 +79,7 @@ function updateAction(input) {
     return "install";
   return "none";
 }
-var RUNNING_VERSION = "0.3.0", APPLICATION_PROTOCOL = 3, ApplicationProtocolError;
+var RUNNING_VERSION = "0.3.1", APPLICATION_PROTOCOL = 4, ApplicationProtocolError;
 var init_application_version = __esm(() => {
   ApplicationProtocolError = class ApplicationProtocolError extends Error {
     constructor() {
@@ -803,7 +803,10 @@ function summarizeToolCall(name, args) {
   const record = args ?? {};
   switch (name) {
     case "subagent":
-      return { args: `${record.type}: ${record.title}`, detail: String(record.task ?? "") };
+      return {
+        args: record.action === "list" ? "List agents" : `${record.agentId ?? record.type}: ${record.title}`,
+        detail: String(record.task ?? "")
+      };
     case "find_files":
     case "search_text":
       return {
@@ -926,6 +929,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),
@@ -1485,164 +1489,403 @@ var init_invoke = __esm(() => {
   init_skills();
 });
 
+// packages/core/src/subagent-usage.ts
+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
+  };
+}
+var emptySubagentUsage = () => ({ models: {}, tools: {} });
+var init_subagent_usage = __esm(() => {
+  init_projection();
+});
+
 // packages/core/src/subagents.ts
 import {
   AssistantEntry,
   configure,
   defineDoc,
   defineExtension as defineExtension3,
-  defineTool as defineTool2
+  defineTask,
+  defineTool as defineTool2,
+  LiveDoc,
+  UsageDoc
 } from "@earendil-works/pi-durable";
 import { Type as Type2 } from "typebox";
+import { Value } from "typebox/value";
 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.status === "completed" || item.status === "failed" || item.status === "cancelled")
-      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);
-    if (task?.state.status !== "terminal")
-      continue;
-    item.status = task.state.outcome.status === "aborted" ? "cancelled" : "failed";
-    item.endedAt = Date.now();
+    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));
 }
-async function admit(api, cwd, role, context) {
-  for (;; ) {
-    context.abortSignal?.throwIfAborted();
-    const acquired = await api.commit(async (tx) => {
-      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 === api.taskId))
-        return true;
-      if (live.filter((slot) => slot.parentId === api.conversationId).length >= 3 || role === "coder" && live.some((slot) => slot.coder && slot.cwd === cwd))
-        return false;
-      slots.items.push({ taskId: api.taskId, parentId: api.conversationId, cwd, coder: role === "coder" });
-      return true;
-    }, context);
-    if (acquired)
-      return;
-    await new Promise((resolve, reject) => {
-      const cleanup = () => {
-        clearTimeout(timer);
-        context.abortSignal?.removeEventListener("abort", abort);
-      };
-      const abort = () => {
-        cleanup();
-        reject(context.abortSignal?.reason ?? new Error("Cancelled"));
-      };
-      const timer = setTimeout(() => {
-        cleanup();
-        resolve();
-      }, 100);
-      context.abortSignal?.addEventListener("abort", abort, { once: true });
-      if (context.abortSignal?.aborted)
-        abort();
-    });
-  }
+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;
 }
 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: "Delegate a self-contained task to an independent foreground subagent. explore: investigation, Bash requires user approval; plan: read-only implementation planning; coder: scoped changes and verification. Include all needed context, constraints and expected delivery. Use only when isolation or parallel independent work helps; handle simple tasks directly. Returns the final report; the main agent waits and must verify/integrate it.",
-        parameters: Type2.Object({
-          type: Type2.Union([Type2.Literal("explore"), Type2.Literal("plan"), Type2.Literal("coder")]),
-          title: Type2.String({ minLength: 1, maxLength: 80 }),
-          task: Type2.String({ minLength: 1, maxLength: 32768 })
-        }),
+        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 (args, api, context) => {
-          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.");
+        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 childId = await api.commit(async (tx) => {
-            const existing = (await tx.scanConversations({ ownerTaskId: api.taskId }, 1)).items[0];
-            if (existing)
-              return existing.id;
-            const child = await tx.createConversation({ ownership: { kind: "task", taskId: api.taskId } });
-            await configure(tx, child.id, {
-              model: agent.model,
-              thinkingLevel: agent.thinkingLevel,
-              cwd: agent.cwd,
-              extensions: agent.extensions.filter((e) => e.name !== extension.name),
-              tools: agent.tools.filter((tool) => tool.name !== "subagent" && (args.type === "coder" || READ_TOOLS.has(tool.name) || args.type === "explore" && tool.name === "bash"))
-            });
-            Object.assign(await tx.doc(SubagentDoc, child.id), { role: args.type, parentId: api.conversationId });
-            (await tx.doc(DelegationsDoc, api.conversationId)).items.push({
+          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: child.id,
-              role: args.type,
+              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
-            });
-            return child.id;
+            };
+            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: childId, role: args.type, title: args.title }, context);
-          const cwd = api.env ? await api.env.canonicalPath(agent.cwd ?? api.env.cwd, context) : undefined;
-          await admit(api, cwd?.ok ? cwd.value : agent.cwd ?? "", args.type, context);
-          await api.commit(async (tx) => {
-            const item = (await tx.doc(DelegationsDoc, api.conversationId)).items.find((d) => d.taskId === api.taskId);
-            item.status = "running";
-            item.startedAt ??= Date.now();
-          }, context);
-          const child = await api.conversation(childId, context);
-          const requestId = `subagent:${api.taskId}`;
-          const duplicate = await api.commit((tx) => tx.submissionByRequest(childId, requestId), context);
-          if (!duplicate)
-            await prepare(childId, requestId, agent.cwd ?? "");
-          let submission;
-          try {
-            submission = await child.submit({
-              type: "input",
-              content: args.task,
-              requestId,
-              entry: { kind: NekoInput.kind, data: { at: Date.now(), prompt: args.task, images: [] } }
-            }, context);
-          } catch (error) {
-            discard(childId, requestId);
-            throw error;
-          }
-          const settled = await submission.wait(context);
-          let report = "";
-          let status = "failed";
-          if (settled.status === "done" && settled.type === "input") {
-            const entry = await api.commit((tx) => tx.entry(AssistantEntry, settled.answer), context);
-            const message = entry?.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 api.commit(async (tx) => {
-            const item = (await tx.doc(DelegationsDoc, api.conversationId)).items.find((d) => d.taskId === api.taskId);
-            item.status = status;
-            item.report = report;
-            item.endedAt = Date.now();
+          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: report || "Subagent completed without a text report." }],
-            isError: status !== "completed",
-            details: { conversationId: childId, role: args.type, title: args.title, status }
+            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
+            }
           };
         }
       })
@@ -1651,11 +1894,67 @@ function createSubagentExtension(prepare, discard) {
   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);
 }
-var DelegationsDoc, SubagentDoc, SlotsDoc, ROLE_PROMPTS, SUBAGENT_DELIVERY = " Work only from the assigned task and your 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.", READ_TOOLS;
+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(() => {});
+}
+var agentIdFor = (childId) => `agent-${childId}`, DelegationsDoc, SubagentsDoc, SubagentDoc, SlotsDoc, ROLE_PROMPTS, 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.", READ_TOOLS, actionParameters, parameters, structuredOutputSchema;
 var init_subagents = __esm(() => {
   init_input();
+  init_subagent_usage();
   DelegationsDoc = defineDoc({
     kind: "app.neko.delegations",
     version: 1,
@@ -1664,6 +1963,14 @@ var init_subagents = __esm(() => {
     fork: "initial",
     initial: () => ({ items: [] })
   });
+  SubagentsDoc = defineDoc({
+    kind: "app.neko.subagents",
+    version: 1,
+    scope: "conversation",
+    history: "latest",
+    fork: "initial",
+    initial: () => ({ items: [] })
+  });
   SubagentDoc = defineDoc({
     kind: "app.neko.subagent",
     version: 1,
@@ -1684,6 +1991,60 @@ var init_subagents = __esm(() => {
     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."
   };
   READ_TOOLS = new Set(["read", "find_files", "search_text", "web_search", "web_extract"]);
+  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 })
+  ]);
+  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 });
+  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 })
+  ]);
 });
 
 // packages/core/src/prompt/prompt.ts
@@ -1744,7 +2105,7 @@ var init_prompt = __esm(() => {
   KEYS = ["preamble", "rules", "project_context", "skills", "cwd"];
   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. Verify and integrate reports. Do not modify files concurrently with a coder assigned those files."
+      "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."
@@ -1899,9 +2260,9 @@ import { getSupportedThinkingLevels } from "@earendil-works/pi-ai";
 import {
   defineDoc as defineDoc2,
   defineExtension as defineExtension5,
-  defineTask,
+  defineTask as defineTask2,
   InboxDoc,
-  LiveDoc
+  LiveDoc as LiveDoc2
 } from "@earendil-works/pi-durable";
 function shortText(value, limit = 60) {
   return [
@@ -1943,7 +2304,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 }),
@@ -2157,7 +2518,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) {
@@ -2359,7 +2720,8 @@ function createApprovalExtension(service) {
           const child = await approvals.harness.conversation(api.conversationId, context);
           const agent = await child.agent(context);
           const cwd = await realpath2(agent.cwd);
-          const delegation = (await api.snapshot(DelegationsDoc, parent, context))?.items.find((d) => d.childId === api.conversationId && d.historyThrough === undefined);
+          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, {
@@ -2990,7 +3352,7 @@ import {
   Harness,
   LiveDoc as importLiveDoc,
   MemoryStorage,
-  UsageDoc,
+  UsageDoc as UsageDoc2,
   watchEvents
 } from "@earendil-works/pi-durable";
 import { createNodePhotonImages } from "@earendil-works/pi-durable/images/node";
@@ -3073,6 +3435,7 @@ async function createNekoRuntime(options = {}) {
   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);
@@ -3257,7 +3620,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);
@@ -3306,7 +3669,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;
@@ -3341,14 +3704,24 @@ async function createNekoRuntime(options = {}) {
               }
             cursor = page.next;
           } while (cursor);
+          const frozen = new Map;
           for (const reference of references) {
             if (!calls.has(reference.callId))
               continue;
-            const latest = await tx.scanEntries({ conversationId: reference.childId }, 1);
-            const usage = totalUsage(await tx.doc(UsageDoc, reference.childId));
+            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 ?? latest.items[0]?.id ?? 0,
+              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,
@@ -3561,6 +3934,7 @@ var init_runtime = __esm(() => {
   init_prompt();
   init_resources();
   init_session_metadata();
+  init_subagent_usage();
   init_subagents();
   init_tool_approvals();
   init_web_search();
@@ -3615,6 +3989,7 @@ var init_src = __esm(() => {
   init_frontmatter();
   init_runtime();
   init_session_metadata();
+  init_subagent_usage();
   init_subagents();
   init_tool_approvals();
   init_workspace();
@@ -3687,7 +4062,7 @@ function contract(name, def) {
   ]));
   return remote(name, { ...def, variants });
 }
-var rpc = (args, result) => [args, result], str, num, bool, nil, integer, nullableString, phase, level, thinking, model, change, usage, image, skill, call, DelegationSchema, ChatViewSchema, SessionSummarySchema, DirectoryStateSchema, WorkspaceSummarySchema, WorkspaceStateSchema, credentialStatus, CredentialStateSchema, AttachmentSchema, chatInput, NekoSessionDirectory, NekoSessionManagement, resize, inputLimits, modelInfo, NekoModels, imageChunk, NekoSubagent, NekoChat, browse, page, NekoWorkspaces, provider, NekoCredentials, FileCandidatesSchema, NekoWorkspaceFiles, marketSkill, preview, scope, installResult, NekoSkillMarket, ApplicationInfoSchema, NekoApplicationInfo;
+var rpc = (args, result) => [args, result], str, num, bool, nil, integer, nullableString, phase, level, thinking, model, change, usage, image, skill, call, DelegationSchema, SubagentSummarySchema, ChatViewSchema, SessionSummarySchema, DirectoryStateSchema, WorkspaceSummarySchema, WorkspaceStateSchema, credentialStatus, CredentialStateSchema, AttachmentSchema, chatInput, NekoSessionDirectory, NekoSessionManagement, resize, inputLimits, modelInfo, NekoModels, imageChunk, NekoSubagent, NekoChat, browse, page, NekoWorkspaces, provider, NekoCredentials, FileCandidatesSchema, NekoWorkspaceFiles, marketSkill, preview, scope, installResult, NekoSkillMarket, ApplicationInfoSchema, NekoApplicationInfo;
 var init_contract = __esm(() => {
   str = Type4.String();
   num = Type4.Number();
@@ -3721,6 +4096,12 @@ var init_contract = __esm(() => {
   });
   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,
@@ -3735,8 +4116,27 @@ var init_contract = __esm(() => {
     historyThrough: Type4.Optional(integer),
     historyUsage: Type4.Optional(usage)
   });
+  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)
+  });
   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,
@@ -3892,7 +4292,12 @@ var init_contract = __esm(() => {
   imageChunk = Type4.Object({ data: str, total: integer, mimeType: str });
   NekoSubagent = contract("neko.subagent", {
     version: 1,
-    input: Type4.Object({ sessionId: str, attachmentId: str, taskId: integer }),
+    input: Type4.Object({
+      sessionId: str,
+      attachmentId: str,
+      taskId: Type4.Optional(integer),
+      agentId: Type4.Optional(str)
+    }),
     variants: {
       ready: {
         state: { revision: integer },
@@ -3905,7 +4310,7 @@ var init_contract = __esm(() => {
           }), 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(nil, nil)
+          stop: rpc(Type4.Union([nil, Type4.Object({ taskId: integer })]), nil)
         }
       }
     }
@@ -4312,17 +4717,18 @@ class ApprovalQueue {
   update(entries) {
     const pending = entries.filter((d) => d.approvalCount && d.historyThrough === undefined);
     for (const [id, reader] of this.#readers) {
-      if (!pending.some((d) => d.taskId === id)) {
+      if (!pending.some((d) => (d.agentId ?? d.taskId) === id)) {
         this.#readers.delete(id);
         reader.stop();
       }
     }
     for (const entry of pending) {
-      if (this.#readers.has(entry.taskId))
+      const key = entry.agentId ?? entry.taskId;
+      if (this.#readers.has(key))
         continue;
-      const service = this.#connect(entry.taskId);
+      const service = this.#connect(key);
       const reader = { service, title: entry.title, stop: () => {} };
-      this.#readers.set(entry.taskId, reader);
+      this.#readers.set(key, reader);
       reader.stop = service.view.subscribe(() => this.#changed());
     }
     this.#changed();
@@ -4392,10 +4798,10 @@ function createGatewayConnection(link, serverId) {
   let closing;
   const connection = {
     application,
-    subagent(taskId) {
+    subagent(target) {
       if (!attachment)
         throw new Error("No active session");
-      const input = { ...attachment, taskId };
+      const input = { ...attachment, ...typeof target === "string" ? { agentId: target } : { taskId: target } };
       return subagentClient(() => host.get(NekoSubagent, input, { at: serverId }));
     },
     host,
@@ -15068,7 +15474,14 @@ var init_history_image = __esm(() => {
 });
 
 // packages/tui/src/components/login.ts
-import { Input, isKeyRelease as isKeyRelease2, matchesKey as matchesKey4, truncateToWidth as truncateToWidth3 } from "@earendil-works/pi-tui";
+import {
+  CURSOR_MARKER as CURSOR_MARKER2,
+  Input,
+  isKeyRelease as isKeyRelease2,
+  matchesKey as matchesKey4,
+  renderFakeCursor,
+  truncateToWidth as truncateToWidth3
+} from "@earendil-works/pi-tui";
 
 class LoginPanel {
   height = 10;
@@ -15079,22 +15492,28 @@ class LoginPanel {
   #provider = "deepseek";
   #message = "";
   #busy = false;
+  #confirmingRemove = false;
   #generation = 0;
+  #closeTimer;
   #unsubscribe;
   #changed;
   #closed;
   #save;
   #remove;
+  #autoCloseMs;
   constructor(options) {
     this.#changed = options.changed;
     this.#closed = options.closed;
     this.#save = options.save;
     this.#remove = options.remove;
+    this.#autoCloseMs = options.autoCloseMs ?? AUTO_CLOSE_MS;
   }
   show(state, subscribe) {
     this.#generation++;
+    this.#clearCloseTimer();
     this.open = true;
     this.#busy = false;
+    this.#confirmingRemove = false;
     this.#message = "";
     this.#input = new Input;
     this.#provider = "deepseek";
@@ -15110,7 +15529,9 @@ class LoginPanel {
   }
   close() {
     this.#generation++;
+    this.#clearCloseTimer();
     this.open = false;
+    this.#confirmingRemove = false;
     this.#input = new Input;
     this.#unsubscribe?.();
     this.#unsubscribe = undefined;
@@ -15127,11 +15548,20 @@ class LoginPanel {
     }
     if (this.#busy)
       return;
+    const confirming = this.#confirmingRemove;
+    this.#confirmingRemove = false;
+    if (confirming && !matchesKey4(data, "ctrl+r"))
+      this.#message = "";
     if (matchesKey4(data, "enter"))
       this.#apply(false);
-    else if (matchesKey4(data, "ctrl+r") && this.#status?.savedConfigured)
-      this.#apply(true);
-    else if (matchesKey4(data, "left") || matchesKey4(data, "right") || matchesKey4(data, "tab"))
+    else if (matchesKey4(data, "ctrl+r") && this.#status?.savedConfigured) {
+      if (confirming)
+        this.#apply(true);
+      else {
+        this.#confirmingRemove = true;
+        this.#message = "Press Ctrl+R again to remove the saved key.";
+      }
+    } else if (matchesKey4(data, "tab") || (matchesKey4(data, "left") || matchesKey4(data, "right")) && this.#input.getValue() === "")
       this.#switch();
     else {
       this.#input.handleInput(data);
@@ -15146,20 +15576,39 @@ class LoginPanel {
   #switch() {
     const index = CREDENTIAL_PROVIDERS.findIndex((spec) => spec.id === this.#provider);
     this.#provider = CREDENTIAL_PROVIDERS[(index + 1) % CREDENTIAL_PROVIDERS.length].id;
-    this.#input = new Input;
     this.#message = "";
   }
+  #clearCloseTimer() {
+    if (this.#closeTimer !== undefined)
+      clearTimeout(this.#closeTimer);
+    this.#closeTimer = undefined;
+  }
+  #scheduleAutoClose(generation) {
+    this.#clearCloseTimer();
+    this.#closeTimer = setTimeout(() => {
+      this.#closeTimer = undefined;
+      if (generation === this.#generation && this.open)
+        this.close();
+    }, this.#autoCloseMs);
+  }
   async#apply(remove) {
-    const key = this.#input.getValue();
-    if (!remove && !key.trim()) {
-      this.#message = "Enter an API key.";
-      this.#changed();
-      return;
+    const key = this.#input.getValue().trim();
+    if (!remove) {
+      if (!key) {
+        this.#message = "Enter an API key.";
+        this.#changed();
+        return;
+      }
+      if (Array.from(key).some((char) => char.charCodeAt(0) < 32)) {
+        this.#message = "Key contains a newline or control character. Remove it and try again.";
+        this.#changed();
+        return;
+      }
     }
     const generation = this.#generation;
     const provider = this.#provider;
     this.#busy = true;
-    this.#message = "Saving...";
+    this.#message = remove ? "Removing..." : "Saving...";
     this.#changed();
     try {
       if (remove)
@@ -15169,10 +15618,11 @@ class LoginPanel {
       if (generation === this.#generation) {
         this.#input = new Input;
         this.#message = remove ? "Saved key removed." : "Saved. Used by the next request.";
+        this.#scheduleAutoClose(generation);
       }
-    } catch {
+    } catch (error) {
       if (generation === this.#generation)
-        this.#message = "Could not update API key. Try again.";
+        this.#message = error instanceof Error ? error.message : "Could not update API key. Try again.";
     } finally {
       if (generation === this.#generation) {
         this.#busy = false;
@@ -15185,20 +15635,25 @@ class LoginPanel {
     const spec = credentialProvider(this.#provider);
     const tabs = CREDENTIAL_PROVIDERS.map((item) => item.id === this.#provider ? `[${item.id}]` : ` ${item.id} `).join(" ");
     const source = state?.source === "keyless" ? "keyless (rate-limited)" : state?.source ?? "Loading...";
+    const keyLength = this.#input.getValue().length;
+    const marker = this.focused ? CURSOR_MARKER2 : "";
+    const keyRow = keyLength > 0 ? `API Key: ********${marker}${this.focused ? renderFakeCursor(" ") : ""} (${keyLength} characters)` : `API Key: ${marker}${this.focused ? `${renderFakeCursor("(")}paste key)` : "(paste key)"}`;
     const rows = [
       `Provider: ${tabs}`,
       `Environment: ${state ? state.environmentConfigured ? "Configured" : "Not configured" : "Loading..."}`,
       `Active source: ${source}`,
-      `API Key: ${"*".repeat(Math.min(this.#input.getValue().length, Math.max(1, width - 15))) || "(paste key)"}`,
+      keyRow,
       this.#message || (spec.keyless ? "Without a key, Tavily runs in rate-limited keyless mode." : "Saved key overrides environment."),
       spec.signupUrl
     ];
-    const help = this.#busy ? shortcutHints(["Esc", "Close"]) : state?.savedConfigured ? shortcutHints(["Enter", "Save"], ["Ctrl+R", "Remove"], ["Left/Right", "Switch"], ["Esc", "Cancel"]) : shortcutHints(["Enter", "Save"], ["Left/Right", "Switch"], ["Esc", "Cancel"]);
+    const switchHint = keyLength > 0 ? ["Tab", "Switch"] : ["Left/Right/Tab", "Switch"];
+    const help = this.#busy ? shortcutHints(["Esc", "Close"]) : this.#confirmingRemove ? shortcutHints(["Ctrl+R", "Confirm remove"], ["Esc", "Cancel"]) : state?.savedConfigured ? shortcutHints(["Enter", "Save"], ["Ctrl+R", "Remove"], switchHint, ["Esc", "Cancel"]) : shortcutHints(["Enter", "Save"], switchHint, ["Esc", "Cancel"]);
     while (rows.length < this.height - 1)
       rows.push("");
     return [...rows.slice(0, Math.max(0, this.height - 1)), help].map((line) => theme.panel(` ${truncateToWidth3(line, Math.max(1, width - 2), "...", true)} `));
   }
 }
+var AUTO_CLOSE_MS = 800;
 var init_login = __esm(() => {
   init_src();
   init_theme();
@@ -16311,6 +16766,7 @@ import {
   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);
@@ -16373,7 +16829,7 @@ async function openReader(runtime, childId, parentId, context, through, historyU
         return () => {};
       const stop = native.subscribe(() => fn(null));
       const stopApprovals = runtime.harness.subscribeCommits(({ changes }) => {
-        if (changes.some((c) => c.type === "document" && c.record.kind === "app.neko.approvals" && c.conversationId === parentId))
+        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 () => {
@@ -16384,7 +16840,12 @@ async function openReader(runtime, childId, parentId, context, through, historyU
     async refresh() {
       const page = await pageAt();
       const approvals = through === undefined ? (await runtime.approvals.list(parentId, context)).filter((a) => a.childId === childId) : [];
-      revision = remember({ ...project(page.entries), approvals, historyBefore: page.next });
+      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) {
@@ -16436,7 +16897,7 @@ function installSubagentHost(host, runtime, context) {
       reader: resource({
         rev: 1,
         async open() {
-          const entry = (await listDelegations(runtime.harness, input.parentId, context)).find((d) => d.taskId === input.taskId);
+          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);
@@ -16466,13 +16927,13 @@ function installSubagentHost(host, runtime, context) {
         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) => d.taskId === input.taskId);
+      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), taskId: input.taskId }, { principal: hostPrincipal });
+    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) => {
@@ -16501,14 +16962,26 @@ function installSubagentHost(host, runtime, context) {
         const entry = await check();
         if (entry.historyThrough !== undefined)
           throw new ChordError("forbidden", "Fork history is read-only");
-        return runtime.approvals.decide(Number(input.sessionId), entry.taskId, id, version, decision, context);
+        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 () => {
+      stop: async (request) => {
         const entry = await check();
         if (entry.historyThrough !== undefined)
           throw new ChordError("forbidden", "Fork history is read-only");
-        await runtime.harness.abortTask(entry.taskId, context);
-        await runtime.harness.waitForTask(entry.taskId, context);
+        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;
       }
     };
@@ -16522,7 +16995,7 @@ var init_subagent_host = __esm(() => {
   init_session_host();
   ChildProjection = local("neko.subagent-projection", {
     version: 1,
-    input: Type5.Object({ parentId: Type5.Integer(), taskId: Type5.Integer() }),
+    input: Type5.Object({ parentId: Type5.Integer(), agentId: Type5.String() }),
     members: {
       revision: Type5.Integer(),
       reader: opaque("neko.subagent-reader@1")
@@ -16543,7 +17016,7 @@ import {
   resource as resource2
 } from "@earendil-works/chord";
 import { withAbortSignal as withAbortSignal3 } from "@earendil-works/chord/context";
-import { UsageDoc as UsageDoc2 } from "@earendil-works/pi-durable";
+import { UsageDoc as UsageDoc4 } from "@earendil-works/pi-durable";
 import { Type as Type6 } from "typebox";
 async function openProjection(runtime, session, context) {
   const view = await session.viewState();
@@ -16560,7 +17033,7 @@ async function openProjection(runtime, session, context) {
   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"].includes(change.record.kind) && change.conversationId === session.id || change.record.kind === "pi.usage" && change.conversationId !== undefined && childIds.has(change.conversationId))))
+    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 {
@@ -16592,15 +17065,19 @@ async function openProjection(runtime, session, context) {
         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 subagents.filter((entry) => entry.historyThrough === undefined))
-        aggregate = mergeUsage(aggregate, await runtime.harness.snapshot(UsageDoc2, child.childId, context) ?? {
+      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,
-        subagents: subagents.map((entry) => ({ ...entry, report: entry.report?.slice(0, 512) ?? null })),
+        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,
@@ -18229,8 +18706,8 @@ function helpLines(platform = process.platform) {
     ["Enter", "Confirm selected approval option"],
     ["PgUp / PgDn", "Scroll full approval command"],
     ["[/]", "Select another pending approval"],
-    ["S", "Stop active task (Enter confirms)"],
-    ["Click", "Open task card or status-bar Agents entry"]
+    ["S", "Stop current round; keep agent context (Enter confirms)"],
+    ["Click", "Open round card or status-bar Agents entry"]
   ]);
   section("Skills", [
     ["U", "Install for user"],
@@ -18707,7 +19184,7 @@ import { matchesKey as matchesKey9 } from "@earendil-works/pi-tui";
 
 class SubagentDetail {
   get help() {
-    const canStop = this.entry?.historyThrough === undefined && (this.entry?.status === "running" || this.entry?.status === "queued");
+    const canStop = this.identity ? this.identity.activeRoundId !== null && this.identity.historyThrough === undefined : this.entry?.historyThrough === undefined && (this.entry?.status === "running" || this.entry?.status === "queued");
     return shortcutHints(["\u2190", "Main"], ["\u2191\u2193/Wheel", "Scroll"], ["E", "Expand"], ...canStop ? [["S", "Stop"]] : []);
   }
   #view;
@@ -18729,6 +19206,9 @@ class SubagentDetail {
   #panel;
   #active = false;
   entry;
+  identity;
+  #targetRound;
+  #locating = false;
   #epoch = 0;
   constructor(client, taskId, panel, changed) {
     this.#service = client.subagent(taskId);
@@ -18755,10 +19235,35 @@ class SubagentDetail {
       if (this.#before === undefined)
         this.#before = view.historyBefore;
       this.#entries = new Map(mergeTranscriptItems([...this.#entries.values()], view.items).map((item) => [item.key, item]));
+      this.#loadTarget();
       this.#changed();
     });
     return this;
   }
+  locate(taskId) {
+    this.#targetRound = taskId;
+    this.#loadTarget();
+    this.#changed();
+  }
+  async#loadTarget() {
+    if (this.#locating || !this.#active || this.#targetRound === undefined)
+      return;
+    const entryId = this.#view?.rounds?.find((r) => r.taskId === this.#targetRound)?.inputEntryId;
+    if (entryId === undefined)
+      return;
+    this.#locating = true;
+    try {
+      while (this.#active && !this.#entries.has(`e${entryId}`) && this.#before != null && !this.#loading) {
+        const before = this.#before;
+        await this.history();
+        if (before === this.#before)
+          break;
+      }
+    } finally {
+      this.#locating = false;
+      this.#changed();
+    }
+  }
   close() {
     this.#epoch++;
     this.#active = false;
@@ -18811,14 +19316,15 @@ class SubagentDetail {
         if (component instanceof AssistantMessageComponent)
           component.setThinkingExpanded(this.#expanded);
       }
-    } else if (data.toLowerCase() === "s" && this.entry?.historyThrough === undefined && (this.entry?.status === "running" || this.entry?.status === "queued"))
+    } else if (data.toLowerCase() === "s" && this.entry?.historyThrough === undefined && (this.identity?.activeRoundId != null || !this.identity && (this.entry?.status === "running" || this.entry?.status === "queued"))) {
+      const stopTaskId = this.identity?.activeRoundId ?? this.entry?.taskId;
       this.#panel.showDetail({
         help: shortcutHints(["Enter", "Stop"], ["Esc", "Back"]),
         lines: () => [theme.warning("Stop this task? Existing changes will be kept.")],
         handleKey: (key) => {
           if (!matchesKey9(key, "enter"))
             return false;
-          this.#service.stop(null).catch((e) => {
+          this.#service.stop(stopTaskId === undefined ? null : { taskId: stopTaskId }).catch((e) => {
             this.#error = String(e);
           }).finally(() => {
             this.#panel.popDetail();
@@ -18827,7 +19333,7 @@ class SubagentDetail {
           return true;
         }
       });
-    else
+    } else
       return false;
     return true;
   }
@@ -18851,14 +19357,25 @@ class SubagentDetail {
     this.#pageSize = Math.max(1, height - 1);
     const entry = this.entry;
     const rows = entry ? [
-      theme.accent(`${entry.role} \xB7 ${entry.title}`),
-      theme.dim(`${entry.historyThrough !== undefined ? "Snapshot \xB7 " : ""}${labels2[entry.status]} \xB7 ${Math.max(0, Math.round(((entry.endedAt ?? Date.now()) - entry.createdAt) / 1000))}s`),
+      theme.accent(`${entry.role} \xB7 ${this.identity?.title ?? entry.title}`),
+      theme.dim(`${entry.historyThrough !== undefined ? "Snapshot \xB7 " : ""}${this.identity ? this.identity.status === "idle" ? "Idle" : this.identity.status === "queued" ? "Queued" : "Running" : labels2[entry.status]} \xB7 ${Math.max(0, Math.round(((entry.endedAt ?? Date.now()) - entry.createdAt) / 1000))}s`),
       ""
     ] : [];
     if (this.#view)
-      rows.push(theme.dim(`In ${this.#view.usage.input} \xB7 Out ${this.#view.usage.output} \xB7 $${this.#view.usage.cost.toFixed(4)}`), "");
+      rows.push(theme.dim(`Total In ${this.#view.usage.input} \xB7 Out ${this.#view.usage.output} \xB7 $${this.#view.usage.cost.toFixed(4)}`), "");
     const imageRows = [];
+    let targetOffset;
     for (const item of [...this.#entries.values()].sort((a, b) => (a.order ?? 0) - (b.order ?? 0))) {
+      if (item.type === "user") {
+        const round = this.#view?.rounds?.find((r) => r.inputEntryId === item.id || r.taskId === item.subagentRoundId);
+        if (round?.taskId === this.#targetRound)
+          targetOffset = rows.length;
+        if (round) {
+          rows.push(theme.accent(`Task ${round.round ?? ""} \xB7 ${round.title} \xB7 ${labels2[round.status]}`));
+          const u = round.roundUsage;
+          rows.push(theme.dim(u ? `Round In ${u.input} \xB7 Out ${u.output} \xB7 Cache ${u.cacheRead}/${u.cacheWrite} \xB7 $${u.cost.toFixed(4)}` : "Round usage not recorded"));
+        }
+      }
       rows.push(...this.#component(item).render(width));
       if (item.type === "tool") {
         for (const approval of this.#view?.approvals ?? [])
@@ -18904,6 +19421,11 @@ class SubagentDetail {
       this.#offset += Math.max(0, this.#maxOffset - this.#prependOffset);
       this.#prependOffset = undefined;
     }
+    if (targetOffset !== undefined) {
+      this.#offset = targetOffset;
+      this.#follow = false;
+      this.#targetRound = undefined;
+    }
     this.#offset = this.#follow ? this.#maxOffset : Math.min(this.#offset, this.#maxOffset);
     for (const image of imageRows) {
       image.image.setVisible(this.#active && image.start < this.#offset + height && image.end > this.#offset);
@@ -18912,11 +19434,11 @@ class SubagentDetail {
     return rows.slice(this.#offset, this.#offset + height);
   }
 }
-var labels2, subagentItems = (entries) => entries.map((d) => ({
-  value: String(d.taskId),
+var labels2, subagentItems = (entries, summaries = summarizeSubagents(entries)) => summaries.map((d) => ({
+  value: d.agentId,
   label: `${d.role} \xB7 ${d.title}`,
-  description: `${d.historyThrough !== undefined ? "Snapshot \xB7 " : ""}${labels2[d.status]}`,
-  rightLabel: d.approvalCount ? `Approval ${d.approvalCount}` : labels2[d.status]
+  description: `${d.historyThrough !== undefined ? "Snapshot \xB7 " : ""}${d.taskTitle} \xB7 ${d.roundCount} rounds`,
+  rightLabel: d.approvalCount ? `Approval ${d.approvalCount}` : d.status === "idle" ? "Idle" : d.status === "queued" ? "Queued" : "Running"
 }));
 var init_subagents_ui = __esm(() => {
   init_src();
@@ -19753,19 +20275,25 @@ class NekoTuiApp {
     this.#agentsPanel = true;
     this.#panel.pointerSelection = true;
     this.#panel.agentNavigation = true;
-    this.#panel.show("Agents", async () => subagentItems(this.#lastView?.subagents ?? []), async (value) => this.#agentDetail(Number(value)));
+    this.#panel.show("Agents", async () => subagentItems(this.#lastView?.subagents ?? [], this.#lastView?.agents), async (value) => this.#agentDetail(value));
     this.#ui.setFocus(this.#panel);
     if (taskId !== undefined)
       this.#panel.showDetail(this.#agentDetail(taskId));
   }
-  #agentDetail(taskId) {
-    let detail = this.#agentDetails.get(taskId);
+  #agentDetail(target) {
+    const round = typeof target === "number" ? this.#lastView?.subagents?.find((r) => r.taskId === target) : undefined;
+    const id = typeof target === "string" ? target : round?.agentId ?? `agent-${round?.childId}`;
+    let detail = this.#agentDetails.get(id);
     if (!detail) {
-      detail = new SubagentDetail(this.#gateway.client, taskId, this.#panel, () => this.#ui.requestRender());
-      this.#agentDetails.set(taskId, detail);
+      detail = new SubagentDetail(this.#gateway.client, id, this.#panel, () => this.#ui.requestRender());
+      this.#agentDetails.set(id, detail);
     }
-    detail.entry = this.#lastView?.subagents?.find((entry) => entry.taskId === taskId);
-    return detail.open();
+    detail.identity = this.#lastView?.agents?.find((a) => a.agentId === id);
+    detail.entry = this.#lastView?.subagents?.find((r) => r.taskId === (detail.identity?.activeRoundId ?? detail.identity?.lastRoundId));
+    detail.open();
+    if (typeof target === "number")
+      detail.locate(target);
+    return detail;
   }
   #closeOverlay() {
     if (this.#panel.open)
@@ -19810,11 +20338,13 @@ class NekoTuiApp {
     else
       this.#approval.close();
     if (this.#agentsPanel)
-      this.#panel.update(subagentItems(view.subagents ?? []));
-    for (const entry of view.subagents ?? []) {
-      const detail = this.#agentDetails.get(entry.taskId);
-      if (detail)
-        detail.entry = entry;
+      this.#panel.update(subagentItems(view.subagents ?? [], view.agents));
+    for (const identity of view.agents ?? []) {
+      const detail = this.#agentDetails.get(identity.agentId);
+      if (detail) {
+        detail.identity = identity;
+        detail.entry = view.subagents?.find((r) => r.taskId === (identity.activeRoundId ?? identity.lastRoundId));
+      }
     }
     const imageModel = `${this.#sessionId}:${view.agent.model?.provider}/${view.agent.model?.modelId}`;
     if (this.#imageWarningModel !== imageModel && view.items.some((i) => (i.type === "user" || i.type === "tool") && i.images?.length)) {
@@ -20014,7 +20544,7 @@ class NekoTuiApp {
   #syncFooter(view) {
     const usage = view.taskUsage ?? view.usage;
     this.#footer.setStats({
-      subagentCount: view.subagents?.length ?? 0,
+      subagentCount: view.agents?.length ?? 0,
       approvalCount: view.subagents?.reduce((n, d) => n + (d.approvalCount ?? 0), 0) ?? 0,
       model: view.model,
       thinkingLevel: view.agent.thinkingLevel,