neko-harness 0.3.0 → 0.3.1

package/dist/gateway.js

@@ -517,7 +517,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 {
@@ -640,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),
@@ -840,7 +844,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";
@@ -1220,9 +1224,58 @@ import {
   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";
+
+// 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,
@@ -1231,6 +1284,14 @@ var DelegationsDoc = defineDoc({
   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,
@@ -1250,157 +1311,401 @@ var ROLE_PROMPTS = {
   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 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.";
+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.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;
+}
+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: "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;
-          }, 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();
+            };
+            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);
-          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
+            }
           };
         }
       })
@@ -1409,15 +1714,70 @@ 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);
 }
+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. 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."
@@ -1627,9 +1987,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";
 var SessionMetadataDoc = defineDoc2({
   kind: "app.neko.session-metadata",
@@ -1694,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 }),
@@ -1908,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) {
@@ -2091,7 +2451,8 @@ function createApprovalExtension(service) {
           const child = await approvals.harness.conversation(api.conversationId, context);
           const agent = await child.agent(context);
           const cwd = await realpath(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, {
@@ -2804,6 +3165,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);
@@ -2988,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);
@@ -3037,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;
@@ -3072,14 +3434,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,
@@ -3315,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.3.0";
-var APPLICATION_PROTOCOL = 3;
+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)));
 }
@@ -3513,6 +3885,12 @@ var call = Type4.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,
@@ -3527,8 +3905,27 @@ var DelegationSchema = Type4.Object({
   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,
@@ -3684,7 +4081,12 @@ var NekoModels = contract("neko.models", {
 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: integer }),
+  input: Type4.Object({
+    sessionId: str,
+    attachmentId: str,
+    taskId: Type4.Optional(integer),
+    agentId: Type4.Optional(str)
+  }),
   variants: {
     ready: {
       state: { revision: integer },
@@ -3697,7 +4099,7 @@ var NekoSubagent = contract("neko.subagent", {
         }), 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)
       }
     }
   }
@@ -3839,7 +4241,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";
 
 // packages/gateway/src/image-uploads.ts
@@ -3946,6 +4348,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);
@@ -4008,7 +4411,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 () => {
@@ -4019,7 +4422,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) {
@@ -4066,7 +4474,7 @@ async function openReader(runtime, childId, parentId, context, through, historyU
 }
 var 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")
@@ -4079,7 +4487,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);
@@ -4109,13 +4517,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) => {
@@ -4144,14 +4552,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;
       }
     };
@@ -4198,7 +4618,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 {
@@ -4230,15 +4650,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,