neko-harness 0.3.0 → 0.3.2

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.2", 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 {
@@ -843,6 +846,51 @@ function toolResultText(content) {
   return content.filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text ?? "").join(`
 `);
 }
+function countDiffLines(diff) {
+  let added = 0;
+  let removed = 0;
+  for (const line of diff.split(`
+`)) {
+    if (line.startsWith("+") && !line.startsWith("+++"))
+      added++;
+    else if (line.startsWith("-") && !line.startsWith("---"))
+      removed++;
+  }
+  return { added, removed };
+}
+function editResultDiff(details) {
+  if (typeof details !== "object" || details === null)
+    return null;
+  const diff = details.diff;
+  return typeof diff === "string" ? diff : null;
+}
+function synthesizedWriteDiff(args) {
+  const record = args ?? {};
+  if (typeof record.content !== "string")
+    return null;
+  const content = record.content;
+  const shown = [];
+  let offset = 0;
+  let bytes = 0;
+  while (offset < content.length && shown.length < WRITE_DIFF_MAX_LINES) {
+    const newline = content.indexOf(`
+`, offset);
+    const end = newline === -1 ? content.length : newline;
+    const overhead = shown.length === 0 ? 2 : 3;
+    const remaining = WRITE_DIFF_MAX_BYTES - bytes - overhead;
+    if (end - offset > remaining)
+      break;
+    const line = content.slice(offset, end);
+    const lineBytes = Buffer.byteLength(line, "utf8");
+    if (lineBytes > remaining)
+      break;
+    shown.push(`+ ${line}`);
+    bytes += lineBytes + overhead;
+    offset = newline === -1 ? content.length : end + 1;
+  }
+  return { diff: shown.join(`
+`), added: shown.length, removed: 0, truncated: offset < content.length };
+}
 function totalUsage(state) {
   const total = {
     input: 0,
@@ -875,6 +923,8 @@ function projectChatView(view, modelLabel, options = {}) {
       if (message.role !== "toolResult")
         continue;
       const diagnostics = entry.data?.diagnostics ?? [];
+      const diff = message.toolName === "edit" ? editResultDiff(message.details) : null;
+      const counts = diff === null ? null : countDiffLines(diff);
       results.set(message.toolCallId, {
         type: "tool",
         key: `t${message.toolCallId}`,
@@ -891,7 +941,10 @@ function projectChatView(view, modelLabel, options = {}) {
         ].filter(Boolean).join(`
 `),
         durationMs: message.durationMs ?? null,
-        note: null
+        note: null,
+        diff,
+        diffAdded: counts?.added ?? null,
+        diffRemoved: counts?.removed ?? null
       });
     }
   }
@@ -926,6 +979,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),
@@ -948,6 +1002,7 @@ function projectChatView(view, modelLabel, options = {}) {
         } else {
           const summary = summarizeToolCall(block.name, block.arguments);
           const slot = live.tools?.find((s) => s.callId === block.id);
+          const synthesized = block.name === "write" ? synthesizedWriteDiff(block.arguments) : null;
           items.push({
             type: "tool",
             key: `t${block.id}`,
@@ -960,7 +1015,11 @@ function projectChatView(view, modelLabel, options = {}) {
             output: slot?.output ?? null,
             result: null,
             durationMs: null,
-            note: ran ? null : "Not run: response interrupted."
+            note: ran ? null : "Not run: response interrupted.",
+            diff: synthesized?.diff ?? null,
+            diffAdded: synthesized?.added ?? null,
+            diffRemoved: synthesized?.removed ?? null,
+            diffTruncated: synthesized?.truncated ?? false
           });
         }
       }
@@ -1008,7 +1067,17 @@ function projectChatView(view, modelLabel, options = {}) {
 }
 function withArgs(item, name, args) {
   const summary = summarizeToolCall(name, args);
-  return { ...item, name, summary: summary.args, detail: summary.detail ?? null };
+  const synthesized = name === "write" ? synthesizedWriteDiff(args) : null;
+  return {
+    ...item,
+    name,
+    summary: summary.args,
+    detail: summary.detail ?? null,
+    diff: synthesized?.diff ?? item.diff,
+    diffAdded: synthesized?.added ?? item.diffAdded,
+    diffRemoved: synthesized?.removed ?? item.diffRemoved,
+    diffTruncated: synthesized?.truncated ?? false
+  };
 }
 function assistantItem(message, id) {
   let thinking = "";
@@ -1061,13 +1130,18 @@ ${block.text}`;
     if (block.type === "toolCall") {
       const slot = live.tools?.find((candidate) => candidate.callId === block.id);
       const summary = summarizeToolCall(block.name, block.arguments);
+      const synthesized = block.name === "write" ? synthesizedWriteDiff(block.arguments) : null;
       toolCalls.push({
         callId: block.id,
         name: block.name,
         summary: summary.args,
         detail: summary.detail ?? null,
         phase: slot === undefined || slot.status === "pending" ? "pending" : slot.status,
-        output: slot?.status === "running" ? slot.output ?? null : null
+        output: slot?.status === "running" ? slot.output ?? null : null,
+        diff: synthesized?.diff ?? null,
+        diffAdded: synthesized?.added ?? null,
+        diffRemoved: synthesized?.removed ?? null,
+        diffTruncated: synthesized?.truncated ?? false
       });
     }
   }
@@ -1087,10 +1161,12 @@ function contextTokens(entries) {
   }
   return null;
 }
+var WRITE_DIFF_MAX_LINES = 2000, WRITE_DIFF_MAX_BYTES;
 var init_projection = __esm(() => {
   init_image_prompt();
   init_input();
   init_workspace();
+  WRITE_DIFF_MAX_BYTES = 64 * 1024;
 });
 
 // packages/core/src/prompt/frontmatter.ts
@@ -1485,164 +1561,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;
-          }, 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
+            }
           };
         }
       })
@@ -1651,11 +1966,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 +2035,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 +2063,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 +2177,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 +2332,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 +2376,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 +2590,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 +2792,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 +3424,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 +3507,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 +3692,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 +3741,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 +3776,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 +4006,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 +4061,7 @@ var init_src = __esm(() => {
   init_frontmatter();
   init_runtime();
   init_session_metadata();
+  init_subagent_usage();
   init_subagents();
   init_tool_approvals();
   init_workspace();
@@ -3674,6 +4121,60 @@ function compactInstructions(text) {
   return match ? match[1]?.trim() ?? "" : null;
 }
 
+// packages/core/src/conversation-items.ts
+function userText2(item) {
+  if (item.skill === undefined)
+    return item.text;
+  return item.skill.args === "" ? `/skill:${item.skill.name}` : `/skill:${item.skill.name} ${item.skill.args}`;
+}
+function toolStatus(item) {
+  return item.phase !== "done" ? item.phase : item.isError ? "error" : "ok";
+}
+function toolOutput(item) {
+  return (item.phase === "done" ? item.result : item.output) ?? "";
+}
+function imageLabel(image) {
+  const size = image.width > 0 && image.height > 0 ? ` \xB7 ${image.width}\xD7${image.height}` : "";
+  return `${image.name} \xB7 ${image.mimeType}${size}`;
+}
+function formatDuration(ms) {
+  return ms < 1000 ? `${Math.round(ms)}ms` : `${(ms / 1000).toFixed(1)}s`;
+}
+function oneLine(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+var FALLBACK_EXPORT_TITLE = "neko-session";
+
+// packages/core/src/input-history.ts
+function promptHistory(items) {
+  const entries = [];
+  for (const item of items) {
+    if (item.type !== "user" || item.subagentRoundId !== undefined)
+      continue;
+    const text = userText2(item).trim();
+    if (text === "" || entries.at(-1) === text)
+      continue;
+    entries.push(text);
+  }
+  return entries.reverse().slice(0, INPUT_HISTORY_LIMIT);
+}
+var INPUT_HISTORY_LIMIT = 100;
+var init_input_history = () => {};
+
+// packages/core/src/session-display.ts
+function relativeTime(at, now, language = "en") {
+  const minutes = Math.floor(Math.max(0, now - at) / 60000);
+  if (minutes < 1)
+    return language === "zh" ? "\u521A\u521A" : "now";
+  const hours = Math.floor(minutes / 60), days = Math.floor(hours / 24);
+  if (days >= 30)
+    return new Date(at).toLocaleDateString(language === "zh" ? "zh-CN" : "en-GB");
+  const value = days || hours || minutes;
+  const unit = days ? ["\u5929", "d"] : hours ? ["\u5C0F\u65F6", "h"] : ["\u5206\u949F", "m"];
+  return language === "zh" ? `${value} ${unit[0]}\u524D` : `${value}${unit[1]}`;
+}
+var sessionName = (session, empty = "New session") => session.title || session.firstPromptPreview || empty, messageTime = (session) => session.lastMessageAt ?? session.createdAt, byMessage = (a, b) => messageTime(b) - messageTime(a) || Number(b.id) - Number(a.id), byVisited = (a, b) => b.lastUsedAt - a.lastUsedAt || Number(b.id) - Number(a.id);
+
 // packages/gateway/src/contract.ts
 import { method, remote } from "@earendil-works/chord";
 import { Type as Type4 } from "typebox";
@@ -3687,7 +4188,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();
@@ -3717,10 +4218,20 @@ var init_contract = __esm(() => {
     summary: str,
     detail: nullableString,
     phase,
-    output: nullableString
+    output: nullableString,
+    diff: nullableString,
+    diffAdded: Type4.Union([num, nil]),
+    diffRemoved: Type4.Union([num, nil]),
+    diffTruncated: Type4.Optional(bool)
   });
   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 +4246,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,
@@ -3800,7 +4330,11 @@ var init_contract = __esm(() => {
         output: nullableString,
         result: nullableString,
         durationMs: Type4.Union([num, nil]),
-        note: nullableString
+        note: nullableString,
+        diff: nullableString,
+        diffAdded: Type4.Union([num, nil]),
+        diffRemoved: Type4.Union([num, nil]),
+        diffTruncated: Type4.Optional(bool)
       }),
       Type4.Object({ type: Type4.Literal("system"), order: Type4.Optional(num), key: str, id: integer, text: str })
     ])),
@@ -3892,7 +4426,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 +4444,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 +4851,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 +4932,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,
@@ -4620,8 +5160,8 @@ var init_palette = __esm(() => {
     codeFg: { fg: "#C0CAF5" },
     border: { fg: "#737DA2" },
     borderMuted: { fg: "#545E7C" },
-    diffAdded: { fg: "#9ECE6A" },
-    diffRemoved: { fg: "#F7768E" },
+    diffAdded: { fg: "#9ECE6A", bg: "#232C32" },
+    diffRemoved: { fg: "#F7768E", bg: "#302735" },
     diffContext: { fg: "#9AA5CE" },
     syntaxComment: { fg: "#8993B3", italic: true },
     syntaxKeyword: { fg: "#BB9AF7", bold: true },
@@ -4655,8 +5195,8 @@ var init_palette = __esm(() => {
     codeFg: { fg: sakura.s800 },
     border: { fg: ink.s300 },
     borderMuted: { fg: ink.s200 },
-    diffAdded: { fg: "#1A7F37" },
-    diffRemoved: { fg: sakura.s800 },
+    diffAdded: { fg: "#1A7F37", bg: "#E4F3E8" },
+    diffRemoved: { fg: sakura.s800, bg: "#FBE7EC" },
     diffContext: { fg: ink.s400 },
     syntaxComment: { fg: ink.s600, italic: true },
     syntaxKeyword: { fg: sakura.s800 },
@@ -4749,6 +5289,10 @@ function getActiveThemeMode() {
 function delegate(name) {
   return (text) => activeTheme[name](text);
 }
+function diffBackgroundAnsi(kind) {
+  const style = (activeMode === "dark" ? DARK_PALETTE : LIGHT_PALETTE)[kind === "added" ? "diffAdded" : "diffRemoved"];
+  return backgroundAnsi(parseColor(style.bg), getTerminalColorMode());
+}
 var darkTheme, lightTheme, THEMES, activeMode = "dark", activeTheme, theme, sgr = (attrs) => (text) => styleText(text, {
   ...attrs.bold !== undefined ? { bold: attrs.bold } : {},
   ...attrs.italic !== undefined ? { italic: attrs.italic } : {},
@@ -14173,7 +14717,7 @@ function solidBlock(lines, fullWidth) {
   const max = Math.max(fullWidth ?? 0, ...lines.map((line) => line.width));
   return lines.map((line) => theme.codeBg(line.styled + " ".repeat(Math.max(0, max - line.width))));
 }
-function renderHighlighted(html, fullWidth) {
+function htmlToSegmentLines(html) {
   const segments = [];
   const scopes = [];
   let textBuffer = "";
@@ -14226,25 +14770,31 @@ function renderHighlighted(html, fullWidth) {
   }
   flushText();
   const lines = [];
-  let current = "";
-  let currentWidth = 0;
+  let current = [];
   for (const segment of segments) {
     const parts = segment.text.split(`
 `);
     for (const [i, part] of parts.entries()) {
       if (i > 0) {
-        lines.push({ styled: current, width: currentWidth });
-        current = "";
-        currentWidth = 0;
+        lines.push(current);
+        current = [];
       }
       if (part === "")
         continue;
-      currentWidth += visibleWidth(part);
-      current += segment.slot === "plain" ? theme.codeFg(part) : theme[segment.slot](part);
+      current.push({ slot: segment.slot, text: part });
     }
   }
-  lines.push({ styled: current, width: currentWidth });
-  return solidBlock(lines, fullWidth);
+  lines.push(current);
+  return lines;
+}
+function styleSegmentLine(segments) {
+  return {
+    styled: segments.map((s) => s.slot === "plain" ? theme.codeFg(s.text) : theme[s.slot](s.text)).join(""),
+    width: segments.reduce((total, s) => total + visibleWidth(s.text), 0)
+  };
+}
+function renderHighlighted(html, fullWidth) {
+  return solidBlock(htmlToSegmentLines(html).map(styleSegmentLine), fullWidth);
 }
 function normalizeLang(lang) {
   if (lang === undefined)
@@ -14252,6 +14802,28 @@ function normalizeLang(lang) {
   const lowered = lang.trim().toLowerCase();
   return LANG_ALIASES[lowered] ?? lowered;
 }
+function highlightCodeToSegments(code, lang) {
+  const normalized = normalizeLang(lang);
+  if (normalized === "" || core_default.getLanguage(normalized) === undefined)
+    return null;
+  try {
+    return htmlToSegmentLines(core_default.highlight(code, { language: normalized }).value);
+  } catch {
+    return null;
+  }
+}
+function languageForPath(path) {
+  if (path === undefined)
+    return;
+  const base = path.slice(path.lastIndexOf("/") + 1).toLowerCase();
+  const dot = base.lastIndexOf(".");
+  if (dot <= 0)
+    return;
+  const ext = base.slice(dot + 1);
+  if (ext === "" || core_default.getLanguage(ext) === undefined)
+    return;
+  return ext;
+}
 function highlightCodeToAnsiLines(code, lang, fullWidth) {
   const normalized = normalizeLang(lang);
   if (normalized !== "" && core_default.getLanguage(normalized) !== undefined) {
@@ -14571,32 +15143,1894 @@ var init_approval_dock = __esm(() => {
   init_theme();
 });
 
-// packages/tui/src/components/assistant-message.ts
-import { Container, Markdown, MouseRegion, Spacer, Text as Text2 } from "@earendil-works/pi-tui";
-var THINKING_COLLAPSED_LABEL = "\u2727 Thinking\u2026 (click to expand)", AssistantMessageComponent;
-var init_assistant_message = __esm(() => {
-  init_theme();
-  AssistantMessageComponent = class AssistantMessageComponent extends Container {
-    #renderTheme = getActiveThemeMode();
-    #lastContent;
-    #isStreaming = false;
-    #thinkingExpanded = false;
-    #renderWidth = 80;
-    constructor(content, isStreaming = false) {
-      super();
-      if (content !== undefined)
-        this.updateContent(content, isStreaming);
-    }
-    render(width) {
-      if (this.#renderTheme !== getActiveThemeMode()) {
-        this.#renderTheme = getActiveThemeMode();
-        this.#rebuild();
-      }
-      this.#renderWidth = width;
-      return super.render(width);
+// node_modules/marked/lib/marked.esm.js
+function I() {
+  return { async: false, breaks: false, extensions: null, gfm: true, hooks: null, pedantic: false, renderer: null, silent: false, tokenizer: null, walkTokens: null };
+}
+function W(l) {
+  P = l;
+}
+function C(l) {
+  let e = [];
+  return (t) => {
+    let n = Math.max(0, Math.min(3, t - 1)), s = e[n];
+    return s || (s = l(n), e[n] = s), s;
+  };
+}
+function h(l, e = "") {
+  let t = typeof l == "string" ? l : l.source, n = { replace: (s, r) => {
+    let o = typeof r == "string" ? r : r.source;
+    return o = o.replace(x.caret, "$1"), t = t.replace(s, o), n;
+  }, getRegex: () => new RegExp(t, e) };
+  return n;
+}
+function O(l, e) {
+  if (e) {
+    if (x.escapeTest.test(l))
+      return l.replace(x.escapeReplace, Re);
+  } else if (x.escapeTestNoEncode.test(l))
+    return l.replace(x.escapeReplaceNoEncode, Re);
+  return l;
+}
+function Te(l) {
+  return l.replace(x.numericCharacterReference, (e, t, n) => {
+    let s = t === undefined ? Number.parseInt(n, 16) : Number.parseInt(t, 10);
+    return s === 0 || s > 1114111 || s >= 55296 && s <= 57343 ? "\uFFFD" : String.fromCodePoint(s);
+  });
+}
+function re(l) {
+  try {
+    l = encodeURI(l).replace(x.percentDecode, "%");
+  } catch {
+    return null;
+  }
+  return l;
+}
+function se(l, e) {
+  let t = l.replace(x.findPipe, (r, o, i) => {
+    let u = false, a = o;
+    for (;--a >= 0 && i[a] === "\\"; )
+      u = !u;
+    return u ? "|" : " |";
+  }), n = t.split(x.splitPipe), s = 0;
+  if (n[0].trim() || n.shift(), n.length > 0 && !n.at(-1)?.trim() && n.pop(), e)
+    if (n.length > e)
+      n.splice(e);
+    else
+      for (;n.length < e; )
+        n.push("");
+  for (;s < n.length; s++)
+    n[s] = n[s].trim().replace(x.slashPipe, "|");
+  return n;
+}
+function L(l, e, t) {
+  let n = l.length;
+  if (n === 0)
+    return "";
+  let s = 0;
+  for (;s < n; ) {
+    let r = l.charAt(n - s - 1);
+    if (r === e && !t)
+      s++;
+    else if (r !== e && t)
+      s++;
+    else
+      break;
+  }
+  return l.slice(0, n - s);
+}
+function ie(l) {
+  let e = l.split(`
+`), t = e.length - 1;
+  for (;t >= 0 && x.blankLine.test(e[t]); )
+    t--;
+  return e.length - t <= 2 ? l : e.slice(0, t + 1).join(`
+`);
+}
+function q(l) {
+  return l.trim().toLowerCase().toUpperCase().toLowerCase();
+}
+function oe(l, e) {
+  if (l.indexOf(e[0]) === -1 && l.indexOf(e[1]) === -1)
+    return -1;
+  let t = 0;
+  for (let n = 0;n < l.length; n++)
+    if (l[n] === "\\")
+      n++;
+    else if (l[n] === e[0])
+      t++;
+    else if (l[n] === e[1] && (t--, t < 0))
+      return n;
+  return t > 0 ? -2 : -1;
+}
+function ae(l, e = 0) {
+  let t = e, n = "";
+  for (let s of l)
+    if (s === "\t") {
+      let r = 4 - t % 4;
+      n += " ".repeat(r), t += r;
+    } else
+      n += s, t++;
+  return n;
+}
+function Oe(l, e, t, n, s) {
+  let r = e.href, o = e.title || null, i = l[1].replace(s.other.outputLinkReplace, "$1"), u = l[0].charAt(0) === "!";
+  n.state.inLink = true;
+  let a = n.state.linkEmitted, p = n.state.inRawBlock;
+  n.state.linkEmitted = false;
+  let c = n.inlineTokens(i), d = n.state.linkEmitted;
+  if (n.state.linkEmitted = a, n.state.inLink = false, !u) {
+    if (d) {
+      n.state.inRawBlock = p;
+      return;
     }
-    #highlightWidth() {
-      return Math.max(10, this.#renderWidth - 4);
+    n.state.linkEmitted = true;
+  }
+  return { type: u ? "image" : "link", raw: t, href: r, title: o, text: i, tokens: c };
+}
+function Pt(l, e, t) {
+  let n = l.match(t.other.indentCodeCompensation);
+  if (n === null)
+    return e;
+  let s = n[1];
+  return e.split(`
+`).map((r) => {
+    let o = r.match(t.other.beginningSpace);
+    if (o === null)
+      return r;
+    let [i] = o;
+    return r.slice(Math.min(i.length, s.length));
+  }).join(`
+`);
+}
+function we(l, e, t, n) {
+  if (!e.includes("<"))
+    return false;
+  for (let s = 0;s < e.length; s++) {
+    if (e[s] === "\\") {
+      s++;
+      continue;
+    }
+    if (e[s] === "`") {
+      let i = n.inline.code.exec(e.slice(s));
+      if (i) {
+        s += i[0].length - 1;
+        continue;
+      }
+    }
+    if (e[s] !== "<")
+      continue;
+    let r = l.slice(t + s), o = n.inline.tag.exec(r) || n.inline.autolink.exec(r);
+    if (o) {
+      if (o[0].length > e.length - s)
+        return true;
+      s += o[0].length - 1;
+    }
+  }
+  return false;
+}
+function k(l, e) {
+  return E.parse(l, e);
+}
+function yt(...l) {
+  return E.use(...l), k.defaults = E.defaults, W(k.defaults), k;
+}
+var P, A, _e, x, $e, Le, ze, G, Ae, J, he, de, Ee, V, Me, Y, Ie, Ce, N = "address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[1-6]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|meta|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul", ee, Be, ke = (l) => h(V).replace("hr", G).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("|table", "").replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*(?:\\n|$))|~~~)[^\\n]*(?:\\n|$)").replace("list", l).replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", N).getRegex(), De, qe, ve, te, ue, Ze, He, Ge, Ne, ge, Qe, $, B, Q, je, Fe, fe, Ue, Ke, We, me, Xe, Je, Ve, Ye, xe = "^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)punct(\\*+)(?=[\\s]|$)|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)|(?!\\*)punctSpace(\\*+)(?=notPunctSpace)|[\\s](\\*+)(?!\\*)(?=punct)|(?!\\*)punct(\\*+)(?!\\*)(?=punct)|notPunctSpace(\\*+)(?=notPunctSpace)", et, tt, nt = "^[^_*]*?__[^_*]*?\\*[^_*]*?(?=__)|[^*]+(?=[^*])|(?!\\*)punct(\\*+)(?=[\\s]|$)|notPunctSpace(\\*+)(?!\\*)(?=punctSpace|$)|(?!\\*)[\\s](\\*+)(?=notPunctSpace)|[\\s](\\*+)(?!\\*)(?=punct)|(?!\\*)punct(\\*+)(?!\\*)(?=punct)|(?:(?!\\*)punct|notPunctSpace)(\\*+)(?!\\*)(?=notPunctSpace)", rt, st, it = "^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)[\\s](_+)(?=notPunctSpace)|[\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)|(?:(?!_)punct|notPunctSpace)(_+)(?!_)(?=notPunctSpace)", ot, at, lt = "^[^~]+(?=[^~])|(?!~)punct(~~?)(?=[\\s]|$)|notPunctSpace(~~?)(?!~)(?=punctSpace|$)|(?!~)punctSpace(~~?)(?=notPunctSpace)|[\\s](~~?)(?!~)(?=punct)|(?!~)punct(~~?)(?!~)(?=punct)|notPunctSpace(~~?)(?=notPunctSpace)", ut, pt, ct, ht, dt, be, U, kt, gt, ft, pe, mt, xt, ce, bt, Rt, ne, Tt, X, Ot, j, D, wt, Re = (l) => wt[l], y = class {
+  options;
+  rules;
+  lexer;
+  constructor(e) {
+    this.options = e || P;
+  }
+  space(e) {
+    let t = this.rules.block.newline.exec(e);
+    if (t && t[0].length > 0)
+      return { type: "space", raw: t[0] };
+  }
+  code(e) {
+    let t = this.rules.block.code.exec(e);
+    if (t) {
+      let n = this.options.pedantic ? t[0] : ie(t[0]), s = n.replace(this.rules.other.codeRemoveIndent, "");
+      return { type: "code", raw: n, codeBlockStyle: "indented", text: s };
+    }
+  }
+  fences(e) {
+    let t = this.rules.block.fences.exec(e);
+    if (t) {
+      let n = t[0], s = Pt(n, t[3] || "", this.rules);
+      return { type: "code", raw: n, lang: t[2] ? t[2].trim().replace(this.rules.inline.anyPunctuation, "$1") : t[2], text: s };
+    }
+  }
+  heading(e) {
+    let t = this.rules.block.heading.exec(e);
+    if (t) {
+      let n = t[2].trim();
+      if (this.rules.other.endingHash.test(n)) {
+        let s = L(n, "#");
+        (this.options.pedantic || !s || this.rules.other.endingSpaceTabChar.test(s)) && (n = s.trim());
+      }
+      return { type: "heading", raw: L(t[0], `
+`), depth: t[1].length, text: n, tokens: this.lexer.inline(n) };
+    }
+  }
+  hr(e) {
+    let t = this.rules.block.hr.exec(e);
+    if (t)
+      return { type: "hr", raw: L(t[0], `
+`) };
+  }
+  blockquote(e) {
+    let t = this.rules.block.blockquote.exec(e);
+    if (t) {
+      let n = L(t[0], `
+`).split(`
+`), s = "", r = "", o = [];
+      for (;n.length > 0; ) {
+        let i = false, u = [], a;
+        for (a = 0;a < n.length; a++)
+          if (this.rules.other.blockquoteStart.test(n[a]))
+            u.push(n[a]), i = true;
+          else if (!i)
+            u.push(n[a]);
+          else
+            break;
+        n = n.slice(a);
+        let p = u.join(`
+`), c = p.replace(this.rules.other.blockquoteSetextReplace, `
+    $1`).replace(this.rules.other.blockquoteSetextReplace2, "");
+        s = s ? `${s}
+${p}` : p, r = r ? `${r}
+${c}` : c;
+        let d = this.lexer.state.top;
+        if (this.lexer.state.top = true, this.lexer.blockTokens(c, o, true), this.lexer.state.top = d, n.length === 0)
+          break;
+        let m = o.at(-1);
+        if (m?.type === "code")
+          break;
+        if (m?.type === "blockquote") {
+          let b = m, g = n.join(`
+`), w = b.raw + `
+` + g.replace(this.rules.other.blockquoteSetextReplace2, ""), f = this.blockquote(w);
+          o[o.length - 1] = f;
+          let M = w.substring(f.raw.length).replace(/^\n/, ""), v = M ? M.split(`
+`).length : 0, Z = v ? n.slice(0, -v) : n;
+          Z.length > 0 && (s = `${s}
+${Z.join(`
+`)}`), r = r.substring(0, r.length - b.text.length) + f.text;
+          break;
+        } else if (m?.type === "list") {
+          let b = m, g = b.raw + `
+` + n.join(`
+`), w = this.list(g);
+          o[o.length - 1] = w, s = s.substring(0, s.length - m.raw.length) + w.raw, r = r.substring(0, r.length - b.raw.length) + w.raw, n = g.substring(o.at(-1).raw.length).split(`
+`);
+          continue;
+        }
+      }
+      return { type: "blockquote", raw: s, tokens: o, text: r };
+    }
+  }
+  list(e) {
+    let t = this.rules.block.list.exec(e);
+    if (t) {
+      let n = t[1].trim(), s = n.length > 1, r = { type: "list", raw: "", ordered: s, start: s ? +n.slice(0, -1) : "", loose: false, items: [] };
+      n = s ? `\\d{1,9}\\${n.slice(-1)}` : `\\${n}`, this.options.pedantic && (n = s ? n : "[*+-]");
+      let o = this.rules.other.listItemRegex(n), i = false;
+      for (;e; ) {
+        let a = false, p = "", c = "";
+        if (!(t = o.exec(e)) || this.rules.block.hr.test(e))
+          break;
+        p = t[0], e = e.substring(p.length);
+        let d = t[2].split(`
+`, 1)[0], m = t[1].length, b = this.options.pedantic ? ae(d, m) : d.replace(this.rules.other.leadingSpaceTab, (M) => ae(M, m)), g = e.split(`
+`, 1)[0], w = !b.trim(), f = 0;
+        if (this.options.pedantic ? (f = 2, c = b.trimStart()) : w ? f = m + 1 : (f = b.search(this.rules.other.nonSpaceChar), f = f > 4 ? 1 : f, c = b.slice(f), f += m), w && this.rules.other.blankLine.test(g) && (p += g + `
+`, e = e.substring(g.length + 1), a = true), !a) {
+          let M = this.rules.other.nextBulletRegex(f), v = this.rules.other.hrRegex(f), Z = this.rules.other.fencesBeginRegex(f), le = this.rules.other.headingBeginRegex(f), Pe = this.rules.other.htmlBeginRegex(f), ye = this.rules.other.blockquoteBeginRegex(f);
+          for (;e; ) {
+            let K = e.split(`
+`, 1)[0], H;
+            if (g = K, this.options.pedantic ? (g = g.replace(this.rules.other.listReplaceNesting, "  "), H = g) : H = g.replace(this.rules.other.leadingSpaceTab, (Se) => Se.replace(this.rules.other.tabCharGlobal, "    ")), Z.test(g) || le.test(g) || Pe.test(g) || ye.test(g) || M.test(g) || v.test(g))
+              break;
+            if (H.search(this.rules.other.nonSpaceChar) >= f || !g.trim())
+              c += `
+` + H.slice(f);
+            else {
+              if (w || b.replace(this.rules.other.tabCharGlobal, "    ").search(this.rules.other.nonSpaceChar) >= 4 || Z.test(b) || le.test(b) || v.test(b))
+                break;
+              c += `
+` + g;
+            }
+            w = !g.trim(), p += K + `
+`, e = e.substring(K.length + 1), b = H.slice(f);
+          }
+        }
+        r.loose || (i ? r.loose = true : this.rules.other.doubleBlankLine.test(p) && (i = true)), r.items.push({ type: "list_item", raw: p, task: !!this.options.gfm && this.rules.other.listIsTask.test(c), loose: false, text: c, tokens: [] }), r.raw += p;
+      }
+      let u = r.items.at(-1);
+      if (u)
+        u.raw = u.raw.trimEnd(), u.text = u.text.trimEnd();
+      else
+        return;
+      r.raw = r.raw.trimEnd();
+      for (let a of r.items)
+        if (this.lexer.state.top = false, a.tokens = this.lexer.blockTokens(a.text, []), !r.loose) {
+          let p = a.tokens.filter((d) => d.type === "space"), c = p.length > 0 && p.some((d) => this.rules.other.anyLine.test(d.raw));
+          r.loose = c;
+        }
+      for (let a of r.items) {
+        let p = a.tokens[0];
+        if (a.task && (p?.type === "text" || p?.type === "paragraph")) {
+          a.text = a.text.replace(this.rules.other.listReplaceTask, ""), p.raw = p.raw.replace(this.rules.other.listReplaceTask, ""), p.text = p.text.replace(this.rules.other.listReplaceTask, "");
+          for (let d = this.lexer.inlineQueue.length - 1;d >= 0; d--)
+            if (this.rules.other.listIsTask.test(this.lexer.inlineQueue[d].src)) {
+              this.lexer.inlineQueue[d].src = this.lexer.inlineQueue[d].src.replace(this.rules.other.listReplaceTask, "");
+              break;
+            }
+          let c = this.rules.other.listTaskCheckbox.exec(a.raw);
+          if (c) {
+            let d = { type: "checkbox", raw: c[0] + " ", checked: c[0] !== "[ ]" };
+            a.checked = d.checked, r.loose ? a.tokens[0] && ["paragraph", "text"].includes(a.tokens[0].type) && "tokens" in a.tokens[0] && a.tokens[0].tokens ? (a.tokens[0].raw = d.raw + a.tokens[0].raw, a.tokens[0].text = d.raw + a.tokens[0].text, a.tokens[0].tokens.unshift(d)) : a.tokens.unshift({ type: "paragraph", raw: d.raw, text: d.raw, tokens: [d] }) : a.tokens.unshift(d);
+          }
+        } else
+          a.task && (a.task = false);
+      }
+      if (r.loose)
+        for (let a of r.items) {
+          a.loose = true;
+          for (let p of a.tokens)
+            p.type === "text" && (p.type = "paragraph");
+        }
+      return r;
+    }
+  }
+  html(e) {
+    let t = this.rules.block.html.exec(e);
+    if (t) {
+      let n = ie(t[0]);
+      return { type: "html", block: true, raw: n, pre: t[1] === "pre" || t[1] === "script" || t[1] === "style", text: n };
+    }
+  }
+  def(e) {
+    let t = this.rules.block.def.exec(e);
+    if (t) {
+      if (!this.rules.other.startAngleBracket.test(t[2]) && oe(t[2], "()") !== -1)
+        return;
+      let n = q(t[1]).replace(this.rules.other.multipleSpaceGlobal, " "), s = t[2] ? t[2].replace(this.rules.other.hrefBrackets, "$1").replace(this.rules.inline.anyPunctuation, "$1") : "", r = t[3] ? t[3].substring(1, t[3].length - 1).replace(this.rules.inline.anyPunctuation, "$1") : t[3];
+      return { type: "def", tag: n, raw: L(t[0], `
+`), href: s, title: r };
+    }
+  }
+  table(e) {
+    let t = this.rules.block.table.exec(e);
+    if (!t || !this.rules.other.tableDelimiter.test(t[2]))
+      return;
+    let n = se(t[1]), s = t[2].replace(this.rules.other.tableAlignChars, "").split("|"), r = t[3]?.trim() ? t[3].replace(this.rules.other.tableRowBlankLine, "").split(`
+`) : [], o = { type: "table", raw: L(t[0], `
+`), header: [], align: [], rows: [] };
+    if (n.length === s.length) {
+      for (let i of s)
+        this.rules.other.tableAlignRight.test(i) ? o.align.push("right") : this.rules.other.tableAlignCenter.test(i) ? o.align.push("center") : this.rules.other.tableAlignLeft.test(i) ? o.align.push("left") : o.align.push(null);
+      for (let i = 0;i < n.length; i++)
+        o.header.push({ text: n[i], tokens: this.lexer.inline(n[i]), header: true, align: o.align[i] });
+      for (let i of r)
+        o.rows.push(se(i, o.header.length).map((u, a) => ({ text: u, tokens: this.lexer.inline(u), header: false, align: o.align[a] })));
+      return o;
+    }
+  }
+  lheading(e) {
+    let t = this.rules.block.lheading.exec(e);
+    if (t) {
+      let n = t[1].trim();
+      return { type: "heading", raw: L(t[0], `
+`), depth: t[2].charAt(0) === "=" ? 1 : 2, text: n, tokens: this.lexer.inline(n) };
+    }
+  }
+  paragraph(e) {
+    let t = this.rules.block.paragraph.exec(e);
+    if (t) {
+      let n = t[1].charAt(t[1].length - 1) === `
+` ? t[1].slice(0, -1) : t[1];
+      return { type: "paragraph", raw: t[0], text: n, tokens: this.lexer.inline(n) };
+    }
+  }
+  text(e) {
+    let t = this.rules.block.text.exec(e);
+    if (t)
+      return { type: "text", raw: t[0], text: t[0], tokens: this.lexer.inline(t[0]) };
+  }
+  escape(e) {
+    let t = this.rules.inline.escape.exec(e);
+    if (t)
+      return { type: "escape", raw: t[0], text: t[1] };
+  }
+  tag(e) {
+    let t = this.rules.inline.tag.exec(e);
+    if (t)
+      return !this.lexer.state.inLink && this.rules.other.startATag.test(t[0]) ? this.lexer.state.inLink = true : this.lexer.state.inLink && this.rules.other.endATag.test(t[0]) && (this.lexer.state.inLink = false), !this.lexer.state.inRawBlock && this.rules.other.startPreScriptTag.test(t[0]) ? this.lexer.state.inRawBlock = true : this.lexer.state.inRawBlock && this.rules.other.endPreScriptTag.test(t[0]) && (this.lexer.state.inRawBlock = false), { type: "html", raw: t[0], inLink: this.lexer.state.inLink, inRawBlock: this.lexer.state.inRawBlock, block: false, text: t[0] };
+  }
+  link(e) {
+    if (this.lexer.state.linkParenPossible === false)
+      return;
+    let t = this.rules.inline.link.exec(e);
+    if (t) {
+      let n = t[0].charAt(0) === "!" ? 2 : 1;
+      if (!this.options.pedantic && we(e, t[1], n, this.rules))
+        return;
+      let s = t[2].trim();
+      if (!this.options.pedantic && this.rules.other.startAngleBracket.test(s)) {
+        if (!this.rules.other.endAngleBracket.test(s))
+          return;
+        let i = L(s.slice(0, -1), "\\");
+        if ((s.length - i.length) % 2 === 0)
+          return;
+      } else {
+        let i = oe(t[2], "()");
+        if (i === -2)
+          return;
+        if (i > -1) {
+          let a = (t[0].indexOf("!") === 0 ? 5 : 4) + t[1].length + i;
+          t[2] = t[2].substring(0, i), t[0] = t[0].substring(0, a).trim(), t[3] = "";
+        }
+      }
+      let r = t[2], o = "";
+      if (this.options.pedantic) {
+        let i = this.rules.other.pedanticHrefTitle.exec(r);
+        i && (r = i[1], o = i[3]);
+      } else
+        o = t[3] ? t[3].slice(1, -1) : "";
+      return r = r.trim(), this.rules.other.startAngleBracket.test(r) && (this.options.pedantic && !this.rules.other.endAngleBracket.test(s) ? r = r.slice(1) : r = r.slice(1, -1)), Oe(t, { href: r && r.replace(this.rules.inline.anyPunctuation, "$1"), title: o && o.replace(this.rules.inline.anyPunctuation, "$1") }, t[0], this.lexer, this.rules);
+    }
+  }
+  reflink(e, t) {
+    let n;
+    if ((n = this.rules.inline.reflink.exec(e)) || (n = this.rules.inline.nolink.exec(e))) {
+      let s = n[0].charAt(0) === "!" ? 2 : 1;
+      if (!this.options.pedantic && we(e, n[1], s, this.rules))
+        return;
+      let r = (n[2] || n[1]).replace(this.rules.other.multipleSpaceGlobal, " "), o = t[q(r)];
+      if (!o) {
+        let i = n[0].charAt(0);
+        return { type: "text", raw: i, text: i };
+      }
+      return Oe(n, o, n[0], this.lexer, this.rules);
+    }
+  }
+  emStrong(e, t, n = "") {
+    let s = this.rules.inline.emStrongLDelim.exec(e);
+    if (!s || !s[1] && !s[2] && !s[3] && !s[4] || s[4] && n.match(this.rules.other.unicodeAlphaNumeric))
+      return;
+    if (!(s[1] || s[3] || "") || !n || this.rules.inline.punctuation.exec(n)) {
+      let o = [...s[0]].length - 1, i, u, a = o, p = 0, c = s[0][0], d = n === c, m = c === "*" ? this.rules.inline.emStrongRDelimAst : this.rules.inline.emStrongRDelimUnd;
+      for (m.lastIndex = 0, t = t.slice(-1 * e.length + o);(s = m.exec(t)) !== null; ) {
+        if (i = s[1] || s[2] || s[3] || s[4] || s[5] || s[6], !i)
+          continue;
+        if (u = [...i].length, s[3] || s[4]) {
+          a += u;
+          continue;
+        } else if (s[5] || s[6]) {
+          if (o % 3 && !((o + u) % 3)) {
+            p += u;
+            continue;
+          }
+          if (d)
+            break;
+        }
+        if (a -= u, a > 0)
+          continue;
+        u = Math.min(u, u + a + p);
+        let b = [...s[0]][0].length, g = e.slice(0, o + s.index + b + u);
+        if (Math.min(o, u) % 2) {
+          let f = g.slice(1, -1);
+          return { type: "em", raw: g, text: f, tokens: this.lexer.inlineTokens(f) };
+        }
+        let w = g.slice(2, -2);
+        return { type: "strong", raw: g, text: w, tokens: this.lexer.inlineTokens(w) };
+      }
+    }
+  }
+  codespan(e) {
+    let t = this.rules.inline.code.exec(e);
+    if (t) {
+      let n = t[2].replace(this.rules.other.newLineCharGlobal, " "), s = this.rules.other.nonSpaceChar.test(n), r = this.rules.other.startingSpaceChar.test(n) && this.rules.other.endingSpaceChar.test(n);
+      return s && r && (n = n.substring(1, n.length - 1)), { type: "codespan", raw: t[0], text: n };
+    }
+  }
+  br(e) {
+    let t = this.rules.inline.br.exec(e);
+    if (t)
+      return { type: "br", raw: t[0] };
+  }
+  del(e, t, n = "") {
+    let s = this.rules.inline.delLDelim.exec(e);
+    if (!s)
+      return;
+    if (!(s[1] || "") || !n || this.rules.inline.punctuation.exec(n)) {
+      let o = [...s[0]].length - 1, i, u, a = o, p = this.rules.inline.delRDelim;
+      for (p.lastIndex = 0, t = t.slice(-1 * e.length + o);(s = p.exec(t)) !== null; ) {
+        if (i = s[1] || s[2] || s[3] || s[4] || s[5] || s[6], !i || (u = [...i].length, u !== o))
+          continue;
+        if (s[3] || s[4]) {
+          a += u;
+          continue;
+        }
+        if (a -= u, a > 0)
+          continue;
+        u = Math.min(u, u + a);
+        let c = [...s[0]][0].length, d = e.slice(0, o + s.index + c + u), m = d.slice(o, -o);
+        return { type: "del", raw: d, text: m, tokens: this.lexer.inlineTokens(m) };
+      }
+    }
+  }
+  autolink(e) {
+    let t = this.rules.inline.autolink.exec(e);
+    if (t) {
+      let n, s;
+      return t[2] === "@" ? (n = t[1], s = "mailto:" + n) : (n = t[1], s = n), { type: "link", raw: t[0], text: n, href: s, autolink: true, tokens: [{ type: "text", raw: n, text: n }] };
+    }
+  }
+  url(e) {
+    let t;
+    if (t = this.rules.inline.url.exec(e)) {
+      let n, s;
+      if (t[2] === "@")
+        n = t[0], s = "mailto:" + n;
+      else {
+        let r;
+        do
+          r = t[0], t[0] = this.rules.inline._backpedal.exec(t[0])?.[0] ?? "";
+        while (r !== t[0]);
+        n = t[0], t[1] === "www." ? s = "http://" + t[0] : s = t[0];
+      }
+      return { type: "link", raw: t[0], text: n, href: s, autolink: true, tokens: [{ type: "text", raw: n, text: n }] };
+    }
+  }
+  inlineText(e) {
+    let t = this.rules.inline.text.exec(e);
+    if (t) {
+      let n = this.lexer.state.inRawBlock;
+      return { type: "text", raw: t[0], text: n ? t[0] : Te(t[0]), escaped: n };
+    }
+  }
+}, R = class l {
+  tokens;
+  options;
+  state;
+  inlineQueue;
+  tokenizer;
+  constructor(e) {
+    this.tokens = [], this.tokens.links = Object.create(null), this.options = e || P, this.options.tokenizer = this.options.tokenizer || new y, this.tokenizer = this.options.tokenizer, this.tokenizer.options = this.options, this.tokenizer.lexer = this, this.inlineQueue = [], this.state = { inLink: false, inRawBlock: false, linkEmitted: false, linkParenPossible: true, top: true };
+    let t = { other: x, block: j.normal, inline: D.normal };
+    this.options.pedantic ? (t.block = j.pedantic, t.inline = D.pedantic) : this.options.gfm && (t.block = j.gfm, this.options.breaks ? t.inline = D.breaks : t.inline = D.gfm), this.tokenizer.rules = t;
+  }
+  static get rules() {
+    return { block: j, inline: D };
+  }
+  static lex(e, t) {
+    return new l(t).lex(e);
+  }
+  static lexInline(e, t) {
+    return new l(t).inlineTokens(e);
+  }
+  lex(e) {
+    e = e.replace(x.carriageReturn, `
+`), this.blockTokens(e, this.tokens);
+    for (let t = 0;t < this.inlineQueue.length; t++) {
+      let n = this.inlineQueue[t];
+      this.inlineTokens(n.src, n.tokens);
+    }
+    return this.inlineQueue = [], this.tokens;
+  }
+  blockTokens(e, t = [], n = false) {
+    this.tokenizer.lexer = this, this.options.pedantic && (e = e.replace(x.tabCharGlobal, "    ").replace(x.spaceLine, ""));
+    let s = 1 / 0;
+    for (;e; ) {
+      if (e.length < s)
+        s = e.length;
+      else {
+        this.infiniteLoopError(e.charCodeAt(0));
+        break;
+      }
+      let r;
+      if (this.options.extensions?.block?.some((i) => (r = i.call({ lexer: this }, e, t)) ? (e = e.substring(r.raw.length), t.push(r), true) : false))
+        continue;
+      if (r = this.tokenizer.space(e)) {
+        e = e.substring(r.raw.length);
+        let i = t.at(-1);
+        r.raw.length === 1 && i !== undefined ? i.raw += `
+` : t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.code(e)) {
+        e = e.substring(r.raw.length);
+        let i = t.at(-1);
+        i?.type === "paragraph" || i?.type === "text" ? (i.raw += (i.raw.endsWith(`
+`) ? "" : `
+`) + r.raw, i.text += `
+` + r.text, this.inlineQueue.at(-1).src = i.text) : t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.fences(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.heading(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.hr(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.blockquote(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.list(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.html(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.def(e)) {
+        e = e.substring(r.raw.length);
+        let i = t.at(-1);
+        i?.type === "paragraph" || i?.type === "text" ? (i.raw += (i.raw.endsWith(`
+`) ? "" : `
+`) + r.raw, i.text += `
+` + r.raw, this.inlineQueue.at(-1).src = i.text) : this.tokens.links[r.tag] || (this.tokens.links[r.tag] = { href: r.href, title: r.title }, t.push(r));
+        continue;
+      }
+      if (r = this.tokenizer.table(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      if (r = this.tokenizer.lheading(e)) {
+        e = e.substring(r.raw.length), t.push(r);
+        continue;
+      }
+      let o = e;
+      if (this.options.extensions?.startBlock) {
+        let i = 1 / 0, u = e.slice(1), a;
+        this.options.extensions.startBlock.forEach((p) => {
+          a = p.call({ lexer: this }, u), typeof a == "number" && a >= 0 && (i = Math.min(i, a));
+        }), i < 1 / 0 && i >= 0 && (o = e.substring(0, i + 1));
+      }
+      if (this.state.top && (r = this.tokenizer.paragraph(o))) {
+        let i = t.at(-1);
+        n && i?.type === "paragraph" ? (i.raw += (i.raw.endsWith(`
+`) ? "" : `
+`) + r.raw, i.text += `
+` + r.text, this.inlineQueue.pop(), this.inlineQueue.at(-1).src = i.text) : t.push(r), n = o.length !== e.length, e = e.substring(r.raw.length);
+        continue;
+      }
+      if (r = this.tokenizer.text(e)) {
+        e = e.substring(r.raw.length);
+        let i = t.at(-1);
+        i?.type === "text" ? (i.raw += (i.raw.endsWith(`
+`) ? "" : `
+`) + r.raw, i.text += `
+` + r.text, this.inlineQueue.pop(), this.inlineQueue.at(-1).src = i.text) : t.push(r);
+        continue;
+      }
+      if (e) {
+        this.infiniteLoopError(e.charCodeAt(0));
+        break;
+      }
+    }
+    return this.state.top = true, t;
+  }
+  inline(e, t = []) {
+    return this.inlineQueue.push({ src: e, tokens: t }), t;
+  }
+  linkInText(e) {
+    if (!e.includes("["))
+      return false;
+    let t = this.tokenizer.rules.inline.link;
+    for (let n of e.matchAll(this.tokenizer.rules.inline.blockSkip))
+      if (t.test(n[0]) && e.charAt(n.index - 1) !== "!")
+        return true;
+    for (let n of e.matchAll(this.tokenizer.rules.inline.reflinkSearch)) {
+      let s = n[0], r = s.lastIndexOf("[");
+      if (!(s.charAt(0) === "!" || !Object.hasOwn(this.tokens.links, q(s.slice(r + 1, -1)))) && !(r > 1 && this.linkInText(s.slice(1, r - 1))))
+        return true;
+    }
+    return false;
+  }
+  inlineTokens(e, t = []) {
+    this.tokenizer.lexer = this;
+    let n = this.state.linkParenPossible;
+    this.state.linkParenPossible = n && e.includes(")");
+    try {
+      return this.#e(e, t);
+    } finally {
+      this.state.linkParenPossible = n;
+    }
+  }
+  #e(e, t) {
+    let n = e;
+    if (this.tokens.links && e.includes("[")) {
+      let i = this.tokenizer.rules.inline.reflinkSearch, u = (a) => {
+        let p = a.lastIndexOf("[");
+        if (!Object.hasOwn(this.tokens.links, q(a.slice(p + 1, -1))))
+          return a;
+        if (p > 1 && a.charAt(0) !== "!") {
+          let c = a.slice(1, p - 1);
+          if (this.linkInText(c))
+            return "[" + c.replace(i, u) + "][" + "a".repeat(a.length - p - 2) + "]";
+        }
+        return "[" + "a".repeat(a.length - 2) + "]";
+      };
+      n = n.replace(i, u);
+    }
+    n = n.replace(this.tokenizer.rules.inline.anyPunctuation, (i) => "+".repeat(i.length)), n = n.replace(this.tokenizer.rules.inline.blockSkip, (i, u, a) => {
+      let p = a ? a.length : 0;
+      return i.slice(0, p) + "[" + "a".repeat(i.length - p - 2) + "]";
+    }), n = this.options.hooks?.emStrongMask?.call({ lexer: this }, n) ?? n;
+    let s = false, r = "", o = 1 / 0;
+    for (;e; ) {
+      if (e.length < o)
+        o = e.length;
+      else {
+        this.infiniteLoopError(e.charCodeAt(0));
+        break;
+      }
+      s || (r = ""), s = false;
+      let i;
+      if (this.options.extensions?.inline?.some((a) => (i = a.call({ lexer: this }, e, t)) ? (e = e.substring(i.raw.length), t.push(i), true) : false))
+        continue;
+      if (i = this.tokenizer.escape(e)) {
+        e = e.substring(i.raw.length), t.push(i);
+        continue;
+      }
+      if (i = this.tokenizer.tag(e)) {
+        e = e.substring(i.raw.length), t.push(i);
+        continue;
+      }
+      if (i = this.tokenizer.link(e)) {
+        e = e.substring(i.raw.length), t.push(i);
+        continue;
+      }
+      if (i = this.tokenizer.reflink(e, this.tokens.links)) {
+        e = e.substring(i.raw.length);
+        let a = t.at(-1);
+        i.type === "text" && a?.type === "text" ? (a.raw += i.raw, a.text += i.text) : t.push(i);
+        continue;
+      }
+      if (i = this.tokenizer.emStrong(e, n, r)) {
+        e = e.substring(i.raw.length), t.push(i);
+        continue;
+      }
+      if (i = this.tokenizer.codespan(e)) {
+        e = e.substring(i.raw.length), t.push(i);
+        continue;
+      }
+      if (i = this.tokenizer.br(e)) {
+        e = e.substring(i.raw.length), t.push(i);
+        continue;
+      }
+      if (i = this.tokenizer.del(e, n, r)) {
+        e = e.substring(i.raw.length), t.push(i);
+        continue;
+      }
+      if (i = this.tokenizer.autolink(e)) {
+        e = e.substring(i.raw.length), t.push(i);
+        continue;
+      }
+      if (!this.state.inLink && (i = this.tokenizer.url(e))) {
+        e = e.substring(i.raw.length), t.push(i);
+        continue;
+      }
+      let u = e;
+      if (this.options.extensions?.startInline) {
+        let a = 1 / 0, p = e.slice(1), c;
+        this.options.extensions.startInline.forEach((d) => {
+          c = d.call({ lexer: this }, p), typeof c == "number" && c >= 0 && (a = Math.min(a, c));
+        }), a < 1 / 0 && a >= 0 && (u = e.substring(0, a + 1));
+      }
+      if (i = this.tokenizer.inlineText(u)) {
+        e = e.substring(i.raw.length), i.raw.slice(-1) !== "_" && (r = i.raw.slice(-1)), s = true;
+        let a = t.at(-1);
+        a?.type === "text" ? (a.raw += i.raw, a.text += i.text) : t.push(i);
+        continue;
+      }
+      if (e) {
+        this.infiniteLoopError(e.charCodeAt(0));
+        break;
+      }
+    }
+    return t;
+  }
+  infiniteLoopError(e) {
+    let t = "Infinite loop on byte: " + e;
+    if (this.options.silent)
+      console.error(t);
+    else
+      throw new Error(t);
+  }
+}, S = class {
+  options;
+  parser;
+  constructor(e) {
+    this.options = e || P;
+  }
+  space(e) {
+    return "";
+  }
+  code({ text: e, lang: t, escaped: n }) {
+    let s = (t || "").match(x.notSpaceStart)?.[0], r = e ? e.replace(x.endingNewline, "") + `
+` : "";
+    return s ? '<pre><code class="language-' + O(s) + '">' + (n ? r : O(r, true)) + `</code></pre>
+` : "<pre><code>" + (n ? r : O(r, true)) + `</code></pre>
+`;
+  }
+  blockquote({ tokens: e }) {
+    return `<blockquote>
+${this.parser.parse(e)}</blockquote>
+`;
+  }
+  html({ text: e }) {
+    return e;
+  }
+  def(e) {
+    return "";
+  }
+  heading({ tokens: e, depth: t }) {
+    return `<h${t}>${this.parser.parseInline(e)}</h${t}>
+`;
+  }
+  hr(e) {
+    return `<hr>
+`;
+  }
+  list(e) {
+    let { ordered: t, start: n } = e, s = "";
+    for (let i = 0;i < e.items.length; i++) {
+      let u = e.items[i];
+      s += this.listitem(u);
+    }
+    let r = t ? "ol" : "ul", o = t && n !== 1 ? ' start="' + n + '"' : "";
+    return "<" + r + o + `>
+` + s + "</" + r + `>
+`;
+  }
+  listitem(e) {
+    return `<li>${this.parser.parse(e.tokens)}</li>
+`;
+  }
+  checkbox({ checked: e }) {
+    return "<input " + (e ? 'checked="" ' : "") + 'disabled="" type="checkbox"> ';
+  }
+  paragraph({ tokens: e }) {
+    return `<p>${this.parser.parseInline(e)}</p>
+`;
+  }
+  table(e) {
+    let t = "", n = "";
+    for (let r = 0;r < e.header.length; r++)
+      n += this.tablecell(e.header[r]);
+    t += this.tablerow({ text: n });
+    let s = "";
+    for (let r = 0;r < e.rows.length; r++) {
+      let o = e.rows[r];
+      n = "";
+      for (let i = 0;i < o.length; i++)
+        n += this.tablecell(o[i]);
+      s += this.tablerow({ text: n });
+    }
+    return s && (s = `<tbody>${s}</tbody>`), `<table>
+<thead>
+` + t + `</thead>
+` + s + `</table>
+`;
+  }
+  tablerow({ text: e }) {
+    return `<tr>
+${e}</tr>
+`;
+  }
+  tablecell(e) {
+    let t = this.parser.parseInline(e.tokens), n = e.header ? "th" : "td";
+    return (e.align ? `<${n} align="${e.align}">` : `<${n}>`) + t + `</${n}>
+`;
+  }
+  strong({ tokens: e }) {
+    return `<strong>${this.parser.parseInline(e)}</strong>`;
+  }
+  em({ tokens: e }) {
+    return `<em>${this.parser.parseInline(e)}</em>`;
+  }
+  codespan({ text: e }) {
+    return `<code>${O(e, true)}</code>`;
+  }
+  br(e) {
+    return "<br>";
+  }
+  del({ tokens: e }) {
+    return `<del>${this.parser.parseInline(e)}</del>`;
+  }
+  link({ href: e, title: t, text: n, tokens: s, autolink: r }) {
+    let o = r ? O(n, true) : this.parser.parseInline(s), i = re(e);
+    if (i === null)
+      return o;
+    e = O(i, r);
+    let u = '<a href="' + e + '"';
+    return t && (u += ' title="' + O(t) + '"'), u += ">" + o + "</a>", u;
+  }
+  image({ href: e, title: t, text: n, tokens: s }) {
+    s && (n = this.parser.parseInline(s, this.parser.textRenderer));
+    let r = re(e);
+    if (r === null)
+      return O(n);
+    e = r;
+    let o = `<img src="${O(e)}" alt="${O(n)}"`;
+    return t && (o += ` title="${O(t)}"`), o += ">", o;
+  }
+  text(e) {
+    return "tokens" in e && e.tokens ? this.parser.parseInline(e.tokens) : ("escaped" in e) && e.escaped ? e.text : O(e.text);
+  }
+}, z = class {
+  strong({ text: e }) {
+    return e;
+  }
+  em({ text: e }) {
+    return e;
+  }
+  codespan({ text: e }) {
+    return e;
+  }
+  del({ text: e }) {
+    return e;
+  }
+  html({ text: e }) {
+    return e;
+  }
+  text({ text: e }) {
+    return e;
+  }
+  link({ text: e }) {
+    return "" + e;
+  }
+  image({ text: e }) {
+    return "" + e;
+  }
+  br() {
+    return "";
+  }
+  checkbox({ raw: e }) {
+    return e;
+  }
+}, T = class l {
+  options;
+  renderer;
+  textRenderer;
+  constructor(e) {
+    this.options = e || P, this.options.renderer = this.options.renderer || new S, this.renderer = this.options.renderer, this.renderer.options = this.options, this.renderer.parser = this, this.textRenderer = new z;
+  }
+  static parse(e, t) {
+    return new l(t).parse(e);
+  }
+  static parseInline(e, t) {
+    return new l(t).parseInline(e);
+  }
+  parse(e) {
+    this.renderer.parser = this;
+    let t = "";
+    for (let n = 0;n < e.length; n++) {
+      let s = e[n];
+      if (this.options.extensions?.renderers?.[s.type]) {
+        let o = s, i = this.options.extensions.renderers[o.type].call({ parser: this }, o);
+        if (i !== false || !["space", "hr", "heading", "code", "table", "blockquote", "list", "checkbox", "html", "def", "paragraph", "text"].includes(o.type)) {
+          t += i || "";
+          continue;
+        }
+      }
+      let r = s;
+      switch (r.type) {
+        case "space": {
+          t += this.renderer.space(r);
+          break;
+        }
+        case "hr": {
+          t += this.renderer.hr(r);
+          break;
+        }
+        case "heading": {
+          t += this.renderer.heading(r);
+          break;
+        }
+        case "code": {
+          t += this.renderer.code(r);
+          break;
+        }
+        case "table": {
+          t += this.renderer.table(r);
+          break;
+        }
+        case "blockquote": {
+          t += this.renderer.blockquote(r);
+          break;
+        }
+        case "list": {
+          t += this.renderer.list(r);
+          break;
+        }
+        case "checkbox": {
+          t += this.renderer.checkbox(r);
+          break;
+        }
+        case "html": {
+          t += this.renderer.html(r);
+          break;
+        }
+        case "def": {
+          t += this.renderer.def(r);
+          break;
+        }
+        case "paragraph": {
+          t += this.renderer.paragraph(r);
+          break;
+        }
+        case "text": {
+          t += this.renderer.text(r);
+          break;
+        }
+        default: {
+          let o = 'Token with "' + r.type + '" type was not found.';
+          if (this.options.silent)
+            return console.error(o), "";
+          throw new Error(o);
+        }
+      }
+    }
+    return t;
+  }
+  parseInline(e, t = this.renderer) {
+    this.renderer.parser = this;
+    let n = "";
+    for (let s = 0;s < e.length; s++) {
+      let r = e[s];
+      if (this.options.extensions?.renderers?.[r.type]) {
+        let i = this.options.extensions.renderers[r.type].call({ parser: this }, r);
+        if (i !== false || !["escape", "html", "link", "image", "checkbox", "strong", "em", "codespan", "br", "del", "text"].includes(r.type)) {
+          n += i || "";
+          continue;
+        }
+      }
+      let o = r;
+      switch (o.type) {
+        case "escape": {
+          n += t.text(o);
+          break;
+        }
+        case "html": {
+          n += t.html(o);
+          break;
+        }
+        case "link": {
+          n += t.link(o);
+          break;
+        }
+        case "image": {
+          n += t.image(o);
+          break;
+        }
+        case "checkbox": {
+          n += t.checkbox(o);
+          break;
+        }
+        case "strong": {
+          n += t.strong(o);
+          break;
+        }
+        case "em": {
+          n += t.em(o);
+          break;
+        }
+        case "codespan": {
+          n += t.codespan(o);
+          break;
+        }
+        case "br": {
+          n += t.br(o);
+          break;
+        }
+        case "del": {
+          n += t.del(o);
+          break;
+        }
+        case "text": {
+          n += t.text(o);
+          break;
+        }
+        default: {
+          let i = 'Token with "' + o.type + '" type was not found.';
+          if (this.options.silent)
+            return console.error(i), "";
+          throw new Error(i);
+        }
+      }
+    }
+    return n;
+  }
+}, _, F = class {
+  defaults = I();
+  options = this.setOptions;
+  parse = this.parseMarkdown(true);
+  parseInline = this.parseMarkdown(false);
+  Parser = T;
+  Renderer = S;
+  TextRenderer = z;
+  Lexer = R;
+  Tokenizer = y;
+  Hooks = _;
+  constructor(...e) {
+    this.use(...e);
+  }
+  walkTokens(e, t) {
+    let n = [];
+    for (let s of e)
+      switch (n = n.concat(t.call(this, s)), s.type) {
+        case "table": {
+          let r = s;
+          for (let o of r.header)
+            n = n.concat(this.walkTokens(o.tokens, t));
+          for (let o of r.rows)
+            for (let i of o)
+              n = n.concat(this.walkTokens(i.tokens, t));
+          break;
+        }
+        case "list": {
+          let r = s;
+          n = n.concat(this.walkTokens(r.items, t));
+          break;
+        }
+        default: {
+          let r = s;
+          this.defaults.extensions?.childTokens?.[r.type] ? this.defaults.extensions.childTokens[r.type].forEach((o) => {
+            let i = r[o].flat(1 / 0);
+            n = n.concat(this.walkTokens(i, t));
+          }) : r.tokens && (n = n.concat(this.walkTokens(r.tokens, t)));
+        }
+      }
+    return n;
+  }
+  use(...e) {
+    let t = this.defaults.extensions || { renderers: {}, childTokens: {} };
+    return e.forEach((n) => {
+      let s = { ...n };
+      if (s.async = this.defaults.async || s.async || false, n.extensions && (n.extensions.forEach((r) => {
+        if (!r.name)
+          throw new Error("extension name required");
+        if ("renderer" in r) {
+          let o = t.renderers[r.name];
+          o ? t.renderers[r.name] = function(...i) {
+            let u = r.renderer.apply(this, i);
+            return u === false && (u = o.apply(this, i)), u;
+          } : t.renderers[r.name] = r.renderer;
+        }
+        if ("tokenizer" in r) {
+          if (!r.level || r.level !== "block" && r.level !== "inline")
+            throw new Error("extension level must be 'block' or 'inline'");
+          let o = t[r.level];
+          o ? o.unshift(r.tokenizer) : t[r.level] = [r.tokenizer], r.start && (r.level === "block" ? t.startBlock ? t.startBlock.push(r.start) : t.startBlock = [r.start] : r.level === "inline" && (t.startInline ? t.startInline.push(r.start) : t.startInline = [r.start]));
+        }
+        "childTokens" in r && r.childTokens && (t.childTokens[r.name] = r.childTokens);
+      }), s.extensions = t), n.renderer) {
+        let r = this.defaults.renderer || new S(this.defaults);
+        for (let o in n.renderer) {
+          if (!(o in r))
+            throw new Error(`renderer '${o}' does not exist`);
+          if (["options", "parser"].includes(o))
+            continue;
+          let i = o, u = n.renderer[i], a = r[i];
+          r[i] = (...p) => {
+            let c = u.apply(r, p);
+            return c === false && (c = a.apply(r, p)), c || "";
+          };
+        }
+        s.renderer = r;
+      }
+      if (n.tokenizer) {
+        let r = this.defaults.tokenizer || new y(this.defaults);
+        for (let o in n.tokenizer) {
+          if (!(o in r))
+            throw new Error(`tokenizer '${o}' does not exist`);
+          if (["options", "rules", "lexer"].includes(o))
+            continue;
+          let i = o, u = n.tokenizer[i], a = r[i];
+          r[i] = (...p) => {
+            let c = u.apply(r, p);
+            return c === false && (c = a.apply(r, p)), c;
+          };
+        }
+        s.tokenizer = r;
+      }
+      if (n.hooks) {
+        let r = this.defaults.hooks || new _;
+        for (let o in n.hooks) {
+          if (!(o in r))
+            throw new Error(`hook '${o}' does not exist`);
+          if (["options", "block"].includes(o))
+            continue;
+          let i = o, u = n.hooks[i], a = r[i];
+          _.passThroughHooks.has(o) ? r[i] = (p) => {
+            if (this.defaults.async && _.passThroughHooksRespectAsync.has(o))
+              return (async () => {
+                let d = await u.call(r, p);
+                return a.call(r, d);
+              })();
+            let c = u.call(r, p);
+            return a.call(r, c);
+          } : r[i] = (...p) => {
+            if (this.defaults.async)
+              return (async () => {
+                let d = await u.apply(r, p);
+                return d === false && (d = await a.apply(r, p)), d;
+              })();
+            let c = u.apply(r, p);
+            return c === false && (c = a.apply(r, p)), c;
+          };
+        }
+        s.hooks = r;
+      }
+      if (n.walkTokens) {
+        let r = this.defaults.walkTokens, o = n.walkTokens;
+        s.walkTokens = function(i) {
+          let u = [];
+          return u.push(o.call(this, i)), r && (u = u.concat(r.call(this, i))), u;
+        };
+      }
+      this.defaults = { ...this.defaults, ...s };
+    }), this;
+  }
+  setOptions(e) {
+    return this.defaults = { ...this.defaults, ...e }, this;
+  }
+  lexer(e, t) {
+    return R.lex(e, t ?? this.defaults);
+  }
+  parser(e, t) {
+    return T.parse(e, t ?? this.defaults);
+  }
+  parseMarkdown(e) {
+    return (n, s) => {
+      let r = { ...s }, o = { ...this.defaults, ...r }, i = this.onError(!!o.silent, !!o.async);
+      if (this.defaults.async === true && r.async === false)
+        return i(new Error("marked(): The async option was set to true by an extension. Remove async: false from the parse options object to return a Promise."));
+      if (typeof n > "u" || n === null)
+        return i(new Error("marked(): input parameter is undefined or null"));
+      if (typeof n != "string")
+        return i(new Error("marked(): input parameter is of type " + Object.prototype.toString.call(n) + ", string expected"));
+      if (o.hooks && (o.hooks.options = o, o.hooks.block = e), o.async)
+        return (async () => {
+          let u = o.hooks ? await o.hooks.preprocess(n) : n, p = await (o.hooks ? await o.hooks.provideLexer(e) : e ? R.lex : R.lexInline)(u, o), c = o.hooks ? await o.hooks.processAllTokens(p) : p;
+          o.walkTokens && await Promise.all(this.walkTokens(c, o.walkTokens));
+          let m = await (o.hooks ? await o.hooks.provideParser(e) : e ? T.parse : T.parseInline)(c, o);
+          return o.hooks ? await o.hooks.postprocess(m) : m;
+        })().catch(i);
+      try {
+        o.hooks && (n = o.hooks.preprocess(n));
+        let a = (o.hooks ? o.hooks.provideLexer(e) : e ? R.lex : R.lexInline)(n, o);
+        o.hooks && (a = o.hooks.processAllTokens(a)), o.walkTokens && this.walkTokens(a, o.walkTokens);
+        let c = (o.hooks ? o.hooks.provideParser(e) : e ? T.parse : T.parseInline)(a, o);
+        return o.hooks && (c = o.hooks.postprocess(c)), c;
+      } catch (u) {
+        return i(u);
+      }
+    };
+  }
+  onError(e, t) {
+    return (n) => {
+      if (n.message += `
+Please report this to https://github.com/markedjs/marked.`, e) {
+        let s = "<p>An error occurred:</p><pre>" + O(n.message + "", true) + "</pre>";
+        return t ? Promise.resolve(s) : s;
+      }
+      if (t)
+        return Promise.reject(n);
+      throw n;
+    };
+  }
+}, E, gn, fn, mn, xn, Rn, Tn;
+var init_marked_esm = __esm(() => {
+  P = I();
+  A = { exec: () => null };
+  _e = ((l = "") => {
+    try {
+      return !!new RegExp("(?<=1)(?<!1)" + l);
+    } catch {
+      return false;
+    }
+  })();
+  x = { codeRemoveIndent: /^(?: {0,3}\t| {1,4})/gm, outputLinkReplace: /\\([\[\]])/g, indentCodeCompensation: /^(\s+)(?:```)/, beginningSpace: /^\s+/, endingHash: /#$/, startingSpaceChar: /^ /, endingSpaceChar: / $/, endingSpaceTabChar: /[ \t]$/, nonSpaceChar: /[^ ]/, newLineCharGlobal: /\n/g, tabCharGlobal: /\t/g, leadingSpaceTab: /^[ \t]+/, multipleSpaceGlobal: /\s+/g, blankLine: /^[ \t]*$/, doubleBlankLine: /\n[ \t]*\n[ \t]*$/, blockquoteStart: /^ {0,3}>/, blockquoteSetextReplace: /\n {0,3}((?:=+|-+) *)(?=\n|$)/g, blockquoteSetextReplace2: /^ {0,3}>[ \t]?/gm, listReplaceNesting: /^ {1,4}(?=( {4})*[^ ])/g, listIsTask: /^\[[ xX]\] +\S/, listReplaceTask: /^\[[ xX]\] +/, listTaskCheckbox: /\[[ xX]\]/, anyLine: /\n.*\n/, hrefBrackets: /^<(.*)>$/, tableDelimiter: /[:|]/, tableAlignChars: /^\||\| *$/g, tableRowBlankLine: /\n[ \t]*$/, tableAlignRight: /^ *-+: *$/, tableAlignCenter: /^ *:-+: *$/, tableAlignLeft: /^ *:-+ *$/, startATag: /^<a /i, endATag: /^<\/a>/i, startPreScriptTag: /^<(pre|code|kbd|script)(\s|>)/i, endPreScriptTag: /^<\/(pre|code|kbd|script)(\s|>)/i, startAngleBracket: /^</, endAngleBracket: />$/, pedanticHrefTitle: /^([^'"]*[^\s])\s+(['"])(.*)\2/, unicodeAlphaNumeric: /[\p{L}\p{N}]/u, numericCharacterReference: /&#(?:(\d{1,7})|[Xx]([A-Fa-f0-9]{1,6}));/g, escapeTest: /[&<>"']/, escapeReplace: /[&<>"']/g, escapeTestNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/, escapeReplaceNoEncode: /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/g, caret: /(^|[^\[])\^/g, percentDecode: /%25/g, findPipe: /\|/g, splitPipe: / \|/, slashPipe: /\\\|/g, carriageReturn: /\r\n|\r/g, spaceLine: /^ +$/gm, notSpaceStart: /^\S*/, endingNewline: /\n$/, listItemRegex: (l) => new RegExp(`^( {0,3}${l})((?:[	 ][^\\n]*)?(?:\\n|$))`), nextBulletRegex: C((l) => new RegExp(`^ {0,${l}}(?:[*+-]|\\d{1,9}[.)])((?:[ 	][^\\n]*)?(?:\\n|$))`)), hrRegex: C((l) => new RegExp(`^ {0,${l}}((?:-[ 	]*){3,}|(?:_[ 	]*){3,}|(?:\\*[ 	]*){3,})(?:\\n+|$)`)), fencesBeginRegex: C((l) => new RegExp(`^ {0,${l}}(?:\`\`\`|~~~)`)), headingBeginRegex: C((l) => new RegExp(`^ {0,${l}}#`)), htmlBeginRegex: C((l) => new RegExp(`^ {0,${l}}(?:</?(?:${N})(?: +|$|/?>)|<(?:script|pre|style|textarea|!--))`, "i")), blockquoteBeginRegex: C((l) => new RegExp(`^ {0,${l}}>`)) };
+  $e = /^(?:[ \t]*(?:\n|$))+/;
+  Le = /^((?: {4}| {0,3}\t)[^\n]+(?:\n(?:[ \t]*(?:\n|$))*)?)+/;
+  ze = /^ {0,3}(`{3,}(?=[^`\n]*(?:\n|$))|~{3,})([^\n]*)(?:\n|$)(?:|([\s\S]*?)(?:\n|$))(?: {0,3}\1[~`]* *(?=\n|$)|$)/;
+  G = /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/;
+  Ae = /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/;
+  J = / {0,3}(?:[*+-]|\d{1,9}[.)])/;
+  he = /^(?!bull |blockCode|fences|blockquote|heading|html|table)((?:.|\n(?!\s*?\n|bull |fences|blockquote|heading|hr|html|table))+?)\n {0,3}(=+|-+) *(?:\n+|$)/;
+  de = h(he).replace(/bull/g, J).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}(?:\s|$)/).replace(/hr/g, / {0,3}(?:(?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/\|table/g, "").getRegex();
+  Ee = h(he).replace(/bull/g, J).replace(/blockCode/g, /(?: {4}| {0,3}\t)/).replace(/fences/g, / {0,3}(?:`{3,}|~{3,})/).replace(/blockquote/g, / {0,3}>/).replace(/heading/g, / {0,3}#{1,6}(?:\s|$)/).replace(/hr/g, / {0,3}(?:(?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/).replace(/html/g, / {0,3}<[^\n>]+>\n/).replace(/table/g, / {0,3}\|?(?:[:\- ]*\|)+[\:\- ]*\n/).getRegex();
+  V = /^([^\n]+(?:\n(?!hr|heading|lheading|blockquote|fences|list|html|table|[ \t]+\n)[^\n]+)*)/;
+  Me = /^[^\n]+/;
+  Y = /(?!\s*\])(?:\\[\s\S]|[^\[\]\\])+/;
+  Ie = h(/^ {0,3}\[(label)\]: *(?:\n[ \t]*)?([^<\s][^\s]*|<.*?>)(?:(?: +(?:\n[ \t]*)?| *\n[ \t]*)(title))? *(?:\n+|$)/).replace("label", Y).replace("title", /(?:"(?:\\"?|[^"\\])*"|'[^'\n]*(?:\n[^'\n]+)*\n?'|\([^()]*\))/).getRegex();
+  Ce = h(/^(bull)([ \t][^\n]*?)?(?:\n|$)/).replace(/bull/g, J).getRegex();
+  ee = /<!--(?:-?>|[\s\S]*?(?:-->|$))/;
+  Be = h("^ {0,3}(?:<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n*|$)|comment[^\\n]*(\\n+|$)|<\\?[\\s\\S]*?(?:\\?>[^\\n]*\\n*|$)|<![A-Z][\\s\\S]*?(?:>[^\\n]*\\n*|$)|<!\\[CDATA\\[[\\s\\S]*?(?:\\]\\]>[^\\n]*\\n*|$)|</?(tag)(?: +|\\n|/?>)[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$)|<(?!script|pre|style|textarea)([a-z][a-z0-9-]*)(?:attribute)*? */?>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$)|</(?!script|pre|style|textarea)[a-z][a-z0-9-]*\\s*>(?=[ \\t]*(?:\\n|$))[\\s\\S]*?(?:(?:\\n[ \t]*)+\\n|$))", "i").replace("comment", ee).replace("tag", N).replace("attribute", / +[a-zA-Z:_][\w.:-]*(?: *= *"[^"\n]*"| *= *'[^'\n]*'| *= *[^\s"'=<>`]+)?/).getRegex();
+  De = ke(/ {0,3}(?:[*+-]|1[.)])[ \t]+[^ \t\n]/);
+  qe = ke(/ {0,3}(?:[*+-]|\d{1,9}[.)])(?:[ \t]|\n|$)/);
+  ve = h(/^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/).replace("paragraph", qe).getRegex();
+  te = { blockquote: ve, code: Le, def: Ie, fences: ze, heading: Ae, hr: G, html: Be, lheading: de, list: Ce, newline: $e, paragraph: De, table: A, text: Me };
+  ue = h("^ *([^\\n ].*)\\n {0,3}((?:\\| *)?:?-+:? *(?:\\| *:?-+:? *)*(?:\\| *)?)(?:\\n((?:(?! *\\n|hr|heading|blockquote|code|fences|list|html).*(?:\\n|$))*)\\n*|$)").replace("hr", G).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("blockquote", " {0,3}>").replace("code", "(?: {4}| {0,3}\t)[^\\n]").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*(?:\\n|$))|~~~)[^\\n]*(?:\\n|$)").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", N).getRegex();
+  Ze = { ...te, lheading: Ee, table: ue, paragraph: h(V).replace("hr", G).replace("heading", " {0,3}#{1,6}(?:\\s|$)").replace("|lheading", "").replace("table", ue).replace("blockquote", " {0,3}>").replace("fences", " {0,3}(?:`{3,}(?=[^`\\n]*(?:\\n|$))|~~~)[^\\n]*(?:\\n|$)").replace("list", " {0,3}(?:[*+-]|1[.)])[ \\t]+[^ \\t\\n]").replace("html", "</?(?:tag)(?: +|\\n|/?>)|<(?:script|pre|style|textarea|!--)").replace("tag", N).getRegex() };
+  He = { ...te, html: h(`^ *(?:comment *(?:\\n|\\s*$)|<(tag)[\\s\\S]+?</\\1> *(?:\\n{2,}|\\s*$)|<tag(?:"[^"]*"|'[^']*'|\\s[^'"/>\\s]*)*?/?> *(?:\\n{2,}|\\s*$))`).replace("comment", ee).replace(/tag/g, "(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:|[^\\w\\s@]*@)\\b").getRegex(), def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +(["(][^\n]+[")]))? *(?:\n+|$)/, heading: /^(#{1,6})(.*)(?:\n+|$)/, fences: A, lheading: /^(.+?)\n {0,3}(=+|-+) *(?:\n+|$)/, paragraph: h(V).replace("hr", G).replace("heading", ` *#{1,6} *[^
+]`).replace("lheading", de).replace("|table", "").replace("blockquote", " {0,3}>").replace("|fences", "").replace("|list", "").replace("|html", "").replace("|tag", "").getRegex() };
+  Ge = /^\\([!"#$%&'()*+,\-./:;<=>?@\[\]\\^_`{|}~])/;
+  Ne = /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/;
+  ge = /^( {2,}|\\)\n(?!\s*$)[ \t]*/;
+  Qe = /^(`+|[^`])(?:(?= {2,}\n)|[\s\S]*?(?:(?=[\\<!\[`*_]|\b_|$)|[^ ](?= {2,}\n)))/;
+  $ = /[\p{P}\p{S}]/u;
+  B = /[\s\p{P}\p{S}]/u;
+  Q = /[^\s\p{P}\p{S}]/u;
+  je = h(/^((?![*_])punctSpace)/, "u").replace(/punctSpace/g, B).getRegex();
+  Fe = /[\p{Pi}\p{Ps}"']/u;
+  fe = /(?!~)[\p{P}\p{S}]/u;
+  Ue = /(?!~)[\s\p{P}\p{S}]/u;
+  Ke = /(?:[^\s\p{P}\p{S}]|~)/u;
+  We = h(/link|precode-code|html/, "g").replace("link", /\[(?:[^\[\]`]|(?<a>`+)[^`]+\k<a>(?!`))*?\]\((?:\\[\s\S]|[^\\\(\)]|\((?:\\[\s\S]|[^\\\(\)])*\))*\)/).replace("precode-", _e ? "(?<!`)()" : "(^^|[^`])").replace("code", /(?<b>`+)[^`]+\k<b>(?!`)/).replace("html", /<(?! )[^<>]*?>/).getRegex();
+  me = /^(?:\*+(?:((?!\*)punct)|([^\s*]))?)|^_+(?:((?!_)punct)|([^\s_]))?/;
+  Xe = h(me, "u").replace(/punct/g, $).getRegex();
+  Je = h(me, "u").replace(/punct/g, fe).getRegex();
+  Ve = /^(?:\*+(?:((?!\*)(?!openQuote)punct)|([^\s*]))?)|^_+(?:((?!_)(?!openQuote)punct)|([^\s_]))?/;
+  Ye = h(Ve, "u").replace(/openQuote/g, Fe).replace(/punct/g, $).getRegex();
+  et = h(xe, "gu").replace(/notPunctSpace/g, Q).replace(/punctSpace/g, B).replace(/punct/g, $).getRegex();
+  tt = h(xe, "gu").replace(/notPunctSpace/g, Ke).replace(/punctSpace/g, Ue).replace(/punct/g, fe).getRegex();
+  rt = h(nt, "gu").replace(/notPunctSpace/g, Q).replace(/punctSpace/g, B).replace(/punct/g, $).getRegex();
+  st = h("^[^_*]*?\\*\\*[^_*]*?_[^_*]*?(?=\\*\\*)|[^_]+(?=[^_])|(?!_)punct(_+)(?=[\\s]|$)|notPunctSpace(_+)(?!_)(?=punctSpace|$)|(?!_)punctSpace(_+)(?=notPunctSpace)|[\\s](_+)(?!_)(?=punct)|(?!_)punct(_+)(?!_)(?=punct)", "gu").replace(/notPunctSpace/g, Q).replace(/punctSpace/g, B).replace(/punct/g, $).getRegex();
+  ot = h(it, "gu").replace(/notPunctSpace/g, Q).replace(/punctSpace/g, B).replace(/punct/g, $).getRegex();
+  at = h(/^~~?(?:((?!~)punct)|[^\s~])/, "u").replace(/punct/g, $).getRegex();
+  ut = h(lt, "gu").replace(/notPunctSpace/g, Q).replace(/punctSpace/g, B).replace(/punct/g, $).getRegex();
+  pt = h(/\\(punct)/, "gu").replace(/punct/g, $).getRegex();
+  ct = h(/^<(scheme:[^\s\x00-\x1f<>]*|email)>/).replace("scheme", /[a-zA-Z][a-zA-Z0-9+.-]{1,31}/).replace("email", /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+(@)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+(?![-_])/).getRegex();
+  ht = h(ee).replace("(?:-->|$)", "-->").getRegex();
+  dt = h("^comment|^</[a-zA-Z][a-zA-Z0-9-]*\\s*>|^<[a-zA-Z][a-zA-Z0-9-]*(?:attribute)*?\\s*/?>|^<\\?[\\s\\S]*?\\?>|^<![a-zA-Z]+\\s[\\s\\S]*?>|^<!\\[CDATA\\[[\\s\\S]*?\\]\\]>").replace("comment", ht).replace("attribute", /\s+[a-zA-Z:_][\w.:-]*(?:\s*=\s*"[^"]*"|\s*=\s*'[^']*'|\s*=\s*[^\s"'=<>`]+)?/).getRegex();
+  be = /\[(?:\\[\s\S]|[^\[\]\\])*\]/;
+  U = h(/(?:\[(?:brackets|\\[\s\S]|[^\[\]\\])*\]|\\[\s\S]|`+(?!`)[^`]*?`+(?!`)|``+(?=\])|[^\[\]\\`])*?/).replace("brackets", be).getRegex();
+  kt = h(/^!?\[(label)\]\([ \t\n]*(href)(?:(?:[ \t]+(?:\n[ \t]*)?|\n[ \t]*)(title))?[ \t\n]*\)/).replace("label", U).replace("href", /<(?:\\.|[^\n<>\\])+>|[^ \t\n\x00-\x1f]+|(?=\))/).replace("title", /"(?:\\"?|[^"\\])*"|'(?:\\'?|[^'\\])*'|\((?:\\\)?|[^)\\])*\)/).getRegex();
+  gt = h(/^!?\[(label)\]\[(ref)\]/).replace("label", U).replace("ref", Y).getRegex();
+  ft = h(/^!?\[(ref)\](?:\[\])?/).replace("ref", Y).getRegex();
+  pe = /(?!\s*\])(?:\\[\s\S]|[^\[\]\\]){1,999}/;
+  mt = h(/(?:[^\[\]\\`]*(?:\[(?:brackets|\\[\s\S]|[^\[\]\\])*\]|\\[\s\S]|`+(?!`)[^`]*?`+(?!`)|``+(?=\]))){0,999}?[^\[\]\\`]*?/).replace("brackets", be).getRegex();
+  xt = h("reflink|nolink(?!\\()", "g").replace("reflink", h(/^!?\[(label)\]\[(ref)\]/).replace("label", mt).replace("ref", pe).getRegex()).replace("nolink", h(/^!?\[(ref)\](?:\[\])?/).replace("ref", pe).getRegex()).getRegex();
+  ce = /[hH][tT][tT][pP][sS]?|[fF][tT][pP]/;
+  bt = /[A-Za-z0-9._+-]+@[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![\w-])/;
+  Rt = h(/(?:mailto:email|xmpp:email(?:\/[A-Za-z0-9@.]+)?)/).replace(/email/g, bt).getRegex();
+  ne = { _backpedal: A, anyPunctuation: pt, autolink: ct, blockSkip: We, br: ge, code: Ne, del: A, delLDelim: A, delRDelim: A, emStrongLDelim: Xe, emStrongRDelimAst: et, emStrongRDelimUnd: st, escape: Ge, link: kt, nolink: ft, punctuation: je, reflink: gt, reflinkSearch: xt, tag: dt, text: Qe, url: A };
+  Tt = { ...ne, emStrongLDelim: Ye, emStrongRDelimAst: rt, emStrongRDelimUnd: ot, link: h(/^!?\[(label)\]\((.*?)\)/).replace("label", U).getRegex(), reflink: h(/^!?\[(label)\]\s*\[([^\]]*)\]/).replace("label", U).getRegex() };
+  X = { ...ne, emStrongRDelimAst: tt, emStrongLDelim: Je, delLDelim: at, delRDelim: ut, url: h(/^emailProtocol|^((?:protocol):\/\/|www\.)(?:[a-zA-Z0-9\-]+\.?)+[^\s<]*|^email/).replace("emailProtocol", Rt).replace("protocol", ce).replace("email", /[A-Za-z0-9._+-]+(@)[a-zA-Z0-9-_]+(?:\.[a-zA-Z0-9-_]*[a-zA-Z0-9])+(?![\w-])/).getRegex(), _backpedal: /(?:[^?!.,:;*_'"~()&]+|\([^)]*\)|&(?![a-zA-Z0-9]+;$)|[?!.,:;*_'"~)]+(?!$))+/, del: /^(~~?)(?=[^\s~])((?:\\[\s\S]|[^\\])*?(?:\\[\s\S]|[^\s~\\]))\1(?=[^~]|$)/, text: h(/^(?:[^a-zA-Z0-9](?=emailProtocol)|(`+|~+|[^`~])(?:(?=[`~])|(?= {2,}\n)|(?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@)|[\s\S]*?(?:(?=[\\<!\[`*~_]|\b_|protocol:\/\/|www\.|$)|[^ ](?= {2,}\n)|[^a-zA-Z0-9](?=emailProtocol)|[^a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-](?=[a-zA-Z0-9.!#$%&'*+\/=?_`{\|}~-]+@))))/).replace("protocol", ce).replace(/emailProtocol/g, /(?:mailto|xmpp):/).getRegex() };
+  Ot = { ...X, br: h(ge).replace("{2,}", "*").getRegex(), text: h(X.text).replace("\\b_", "\\b_| {2,}\\n").replace(/\{2,\}/g, "*").getRegex() };
+  j = { normal: te, gfm: Ze, pedantic: He };
+  D = { normal: ne, gfm: X, breaks: Ot, pedantic: Tt };
+  wt = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
+  _ = class {
+    options;
+    block;
+    constructor(e) {
+      this.options = e || P;
+    }
+    static passThroughHooks = new Set(["preprocess", "postprocess", "processAllTokens", "emStrongMask"]);
+    static passThroughHooksRespectAsync = new Set(["preprocess", "postprocess", "processAllTokens"]);
+    preprocess(e) {
+      return e;
+    }
+    postprocess(e) {
+      return e;
+    }
+    processAllTokens(e) {
+      return e;
+    }
+    emStrongMask(e) {
+      return e;
+    }
+    provideLexer(e = this.block) {
+      return e ? R.lex : R.lexInline;
+    }
+    provideParser(e = this.block) {
+      return e ? T.parse : T.parseInline;
+    }
+  };
+  E = new F;
+  k.options = k.setOptions = function(l) {
+    return E.setOptions(l), k.defaults = E.defaults, W(k.defaults), k;
+  };
+  k.getDefaults = I;
+  k.defaults = P;
+  k.use = yt;
+  k.walkTokens = function(l, e) {
+    return E.walkTokens(l, e);
+  };
+  k.parseInline = E.parseInline;
+  k.Parser = T;
+  k.parser = T.parse;
+  k.Renderer = S;
+  k.TextRenderer = z;
+  k.Lexer = R;
+  k.lexer = R.lex;
+  k.Tokenizer = y;
+  k.Hooks = _;
+  k.parse = k;
+  gn = k.options;
+  fn = k.setOptions;
+  mn = k.walkTokens;
+  xn = k.parseInline;
+  Rn = T.parse;
+  Tn = R.lex;
+});
+
+// packages/core/src/conversation-export-html.ts
+async function embedImages(items, loadImage) {
+  const embedded = new Map;
+  let used = 0;
+  let skipped = 0;
+  for (const item of items) {
+    if (item.type !== "user" && item.type !== "tool")
+      continue;
+    for (const image of item.images ?? []) {
+      let reason = null;
+      if (loadImage === undefined)
+        reason = "not embedded";
+      else if (used + image.bytes > MAX_EMBEDDED_IMAGE_BYTES)
+        reason = "over the embedding size limit";
+      else {
+        try {
+          const file = await loadImage(image);
+          if (!SAFE_IMAGE_TYPE.test(file.mimeType))
+            reason = "unsupported image type";
+          else if (used + file.bytes.length > MAX_EMBEDDED_IMAGE_BYTES)
+            reason = "over the embedding size limit";
+          else {
+            used += file.bytes.length;
+            const parts = [];
+            for (let at = 0;at < file.bytes.length; at += BASE64_SLICE_BYTES)
+              parts.push(encodeChunk(file.bytes.subarray(at, at + BASE64_SLICE_BYTES)));
+            embedded.set(`${image.entryId}:${image.contentIndex}`, {
+              src: `data:${file.mimeType.toLowerCase()};base64,${parts.join("")}`
+            });
+          }
+        } catch {
+          reason = "image unavailable";
+        }
+      }
+      if (reason !== null) {
+        embedded.set(`${image.entryId}:${image.contentIndex}`, { reason });
+        skipped++;
+      }
+    }
+  }
+  return { embedded, skipped };
+}
+function renderImages(images, embedded) {
+  return (images ?? []).map((image) => {
+    const found = embedded.get(`${image.entryId}:${image.contentIndex}`);
+    const label = escapeHtml(imageLabel(image));
+    if (found !== undefined && "src" in found)
+      return `<figure><img src="${found.src}" alt="${escapeHtml(image.name)}"><figcaption>${label}</figcaption></figure>`;
+    const reason = found !== undefined && "reason" in found ? ` \u2014 ${found.reason}` : "";
+    return `<p class="placeholder">[image: ${label}${reason}]</p>`;
+  }).join("");
+}
+async function exportHtml(source, options) {
+  const { embedded, skipped } = await embedImages(source.items, options.loadImage);
+  const title = escapeHtml(oneLine(source.title) || FALLBACK_EXPORT_TITLE);
+  const body = [];
+  for (const item of source.items) {
+    if (item.type === "system") {
+      body.push(`<div class="system">${escapeHtml(oneLine(item.text))}</div>`);
+    } else if (item.type === "user") {
+      const text = userText2(item);
+      body.push(`<section class="msg user"><div class="role">User</div>${text === "" ? "" : `<div class="text">${escapeHtml(text)}</div>`}${renderImages(item.images, embedded)}</section>`);
+    } else if (item.type === "assistant") {
+      const thinking = options.includeThinking && item.thinking.trim() !== "" ? `<details class="thinking"><summary>Thinking</summary><div class="text">${escapeHtml(item.thinking.trim())}</div></details>` : "";
+      const text = item.text.trim() === "" ? "" : `<div class="md">${markdown2.parse(item.text.trim(), { async: false })}</div>`;
+      const note = item.note === null ? "" : `<div class="note">${escapeHtml(oneLine(item.note))}</div>`;
+      body.push(`<section class="msg assistant"><div class="role">Assistant</div>${thinking}${text}${note}</section>`);
+    } else {
+      const status = toolStatus(item);
+      const output = toolOutput(item);
+      const heading = [
+        `<b>Tool</b> ${escapeHtml(item.name)}`,
+        item.summary === "" ? "" : `<span class="args">${escapeHtml(oneLine(item.summary))}</span>`,
+        status === "ok" ? "" : `<span class="status">[${status}]</span>`,
+        item.durationMs === null ? "" : `<span class="duration">(${formatDuration(item.durationMs)})</span>`
+      ].filter(Boolean).join(" ");
+      body.push(`<details class="tool ${status}"><summary>${heading}</summary>${item.detail === null || item.detail === "" ? "" : `<pre>${escapeHtml(item.detail)}</pre>`}${output === "" ? "" : `<div class="label">${status === "running" ? "Output so far" : "Result"}</div><pre>${escapeHtml(output)}</pre>`}${item.note === null ? "" : `<div class="note">${escapeHtml(oneLine(item.note))}</div>`}${renderImages(item.images, embedded)}</details>`);
+    }
+  }
+  const content = `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta http-equiv="Content-Security-Policy" content="${CSP}">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${title}</title>
+<style>${STYLE}</style>
+</head>
+<body>
+<main>
+<h1>${title}</h1>
+<p class="meta">${escapeHtml(oneLine(source.model))} \xB7 ${escapeHtml(oneLine(source.cwd))} \xB7 ${escapeHtml(source.exportedAt.toISOString())}</p>
+${body.join(`
+`)}
+</main>
+</body>
+</html>
+`;
+  return { content, skippedImages: skipped };
+}
+var MAX_EMBEDDED_IMAGE_BYTES, SAFE_IMAGE_TYPE, SAFE_LINK, BASE64_SLICE_BYTES, CSP = "default-src 'none'; img-src data:; style-src 'unsafe-inline'", STYLE = `
+:root{color-scheme:light dark;--bg:#fff;--fg:#1f2328;--muted:#656d76;--border:#d0d7de;--user:#eef4ff;--code:#f6f8fa}
+@media(prefers-color-scheme:dark){:root{--bg:#0d1117;--fg:#e6edf3;--muted:#8b949e;--border:#30363d;--user:#16243a;--code:#161b22}}
+body{margin:0;background:var(--bg);color:var(--fg);font:15px/1.6 system-ui,-apple-system,"Segoe UI",sans-serif}
+main{max-width:860px;margin:0 auto;padding:24px 16px 64px}
+h1{font-size:1.5rem;margin:0 0 4px}
+.meta{color:var(--muted);font-size:.85rem;margin:0 0 24px}
+.msg{margin:16px 0;padding:12px 16px;border:1px solid var(--border);border-radius:12px}
+.msg.user{background:var(--user)}
+.role{font-size:.75rem;font-weight:600;letter-spacing:.04em;text-transform:uppercase;color:var(--muted);margin-bottom:6px}
+.text{white-space:pre-wrap;overflow-wrap:anywhere}
+.system{text-align:center;color:var(--muted);font-size:.85rem;margin:16px 0}
+.md>:first-child{margin-top:0}.md>:last-child{margin-bottom:0}
+.md pre,pre{background:var(--code);border-radius:8px;padding:10px 12px;overflow:auto;font-size:.85rem;white-space:pre-wrap;overflow-wrap:anywhere}
+.md code{background:var(--code);border-radius:4px;padding:1px 4px}.md pre code{background:none;padding:0}
+.md table{border-collapse:collapse}.md th,.md td{border:1px solid var(--border);padding:4px 8px}
+.md blockquote{margin:0;padding-left:12px;border-left:3px solid var(--border);color:var(--muted)}
+details{margin:8px 0}summary{cursor:pointer;color:var(--muted)}
+details.tool{border:1px solid var(--border);border-radius:8px;padding:6px 12px;margin:12px 0}
+details.tool.error>summary .status{color:#cf222e}
+.label{font-size:.75rem;color:var(--muted);margin-top:8px}
+.note{color:var(--muted);font-style:italic;margin-top:6px}
+figure{margin:8px 0}img{max-width:100%;height:auto;border-radius:8px}figcaption,.placeholder{color:var(--muted);font-size:.8rem}
+`, escapeHtml = (text) => text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;"), markdown2;
+var init_conversation_export_html = __esm(() => {
+  init_marked_esm();
+  MAX_EMBEDDED_IMAGE_BYTES = 32 * 1024 * 1024;
+  SAFE_IMAGE_TYPE = /^image\/(png|jpeg|webp|gif)$/i;
+  SAFE_LINK = /^(https?:|mailto:)/i;
+  BASE64_SLICE_BYTES = 3 * 16 * 1024;
+  markdown2 = new F({
+    gfm: true,
+    breaks: true,
+    renderer: {
+      html: ({ text }) => escapeHtml(text),
+      link({ href, title, tokens }) {
+        const label = this.parser.parseInline(tokens);
+        if (!SAFE_LINK.test(href.trim()))
+          return label;
+        const titleAttr = title ? ` title="${escapeHtml(title)}"` : "";
+        return `<a href="${escapeHtml(href)}"${titleAttr} rel="noopener noreferrer" target="_blank">${label}</a>`;
+      },
+      image({ href, text }) {
+        const label = `[image: ${escapeHtml(text || href)}]`;
+        return SAFE_LINK.test(href.trim()) ? `<a href="${escapeHtml(href)}" rel="noopener noreferrer" target="_blank">${label}</a>` : label;
+      }
+    }
+  });
+});
+
+// packages/core/src/conversation-export.ts
+function copyText(item) {
+  if (item.type === "user")
+    return userText2(item);
+  if (item.type === "assistant")
+    return item.text.trim();
+  return "";
+}
+function lastAnswerText(items) {
+  for (let i = items.length - 1;i >= 0; i--) {
+    const item = items[i];
+    if (item.type !== "assistant")
+      continue;
+    const text = copyText(item);
+    if (text !== "")
+      return text;
+  }
+  return null;
+}
+function exportFormatFromPath(path) {
+  const extension = /\.(md|html|json)$/i.exec(path)?.[1]?.toLowerCase();
+  return extension === "md" ? "markdown" : extension === "html" ? "html" : extension === "json" ? "json" : null;
+}
+function exportFileName(title, format, at) {
+  const cleaned = title.replace(/[\\/:*?"<>|\u0000-\u001f\u007f]/g, "-").replace(/\s+/g, " ").replace(/-{2,}/g, "-");
+  const safe = Array.from(cleaned).slice(0, MAX_FILE_TITLE_CHARS).join("").replace(/^[\s.-]+|[\s.-]+$/g, "") || FALLBACK_EXPORT_TITLE;
+  const pad = (value, width = 2) => String(value).padStart(width, "0");
+  const stamp = `${pad(at.getFullYear(), 4)}${pad(at.getMonth() + 1)}${pad(at.getDate())}-${pad(at.getHours())}${pad(at.getMinutes())}${pad(at.getSeconds())}`;
+  return `${safe}-${stamp}.${EXPORT_EXTENSIONS[format]}`;
+}
+async function exportConversation(format, source, options) {
+  if (source.items.length === 0)
+    throw new Error("Nothing to export yet - start a conversation first");
+  const extension = EXPORT_EXTENSIONS[format];
+  const mimeType = MIME_TYPES[format];
+  if (format === "html") {
+    const { content, skippedImages } = await exportHtml(source, options);
+    return { content, mimeType, extension, skippedImages };
+  }
+  const content = format === "markdown" ? exportMarkdown(source, options) : exportJson(source, options);
+  return { content, mimeType, extension, skippedImages: 0 };
+}
+function block(content) {
+  let longest = 0;
+  for (const run of content.matchAll(/`+/g))
+    longest = Math.max(longest, run[0].length);
+  const marks = "`".repeat(Math.max(3, longest + 1));
+  return `${marks}
+${content}
+${marks}`;
+}
+function exportMarkdown(source, options) {
+  const out = [
+    `# ${oneLine(source.title) || FALLBACK_EXPORT_TITLE}`,
+    "",
+    `- **Model:** ${oneLine(source.model)}`,
+    `- **Workspace:** ${oneLine(source.cwd)}`,
+    `- **Exported:** ${source.exportedAt.toISOString()}`,
+    ""
+  ];
+  let role = null;
+  const heading = (next) => {
+    if (role === next)
+      return;
+    role = next;
+    out.push("---", "", next === "user" ? "## User" : "## Assistant", "");
+  };
+  for (const item of source.items) {
+    if (item.type === "system") {
+      role = null;
+      out.push("---", "", `*${escapeInline(oneLine(item.text))}*`, "");
+    } else if (item.type === "user") {
+      heading("user");
+      const text = userText2(item);
+      if (text !== "")
+        out.push(text, "");
+      for (const image of item.images ?? [])
+        out.push(`> [image] ${escapeInline(imageLabel(image))}`, "");
+    } else if (item.type === "assistant") {
+      heading("assistant");
+      if (options.includeThinking && item.thinking.trim() !== "")
+        out.push("<details>", "<summary>Thinking</summary>", "", item.thinking.trim(), "", "</details>", "");
+      if (item.text.trim() !== "")
+        out.push(item.text.trim(), "");
+      if (item.note !== null)
+        out.push(`> ${escapeInline(oneLine(item.note))}`, "");
+    } else {
+      heading("assistant");
+      out.push(...markdownTool(item));
+    }
+  }
+  return `${out.join(`
+`).trimEnd()}
+`;
+}
+function markdownTool(item) {
+  const status = toolStatus(item);
+  const label = [
+    `Tool: ${item.name}`,
+    item.summary === "" ? "" : `\xB7 ${oneLine(item.summary)}`,
+    status === "ok" ? "" : `[${status}]`,
+    item.durationMs === null ? "" : `(${formatDuration(item.durationMs)})`
+  ].filter(Boolean).join(" ");
+  const lines = ["<details>", `<summary>${escapeInline(label)}</summary>`, ""];
+  if (item.detail !== null && item.detail !== "")
+    lines.push(block(item.detail), "");
+  const output = toolOutput(item);
+  if (output !== "")
+    lines.push(status === "running" ? "Output so far:" : "Result:", "", block(output), "");
+  if (item.note !== null)
+    lines.push(`> ${escapeInline(oneLine(item.note))}`, "");
+  for (const image of item.images ?? [])
+    lines.push(`> [image] ${escapeInline(imageLabel(image))}`, "");
+  lines.push("</details>", "");
+  return lines;
+}
+function exportJson(source, options) {
+  const items = source.items.map((item) => {
+    switch (item.type) {
+      case "user":
+        return {
+          type: "user",
+          text: userText2(item),
+          images: (item.images ?? []).map(({ name, mimeType, width, height, bytes }) => ({
+            name,
+            mimeType,
+            width,
+            height,
+            bytes
+          }))
+        };
+      case "assistant":
+        return {
+          type: "assistant",
+          text: item.text,
+          ...options.includeThinking && item.thinking.trim() !== "" ? { thinking: item.thinking } : {},
+          stopReason: item.stopReason,
+          note: item.note
+        };
+      case "tool":
+        return {
+          type: "tool",
+          name: item.name,
+          summary: item.summary,
+          detail: item.detail,
+          status: item.phase,
+          isError: item.isError,
+          result: toolOutput(item),
+          durationMs: item.durationMs,
+          note: item.note,
+          images: (item.images ?? []).map(({ name, mimeType, width, height, bytes }) => ({
+            name,
+            mimeType,
+            width,
+            height,
+            bytes
+          }))
+        };
+      default:
+        return { type: "system", text: item.text };
+    }
+  });
+  return `${JSON.stringify({
+    format: "neko-conversation",
+    version: 1,
+    session: {
+      id: source.sessionId,
+      title: source.title,
+      model: source.model,
+      cwd: source.cwd,
+      exportedAt: source.exportedAt.toISOString()
+    },
+    items
+  }, null, 2)}
+`;
+}
+var EXPORT_EXTENSIONS, MIME_TYPES, MAX_FILE_TITLE_CHARS = 60, escapeInline = (text) => text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+var init_conversation_export = __esm(() => {
+  init_conversation_export_html();
+  init_conversation_export_html();
+  EXPORT_EXTENSIONS = { markdown: "md", html: "html", json: "json" };
+  MIME_TYPES = {
+    markdown: "text/markdown;charset=utf-8",
+    html: "text/html;charset=utf-8",
+    json: "application/json;charset=utf-8"
+  };
+});
+
+// packages/tui/src/clipboard-write.ts
+import { spawn as spawn2 } from "child_process";
+import { getNativeClipboard } from "@earendil-works/pi-tui";
+function runClipboardCommand(command, args, input) {
+  const { promise, resolve } = Promise.withResolvers();
+  const child = spawn2(command, args, { stdio: ["pipe", "ignore", "ignore"], windowsHide: true });
+  const timer = setTimeout(() => {
+    child.kill("SIGKILL");
+    resolve(false);
+  }, COMMAND_TIMEOUT_MS);
+  child.on("error", () => {
+    clearTimeout(timer);
+    resolve(false);
+  });
+  child.on("close", (code) => {
+    clearTimeout(timer);
+    resolve(code === 0);
+  });
+  child.stdin.on("error", () => {});
+  child.stdin.end(input);
+  return promise;
+}
+async function copyToClipboard(text, deps) {
+  const platform = deps.platform ?? process.platform;
+  const env = deps.env ?? process.env;
+  const native = "native" in deps ? deps.native : getNativeClipboard();
+  const run = deps.run ?? runClipboardCommand;
+  let method = null;
+  if (platform !== "linux" && native?.setText !== undefined) {
+    try {
+      await native.setText(text);
+      method = "native";
+    } catch {}
+  }
+  if (method === null) {
+    const tools = [];
+    if (platform === "darwin")
+      tools.push(["pbcopy", []]);
+    else if (platform === "win32")
+      tools.push([
+        "powershell.exe",
+        [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          "$t=[IO.StreamReader]::new([Console]::OpenStandardInput(),[Text.UTF8Encoding]::new($false)).ReadToEnd();Set-Clipboard -Value $t"
+        ]
+      ]);
+    else {
+      if (env.TERMUX_VERSION)
+        tools.push(["termux-clipboard-set", []]);
+      if (env.WAYLAND_DISPLAY)
+        tools.push(["wl-copy", []]);
+      if (env.DISPLAY)
+        tools.push(["xclip", ["-selection", "clipboard"]], ["xsel", ["--clipboard", "--input"]]);
+    }
+    for (const [command, args] of tools) {
+      if (await run(command, args, text)) {
+        method = "command";
+        break;
+      }
+    }
+  }
+  const remote = Boolean(env.SSH_CONNECTION || env.SSH_CLIENT || env.MOSH_CONNECTION);
+  let osc52Sent = false;
+  if (method === null || remote) {
+    const encoded = Buffer.from(text).toString("base64");
+    if (encoded.length <= OSC52_MAX_BASE64_LENGTH) {
+      deps.osc52(`\x1B]52;c;${encoded}\x07`);
+      osc52Sent = true;
+    }
+  }
+  if (method === null && !osc52Sent)
+    throw new Error(`Clipboard unavailable: no clipboard tool worked and ${text.length} chars is too large for OSC 52. Use /export to save it to a file.`);
+  return { method: method ?? "osc52", osc52Sent };
+}
+async function copyLastAnswer(items, deps) {
+  const text = lastAnswerText(items);
+  if (text === null)
+    return { level: "warning", message: "Nothing to copy yet: no assistant answer in this session." };
+  try {
+    const result = await copyToClipboard(text, deps);
+    return {
+      level: "info",
+      message: result.osc52Sent ? `Sent to terminal clipboard via OSC 52 (${text.length} chars); your terminal must allow it` : `Copied last response (${text.length} chars)`
+    };
+  } catch (error) {
+    return { level: "error", message: error instanceof Error ? error.message : String(error) };
+  }
+}
+var OSC52_MAX_BASE64_LENGTH = 1e5, COMMAND_TIMEOUT_MS = 3000;
+var init_clipboard_write = __esm(() => {
+  init_conversation_export();
+});
+
+// packages/tui/src/components/assistant-message.ts
+import { Container, Markdown, MouseRegion, Spacer, Text as Text2 } from "@earendil-works/pi-tui";
+var THINKING_COLLAPSED_LABEL = "\u2727 Thinking\u2026 (click to expand)", AssistantMessageComponent;
+var init_assistant_message = __esm(() => {
+  init_theme();
+  AssistantMessageComponent = class AssistantMessageComponent extends Container {
+    #renderTheme = getActiveThemeMode();
+    #lastContent;
+    #isStreaming = false;
+    #thinkingExpanded = false;
+    #renderWidth = 80;
+    constructor(content, isStreaming = false) {
+      super();
+      if (content !== undefined)
+        this.updateContent(content, isStreaming);
+    }
+    render(width) {
+      if (this.#renderTheme !== getActiveThemeMode()) {
+        this.#renderTheme = getActiveThemeMode();
+        this.#rebuild();
+      }
+      this.#renderWidth = width;
+      return super.render(width);
+    }
+    #highlightWidth() {
+      return Math.max(10, this.#renderWidth - 4);
     }
     updateContent(content, isStreaming = this.#isStreaming) {
       this.#lastContent = content;
@@ -14685,10 +17119,28 @@ var init_editor = __esm(() => {
       this.#completionEpoch++;
       this.resetEscapeSequence();
       super.setText(text);
+      this.#flushHistory();
+    }
+    setHistory(entries) {
+      if (this["historyIndex"] > -1) {
+        this.#pendingHistory = entries;
+        return;
+      }
+      this.#pendingHistory = undefined;
+      const current = this["history"];
+      if (current.length === entries.length && current.every((entry, i) => entry === entries[i]))
+        return;
+      this["history"] = [...entries];
+    }
+    #pendingHistory;
+    #flushHistory() {
+      if (this.#pendingHistory !== undefined && this["historyIndex"] === -1)
+        this.setHistory(this.#pendingHistory);
     }
     handleInput(data) {
       if (isKeyRelease(data))
         return;
+      this.#flushHistory();
       this.#completionEpoch++;
       if (matchesKey3(data, "escape") && this.isShowingAutocomplete()) {
         this.resetEscapeSequence();
@@ -14780,6 +17232,8 @@ var init_labels = __esm(() => {
     { name: "help", description: "Show keyboard shortcuts and commands" },
     { name: "version", description: "View versions and check for updates" },
     { name: "compact", description: "Compact context (/compact optional instructions)" },
+    { name: "copy", description: "Copy the last assistant response" },
+    { name: "export", description: "Export session (/export path.md|.html|.json [--thinking])" },
     { name: "exit", description: "Exit neko TUI" },
     { name: "new", description: "Create a new session" },
     { name: "sessions", description: "Switch or create a session" },
@@ -15068,7 +17522,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 +17540,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 +17577,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 +17596,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 +17624,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 +17666,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 +17683,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();
@@ -15535,6 +18038,17 @@ class ThemedTruncatedText {
     return new TruncatedText(this.#content(), this.#paddingX, this.#paddingY).render(width);
   }
 }
+
+class ThemedWrappedText {
+  #content;
+  constructor(content) {
+    this.#content = content;
+  }
+  invalidate() {}
+  render(width) {
+    return new Text4(this.#content(), 1, 0).render(width);
+  }
+}
 var ThemedText;
 var init_themed_text = __esm(() => {
   ThemedText = class ThemedText extends Text4 {
@@ -15556,6 +18070,103 @@ var init_themed_text = __esm(() => {
   };
 });
 
+// packages/tui/src/components/diff-view.ts
+function parseDiffLine(line, format = "edit") {
+  if (format === "write") {
+    return line.startsWith("+ ") ? { prefix: "+", lineNum: "", content: line.slice(2) } : null;
+  }
+  const match = /^([+\- ])( *\d+) (.*)$/.exec(line);
+  if (match === null)
+    return null;
+  const first = match[1];
+  const prefix = first === "+" || first === "-" ? first : " ";
+  return { prefix, lineNum: match[2] ?? "", content: match[3] ?? "" };
+}
+function parseDiffLines(diff, format = "edit") {
+  return diff.split(`
+`).map((line) => {
+    const parsed = parseDiffLine(line, format);
+    if (parsed === null)
+      return { kind: "raw", text: line };
+    const kind = parsed.prefix === "+" ? "add" : parsed.prefix === "-" ? "del" : "context";
+    return { kind, lineNum: parsed.lineNum, content: parsed.content };
+  });
+}
+function diffTargetPath(name, summary, detail) {
+  if (name === "edit") {
+    const path = summary.replace(/ \(\d+ edits?\)$/, "");
+    return path === "" ? undefined : path;
+  }
+  if (name === "write") {
+    if (detail !== null) {
+      const first = detail.split(`
+`, 1)[0] ?? "";
+      if (first !== "")
+        return first;
+    }
+    return summary === "" ? undefined : summary;
+  }
+  return;
+}
+function highlightDocuments(parsed, lang) {
+  const newContents = [];
+  const oldContents = [];
+  for (const line of parsed) {
+    if (line.kind === "raw")
+      continue;
+    if (line.kind !== "del")
+      newContents.push(line.content);
+    if (line.kind !== "add")
+      oldContents.push(line.content);
+  }
+  const newLines = highlightCodeToSegments(newContents.join(`
+`), lang);
+  const oldLines = highlightCodeToSegments(oldContents.join(`
+`), lang);
+  if (newLines === null || oldLines === null)
+    return null;
+  return { newLines, oldLines };
+}
+function styleSegments(segments) {
+  return segments.map((s) => s.slot === "plain" ? theme.codeFg(s.text) : theme[s.slot](s.text)).join("");
+}
+function paintChangedLine(kind, gutter, content) {
+  const bg = diffBackgroundAnsi(kind === "add" ? "added" : "removed");
+  return `${bg}${theme.dim(gutter)}${bg}${content}\x1B[49m`;
+}
+function highlightDiffLines(diff, lang, format = "edit") {
+  const parsed = parseDiffLines(diff, format);
+  const documents = highlightDocuments(parsed, lang);
+  if (documents === null)
+    return highlightCodeToAnsiLines(diff, "diff");
+  const rendered = [];
+  let newIndex = 0;
+  let oldIndex = 0;
+  for (const line of parsed) {
+    if (line.kind === "raw") {
+      rendered.push(theme.dim(line.text));
+      continue;
+    }
+    const sign = line.kind === "add" ? "+" : line.kind === "del" ? "-" : " ";
+    const gutter = `${sign}${line.lineNum} `;
+    if (line.kind === "del") {
+      rendered.push(paintChangedLine("del", gutter, styleSegments(documents.oldLines[oldIndex++] ?? [])));
+      continue;
+    }
+    if (line.kind === "add") {
+      rendered.push(paintChangedLine("add", gutter, styleSegments(documents.newLines[newIndex++] ?? [])));
+      continue;
+    }
+    rendered.push(`${theme.dim(gutter)}${styleSegments(documents.newLines[newIndex++] ?? [])}`);
+    oldIndex++;
+  }
+  return rendered;
+}
+var init_diff_view = __esm(() => {
+  init_slots();
+  init_syntax();
+});
+
 // packages/tui/src/components/tool-execution.ts
 import { Box, Container as Container3, MouseRegion as MouseRegion2, Text as Text5 } from "@earendil-works/pi-tui";
 function currentToolFrame() {
@@ -15586,15 +18197,23 @@ class ToolSpinnerTicker {
     this.#timer = undefined;
   }
 }
+function diffCountSuffix(state) {
+  if (state.diffAdded === null)
+    return "";
+  const removed = state.diffRemoved !== null && state.diffRemoved > 0 ? `/-${state.diffRemoved}` : "";
+  return ` (+${state.diffAdded}${removed})`;
+}
 function clipLines(text, maxLines) {
   const lines = text.split(`
 `);
   return { visible: lines.slice(0, maxLines).join(`
 `), rest: Math.max(0, lines.length - maxLines) };
 }
-var SPINNER_FRAMES, spinnerFrame = 0, ToolExecutionComponent;
+var SPINNER_FRAMES, spinnerFrame = 0, DIFF_MAX_LINES = 50, ToolExecutionComponent;
 var init_tool_execution = __esm(() => {
   init_theme();
+  init_syntax();
+  init_diff_view();
   SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
   ToolExecutionComponent = class ToolExecutionComponent extends Container3 {
     #renderTheme = getActiveThemeMode();
@@ -15648,16 +18267,38 @@ var init_tool_execution = __esm(() => {
     }
     rebuild() {
       const state = this.#state;
-      const parts = [`${theme.toolTitle(`\u26A1 ${state.name}`)}`, theme.dim(state.summary), this.#statusLine(state.phase)];
+      const parts = [
+        `${theme.toolTitle(`\u26A1 ${state.name}`)}`,
+        theme.dim(state.summary + diffCountSuffix(state)),
+        this.#statusLine(state.phase)
+      ];
       let text = parts.join("  ");
-      if (this.#expanded && state.detail !== null) {
-        const detail = clipLines(state.detail, 20);
-        text += `
+      if (this.#expanded) {
+        const detail = state.detail;
+        if (detail !== null && !(state.diff !== null && state.name === "write" && !state.diffTruncated)) {
+          const clipped = clipLines(detail, 20);
+          text += `
 ${theme.dim("---- Arguments ----")}
-${detail.visible}`;
-        if (detail.rest > 0)
+${clipped.visible}`;
+          if (clipped.rest > 0)
+            text += `
+${theme.dim(`... ${clipped.rest} more lines`)}`;
+        }
+        if (state.diff !== null) {
+          const clipped = clipLines(state.diff, DIFF_MAX_LINES);
+          const lang = languageForPath(diffTargetPath(state.name, state.summary, state.detail));
+          const format = state.name === "write" ? "write" : "edit";
           text += `
-${theme.dim(`... ${detail.rest} more lines`)}`;
+${theme.dim("---- Diff ----")}
+${highlightDiffLines(clipped.visible, lang, format).join(`
+`)}`;
+          if (state.diffTruncated)
+            text += `
+${theme.dim("\u2026 Diff preview truncated (line or byte limit)")}`;
+          if (clipped.rest > 0)
+            text += `
+${theme.dim(`\u2026 +${clipped.rest} more lines`)}`;
+        }
       }
       const body = state.phase === "running" ? state.output : state.result;
       if (!this.#expanded && body !== null && body !== "") {
@@ -15844,6 +18485,90 @@ function followTerminalTheme(ui, apply) {
 }
 var THEME_QUERY_TIMEOUT_MS = 100;
 
+// packages/tui/src/export-command.ts
+import { open as open2, unlink as unlink2 } from "fs/promises";
+import { homedir as homedir6 } from "os";
+import { resolve as resolve4 } from "path";
+function parseExportArgs(input) {
+  const words = [];
+  let word = "";
+  let quote = "";
+  let quoted = false;
+  let active = false;
+  for (const c of input) {
+    if (quote !== "") {
+      if (c === quote)
+        quote = "";
+      else
+        word += c;
+    } else if (c === '"' || c === "'") {
+      quote = c;
+      quoted = true;
+      active = true;
+    } else if (/\s/.test(c)) {
+      if (active)
+        words.push({ text: word, quoted });
+      word = "";
+      quoted = false;
+      active = false;
+    } else {
+      word += c;
+      active = true;
+    }
+  }
+  if (quote !== "")
+    throw new Error(`Unterminated quote. ${EXPORT_USAGE}`);
+  if (active)
+    words.push({ text: word, quoted });
+  let includeThinking = false;
+  let path;
+  for (const { text, quoted: wasQuoted } of words) {
+    if (!wasQuoted && text === "--thinking")
+      includeThinking = true;
+    else if (!wasQuoted && text.startsWith("--"))
+      throw new Error(`Unknown option ${text}. ${EXPORT_USAGE}`);
+    else if (path === undefined && text !== "")
+      path = text;
+    else
+      throw new Error(EXPORT_USAGE);
+  }
+  return { path, includeThinking };
+}
+async function exportToFile(input) {
+  const format = input.path === undefined ? "markdown" : exportFormatFromPath(input.path);
+  if (format === null)
+    throw new Error("Unsupported export format: use a .md, .html or .json path");
+  const target = resolve4(input.cwd, input.path === undefined ? exportFileName(input.source.title, format, input.source.exportedAt) : input.path.startsWith("~/") ? homedir6() + input.path.slice(1) : input.path);
+  let handle;
+  try {
+    handle = await open2(target, "wx");
+  } catch (error) {
+    const code = error.code;
+    if (code === "EEXIST")
+      throw new Error(`File already exists: ${target}. Choose another path.`);
+    if (code === "ENOENT")
+      throw new Error(`Directory does not exist: ${target}`);
+    throw error;
+  }
+  try {
+    const result = await exportConversation(format, input.source, {
+      includeThinking: input.includeThinking,
+      ...input.loadImage ? { loadImage: input.loadImage } : {}
+    });
+    await handle.writeFile(result.content, "utf8");
+    return { path: target, skippedImages: result.skippedImages };
+  } catch (error) {
+    await unlink2(target).catch(() => {});
+    throw error;
+  } finally {
+    await handle.close().catch(() => {});
+  }
+}
+var EXPORT_USAGE = "Usage: /export [path.md|path.html|path.json] [--thinking]";
+var init_export_command = __esm(() => {
+  init_conversation_export();
+});
+
 // packages/core/src/file-mentions.ts
 function mentionAt(text, cursor) {
   const before = text.slice(0, cursor);
@@ -15908,7 +18633,7 @@ function fileCompletion(commands, root, notice, search) {
 var init_file_completion = () => {};
 
 // packages/gateway/src/unix-link.ts
-import { lstat as lstat2, mkdir as mkdir4, unlink as unlink2 } from "fs/promises";
+import { lstat as lstat2, mkdir as mkdir4, unlink as unlink3 } from "fs/promises";
 import { connect, createServer } from "net";
 import { dirname as dirname7 } from "path";
 import { webSocketLink as webSocketLink2 } from "@earendil-works/chord";
@@ -16051,7 +18776,7 @@ function createUnixListener(options) {
         });
         if (active)
           throw new Error("Gateway already running at this socket");
-        await unlink2(options.path);
+        await unlink3(options.path);
       } catch (error) {
         if (error.code !== "ENOENT")
           throw error;
@@ -16081,7 +18806,7 @@ function createUnixListener(options) {
         await new Promise((resolve) => previous.close(() => resolve()));
       if (bound) {
         bound = false;
-        await unlink2(options.path).catch(() => {});
+        await unlink3(options.path).catch(() => {});
       }
     }
   };
@@ -16311,6 +19036,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 +19099,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 +19110,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 +19167,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 +19197,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 +19232,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 +19265,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")
@@ -16531,7 +19274,7 @@ var init_subagent_host = __esm(() => {
 });
 
 // packages/gateway/src/session-host.ts
-import { open as open2 } from "fs/promises";
+import { open as open3 } from "fs/promises";
 import { basename as basename5, extname } from "path";
 import {
   ChordError as ChordError2,
@@ -16543,7 +19286,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 +19303,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 +19335,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,
@@ -16708,7 +19455,7 @@ function serveSessions(host, runtime, context) {
         const model = runtime.listModels().find((m) => m.provider === agent.model?.provider && m.modelId === agent.model?.modelId);
         if (!model?.input.includes("image"))
           throw new Error("Current model does not support images");
-        const handle = await open2(target, "r");
+        const handle = await open3(target, "r");
         let id;
         try {
           const info = await handle.stat();
@@ -16944,7 +19691,7 @@ var require2, _a, Worker, isMarkedAsUntransferable, u8, u16, i32, fleb, fdeb, cl
     }
   }
   return { b, r };
-}, _a, fl, revfl, _b, fd, revfd, rev, x, i, hMap = function(cd, mb, r) {
+}, _a, fl, revfl, _b, fd, revfd, rev, x2, i, hMap = function(cd, mb, r) {
   var s = cd.length;
   var i = 0;
   var l = new u16(mb);
@@ -17148,7 +19895,7 @@ var require2, _a, Worker, isMarkedAsUntransferable, u8, u16, i32, fleb, fdeb, cl
       final = 1, st.m = lbt, st.d = dm, st.n = dbt;
   } while (!final);
   return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
-}, et, b2 = function(d, b) {
+}, et2, b2 = function(d, b) {
   return d[b] | d[b + 1] << 8;
 }, b4 = function(d, b) {
   return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
@@ -17214,10 +19961,10 @@ var init_esm = __esm(() => {
   revfd = _b.r;
   rev = new u16(32768);
   for (i = 0;i < 32768; ++i) {
-    x = (i & 43690) >> 1 | (i & 21845) << 1;
-    x = (x & 52428) >> 2 | (x & 13107) << 2;
-    x = (x & 61680) >> 4 | (x & 3855) << 4;
-    rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+    x2 = (i & 43690) >> 1 | (i & 21845) << 1;
+    x2 = (x2 & 52428) >> 2 | (x2 & 13107) << 2;
+    x2 = (x2 & 61680) >> 4 | (x2 & 3855) << 4;
+    rev[i] = ((x2 & 65280) >> 8 | (x2 & 255) << 8) >> 1;
   }
   flt = new u8(288);
   for (i = 0;i < 144; ++i)
@@ -17249,10 +19996,10 @@ var init_esm = __esm(() => {
     "stream finishing",
     "invalid zip data"
   ];
-  et = /* @__PURE__ */ new u8(0);
+  et2 = /* @__PURE__ */ new u8(0);
   td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder;
   try {
-    td.decode(et, { stream: true });
+    td.decode(et2, { stream: true });
     tds = 1;
   } catch (e) {}
 });
@@ -17260,10 +20007,10 @@ var init_esm = __esm(() => {
 // packages/gateway/src/skill-market.ts
 import { createHash, randomUUID as randomUUID2 } from "crypto";
 import { mkdir as mkdir5, readdir as readdir2, rename as rename3, rm as rm4, stat as stat3, writeFile as writeFile4 } from "fs/promises";
-import { homedir as homedir6 } from "os";
+import { homedir as homedir7 } from "os";
 import { dirname as dirname8, join as join9 } from "path";
 function createSkillMarketClient(options) {
-  const home = options.home ?? homedir6();
+  const home = options.home ?? homedir7();
   const fetchImpl = options.fetchImpl ?? fetch;
   const now = options.now ?? Date.now;
   let base;
@@ -17991,7 +20738,7 @@ var init_src2 = __esm(() => {
 });
 
 // packages/tui/src/gateway.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
 import { basename as basename7, dirname as dirname11, join as join12 } from "path";
 async function connectToGateway(options = {}) {
@@ -18032,7 +20779,7 @@ async function connectToGateway(options = {}) {
 }
 async function spawnAndConnect(plan) {
   const command = gatewayCommand(gatewayArgs(plan));
-  const child = spawn2(command.binary, command.args, { stdio: ["ignore", "pipe", "pipe"] });
+  const child = spawn3(command.binary, command.args, { stdio: ["ignore", "pipe", "pipe"] });
   const outputTail = captureOutput(child);
   let spawnError;
   child.on("error", (error) => {
@@ -18206,6 +20953,7 @@ function helpLines(platform = process.platform) {
     ["Alt+Enter", "Queue while running"],
     ["Esc", "Stop a running task or blocking compaction"],
     ["Esc Esc", "Clear draft when idle (press twice quickly)"],
+    ["Up / Down", "Browse previous inputs in this session"],
     ["Ctrl+C", "Stop while running; exit when idle"],
     ["Ctrl+S", "Open sessions"],
     [platform === "win32" ? "Alt+V" : "Ctrl+V", "Paste clipboard image or text"],
@@ -18229,8 +20977,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"],
@@ -18314,8 +21062,8 @@ var init_help_ui = __esm(() => {
 // packages/tui/src/image-input.ts
 import { execFile as execFile2 } from "child_process";
 import { readFile as readFile8, stat as stat5 } from "fs/promises";
-import { homedir as homedir7 } from "os";
-import { basename as basename8, resolve as resolve4 } from "path";
+import { homedir as homedir8 } from "os";
+import { basename as basename8, resolve as resolve5 } from "path";
 import { promisify as promisify2 } from "util";
 import { isKeyRelease as isKeyRelease4, isKeyRepeat as isKeyRepeat2, matchesKey as matchesKey7 } from "@earendil-works/pi-tui";
 function imagePaths(text, platform = process.platform) {
@@ -18349,7 +21097,7 @@ function imagePaths(text, platform = process.platform) {
   return paths.length && paths.every((p) => /\.(png|jpe?g|webp)$/i.test(p)) ? paths : null;
 }
 async function readImageFile(path, cwd) {
-  const full = resolve4(cwd, path.startsWith("~/") ? homedir7() + path.slice(1) : path);
+  const full = resolve5(cwd, path.startsWith("~/") ? homedir8() + path.slice(1) : path);
   const info = await stat5(full);
   if (!info.isFile() || info.size > 20 * 1024 * 1024)
     throw new Error("Image must be a file no larger than 20 MiB");
@@ -18707,7 +21455,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 +21477,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 +21506,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 +21587,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 +21604,7 @@ class SubagentDetail {
           return true;
         }
       });
-    else
+    } else
       return false;
     return true;
   }
@@ -18851,14 +21628,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 +21692,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 +21705,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();
@@ -19052,20 +21845,6 @@ var init_version_ui = __esm(() => {
   init_application_version();
 });
 
-// packages/core/src/session-display.ts
-function relativeTime(at, now, language = "en") {
-  const minutes = Math.floor(Math.max(0, now - at) / 60000);
-  if (minutes < 1)
-    return language === "zh" ? "\u521A\u521A" : "now";
-  const hours = Math.floor(minutes / 60), days = Math.floor(hours / 24);
-  if (days >= 30)
-    return new Date(at).toLocaleDateString(language === "zh" ? "zh-CN" : "en-GB");
-  const value = days || hours || minutes;
-  const unit = days ? ["\u5929", "d"] : hours ? ["\u5C0F\u65F6", "h"] : ["\u5206\u949F", "m"];
-  return language === "zh" ? `${value} ${unit[0]}\u524D` : `${value}${unit[1]}`;
-}
-var sessionName = (session, empty = "New session") => session.title || session.firstPromptPreview || empty, messageTime = (session) => session.lastMessageAt ?? session.createdAt, byMessage = (a, b) => messageTime(b) - messageTime(a) || Number(b.id) - Number(a.id), byVisited = (a, b) => b.lastUsedAt - a.lastUsedAt || Number(b.id) - Number(a.id);
-
 // packages/tui/src/workspace.ts
 function workspaceSessions(sessions, cwd) {
   return sessions.filter((s) => s.workspaceRoot === cwd).sort(byMessage);
@@ -19117,6 +21896,7 @@ class NekoTuiApp {
   #noticeTimer;
   #compactionTimer;
   #editor;
+  #historyItems;
   #footer = new StatusFooter;
   #welcome = new WelcomeScreen;
   #welcomeAttached = false;
@@ -19455,6 +22235,14 @@ class NekoTuiApp {
       this.#manage(() => this.archiveSession());
       return;
     }
+    if (trimmed === "/copy") {
+      this.#copyLastAnswer();
+      return;
+    }
+    if (trimmed === "/export" || trimmed.startsWith("/export ")) {
+      this.#exportSession(trimmed.slice("/export".length));
+      return;
+    }
     const chat = this.#chat;
     if (chat === undefined)
       return;
@@ -19555,6 +22343,44 @@ class NekoTuiApp {
       this.#ui.requestRender();
     }
   }
+  async#copyLastAnswer() {
+    const outcome = await copyLastAnswer(this.#lastView?.items ?? [], {
+      osc52: (sequence) => this.#terminal.write(sequence)
+    });
+    this.addNotice(outcome.message, outcome.level);
+  }
+  async#exportSession(argumentText) {
+    const view = this.#lastView;
+    const chat = this.#chat;
+    const sessionId = this.#sessionId;
+    if (view === undefined || chat === undefined) {
+      this.addNotice("No session is open.", "warning");
+      return;
+    }
+    let args;
+    try {
+      args = parseExportArgs(argumentText);
+    } catch (error) {
+      this.addNotice(messageOf(error), "warning", { wrap: true });
+      return;
+    }
+    const summary = this.#gateway.client.directory.state.value?.sessions.find((s) => s.id === sessionId);
+    const title = summary ? sessionName(summary, "") : "";
+    this.addNotice("Exporting...");
+    try {
+      const { path, skippedImages } = await exportToFile({
+        ...args,
+        cwd: this.#options.cwd ?? process.cwd(),
+        source: { sessionId, title, model: view.model, cwd: view.cwd, exportedAt: new Date, items: view.items },
+        loadImage: (image) => downloadImage((offset) => chat.getImage({ entryId: image.entryId, contentIndex: image.contentIndex, offset }))
+      });
+      const other = sessionId !== this.#sessionId ? ` (session ${title || sessionId})` : "";
+      const skipped = skippedImages > 0 ? `; ${skippedImages} image(s) not embedded` : "";
+      this.addNotice(`Exported${other} to ${path}${skipped}`, "info", { wrap: true, ttlMs: 20000 });
+    } catch (error) {
+      this.addNotice(`Export failed: ${messageOf(error)}`, "error", { wrap: true, ttlMs: 20000 });
+    }
+  }
   abort() {
     const chat = this.#chat;
     if (chat === undefined)
@@ -19585,6 +22411,8 @@ class NekoTuiApp {
     this.#sessionId = id;
     this.#refreshSkills(handle);
     this.#editor.setText(this.#texts.get(id) ?? "");
+    this.#editor.setHistory([]);
+    this.#historyItems = undefined;
     this.#resetTranscript();
     const view = handle.view;
     if (view.value !== undefined)
@@ -19753,19 +22581,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)
@@ -19774,14 +22608,15 @@ class NekoTuiApp {
       this.#login.close();
     this.#ui.setFocus(this.#editor);
   }
-  addNotice(text, level = "info") {
+  addNotice(text, level = "info", options = {}) {
     clearTimeout(this.#noticeTimer);
     this.#noticeTimer = setTimeout(() => {
       this.#notices.clear();
       this.#ui.requestRender();
-    }, 5000);
+    }, options.ttlMs ?? 5000);
     this.#notices.clear();
-    this.#notices.addChild(new ThemedTruncatedText(() => formatNotice(text, level), 1, 0));
+    const content = () => formatNotice(text, level);
+    this.#notices.addChild(options.wrap ? new ThemedWrappedText(content) : new ThemedTruncatedText(content, 1, 0));
     this.#ui.requestRender();
   }
   scheduleApply() {
@@ -19805,16 +22640,22 @@ class NekoTuiApp {
   }
   applyView(view) {
     this.#lastView = view;
+    if (this.#historyItems !== view.items) {
+      this.#historyItems = view.items;
+      this.#editor.setHistory(promptHistory(view.items));
+    }
     if (this.#chat)
       this.#approval.update(view.subagents ?? []);
     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)) {
@@ -19932,7 +22773,11 @@ class NekoTuiApp {
         summary: item.summary,
         detail: item.detail,
         phase: item.phase,
-        output: item.output
+        output: item.output,
+        diff: item.diff,
+        diffAdded: item.diffAdded,
+        diffRemoved: item.diffRemoved,
+        diffTruncated: item.diffTruncated
       });
       component.sync(item);
       this.#items.set(item.key, { kind: "tool", component });
@@ -20014,7 +22859,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,
@@ -20085,7 +22930,11 @@ function streamingCardState(call) {
     output: call.output,
     result: null,
     durationMs: null,
-    note: null
+    note: null,
+    diff: call.diff,
+    diffAdded: call.diffAdded,
+    diffRemoved: call.diffRemoved,
+    diffTruncated: call.diffTruncated
   };
 }
 function messageOf(error) {
@@ -20131,7 +22980,9 @@ var EXIT_COMMANDS, SESSIONS_COMMANDS, NEW_SESSION_VALUE = "__new__";
 var init_tui = __esm(() => {
   init_src();
   init_application_updates();
+  init_input_history();
   init_approval_dock();
+  init_clipboard_write();
   init_assistant_message();
   init_editor();
   init_footer();
@@ -20143,6 +22994,7 @@ var init_tui = __esm(() => {
   init_tool_execution();
   init_user_message();
   init_welcome();
+  init_export_command();
   init_file_completion();
   init_gateway2();
   init_help_ui();
@@ -20268,7 +23120,7 @@ function openBrowser(url) {
 var init_open_browser = () => {};
 
 // packages/web/src/gateway-spawn.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import { randomUUID as randomUUID5 } from "crypto";
 import { mkdir as mkdir7, readFile as readFile9, writeFile as writeFile6 } from "fs/promises";
 import { dirname as dirname12, join as join13 } from "path";
@@ -20370,7 +23222,7 @@ function spawnGatewayProcess(options, socketPath, serverId) {
     ...options.model !== undefined ? ["--model", `${options.model.provider}/${options.model.modelId}`] : []
   ];
   const command = gatewayCommand(args);
-  return spawn3(command.binary, command.args, { env: process.env, stdio: ["ignore", "pipe", "pipe"] });
+  return spawn4(command.binary, command.args, { env: process.env, stdio: ["ignore", "pipe", "pipe"] });
 }
 function pipeChildLogs(child, onLog) {
   if (onLog === undefined)
@@ -20460,10 +23312,10 @@ var init_gateway_spawn = __esm(() => {
 import { createReadStream } from "fs";
 import { stat as stat6 } from "fs/promises";
 import { createServer as createServer2 } from "http";
-import { dirname as dirname13, extname as extname2, resolve as resolve5, sep as sep2 } from "path";
+import { dirname as dirname13, extname as extname2, resolve as resolve6, sep as sep2 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 async function startWebServer(options = {}) {
-  const staticDir = resolve5(options.staticDir ?? DEFAULT_STATIC_DIR);
+  const staticDir = resolve6(options.staticDir ?? DEFAULT_STATIC_DIR);
   const workspaceRoot = normalizeWorkspace(options.gateway?.cwd ?? process.cwd());
   const gateway = await ensureNekoGateway({
     ...options.gateway ?? {},
@@ -20542,7 +23394,7 @@ async function handleHttp(request, response, info) {
 }
 async function serveStatic(pathname, method, response, staticDir) {
   const cleanPath = decodeURIComponent(pathname);
-  const candidate = resolve5(staticDir, `.${cleanPath}`);
+  const candidate = resolve6(staticDir, `.${cleanPath}`);
   if (candidate !== staticDir && !candidate.startsWith(staticDir + sep2)) {
     response.writeHead(403);
     response.end();
@@ -20553,13 +23405,13 @@ async function serveStatic(pathname, method, response, staticDir) {
     return;
   });
   if (stats?.isDirectory()) {
-    file = resolve5(file, "index.html");
+    file = resolve6(file, "index.html");
     stats = await stat6(file).catch(() => {
       return;
     });
   }
   if (stats === undefined && extname2(candidate) === "") {
-    file = resolve5(staticDir, "index.html");
+    file = resolve6(staticDir, "index.html");
     stats = await stat6(file).catch(() => {
       return;
     });