@goodfish/jarvy 0.3.0 → 0.4.0

package/dist/server/cli.js

@@ -11,7 +11,7 @@ import { createServer } from "node:http";
 import { getRequestListener } from "@hono/node-server";
 
 // src/server/api/app.ts
-import { Hono as Hono9 } from "hono";
+import { Hono as Hono10 } from "hono";
 import { HTTPException as HTTPException9 } from "hono/http-exception";
 import { serveStatic } from "@hono/node-server/serve-static";
 
@@ -432,6 +432,26 @@ function botRoutes(bots) {
 // src/server/api/routes/chats.ts
 import { Hono as Hono5 } from "hono";
 import { HTTPException as HTTPException7 } from "hono/http-exception";
+
+// src/server/api/views/download.ts
+var MEDIA_TYPES = /* @__PURE__ */ new Set(["video/webm", "video/mp4", "video/quicktime", "audio/mpeg", "audio/wav", "audio/x-wav", "audio/ogg", "audio/webm", "audio/mp4"]);
+function downloadType(mimeType) {
+  const type = mimeType.split(";")[0].trim().toLowerCase();
+  return MEDIA_TYPES.has(type) ? type : "application/octet-stream";
+}
+function byteRange(header, size) {
+  const match = header?.trim().match(/^bytes=(\d*)-(\d*)$/);
+  if (!match || !match[1] && !match[2]) return null;
+  if (!match[1]) {
+    const suffix = Number(match[2]);
+    return suffix === 0 ? "unsatisfiable" : { start: Math.max(0, size - suffix), end: size - 1 };
+  }
+  const start = Number(match[1]), end = match[2] ? Number(match[2]) : Infinity;
+  if (end < start) return null;
+  return start >= size ? "unsatisfiable" : { start, end: Math.min(end, size - 1) };
+}
+
+// src/server/api/routes/chats.ts
 function chatRoutes({ chats, bots }) {
   const routes = new Hono5();
   const view = (chat) => chatView(chat, (id) => chats.member(id));
@@ -484,11 +504,19 @@ function attachmentRoutes(chats) {
   routes.get("/:id", (c) => {
     const attachment = chats.download(c.get("actorId"), c.req.param("id"));
     if (!attachment) throw new HTTPException7(404, { message: "Attachment not found" });
-    return c.body(new Uint8Array(attachment.data), 200, {
-      "Content-Type": "application/octet-stream",
-      "Content-Length": String(attachment.data.length),
+    const size = attachment.data.length, range = byteRange(c.req.header("Range"), size);
+    const headers2 = {
+      "Content-Type": downloadType(attachment.file.mimeType),
+      "Accept-Ranges": "bytes",
       "Content-Disposition": `attachment; filename*=UTF-8''${encodeURIComponent(attachment.file.name)}`
-    });
+    };
+    if (range === "unsatisfiable") return c.body(null, 416, { ...headers2, "Content-Range": `bytes */${size}` });
+    if (!range) return c.body(new Uint8Array(attachment.data), 200, { ...headers2, "Content-Length": String(size) });
+    return c.body(
+      new Uint8Array(attachment.data.subarray(range.start, range.end + 1)),
+      206,
+      { ...headers2, "Content-Length": String(range.end - range.start + 1), "Content-Range": `bytes ${range.start}-${range.end}/${size}` }
+    );
   });
   routes.get("/:id/run", (c) => {
     const attachment = chats.download(c.get("actorId"), c.req.param("id"));
@@ -685,12 +713,68 @@ function channelRoutes({ chats }) {
   return routes;
 }
 
+// src/server/api/routes/live.ts
+import { Hono as Hono9 } from "hono";
+function liveRoutes({ account, bots }) {
+  const routes = new Hono9();
+  routes.get("/bots/:id/live", (c) => {
+    const token = c.get("sessionToken"), signal = c.req.raw.signal, live = bots.live(c.req.param("id"));
+    let disconnect;
+    const body = new ReadableStream({
+      start(controller) {
+        let ended = false;
+        const encoder = new TextEncoder();
+        const send = (event, data) => {
+          if (ended) return;
+          if ((controller.desiredSize ?? 0) <= 0) {
+            disconnect();
+            return;
+          }
+          controller.enqueue(encoder.encode(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`));
+        };
+        const { turn, unsubscribe } = live.subscribe((update) => {
+          if (!account.authenticated(token)) {
+            disconnect();
+            return;
+          }
+          send(update.type, update);
+        }, () => disconnect());
+        const heartbeat = setInterval(() => {
+          if (!account.authenticated(token)) disconnect();
+          else send("heartbeat", {});
+        }, 15e3);
+        heartbeat.unref();
+        const aborted = () => disconnect();
+        disconnect = (close = true) => {
+          if (ended) return;
+          ended = true;
+          clearInterval(heartbeat);
+          unsubscribe();
+          signal.removeEventListener("abort", aborted);
+          if (close) controller.close();
+        };
+        signal.addEventListener("abort", aborted, { once: true });
+        if (signal.aborted) disconnect();
+        else send("snapshot", { turn, now: Date.now() });
+      },
+      cancel() {
+        disconnect(false);
+      }
+    }, new ByteLengthQueuingStrategy({ highWaterMark: c.env.outgoing.writableHighWaterMark }));
+    return c.body(body, 200, { "Content-Type": "text/event-stream", Connection: "keep-alive", "X-Accel-Buffering": "no" });
+  });
+  return routes;
+}
+
 // src/server/api/app.ts
 function createHttpApp(services, webRoot) {
-  const app = new Hono9();
+  const app = new Hono10();
   app.use("*", headers);
   app.onError(handleError);
-  const api = new Hono9();
+  const api = new Hono10();
   api.use("*", apiSecurity);
   installAuthentication(api, services.account);
   api.route("/bots", botRoutes(services.bots));
@@ -699,6 +783,7 @@ function createHttpApp(services, webRoot) {
   api.route("/attachments", attachmentRoutes(services.chats));
   api.route("/", modelRoutes(services.models));
   api.route("/", eventRoutes(services));
+  api.route("/", liveRoutes(services));
   api.all("*", () => {
     throw new HTTPException9(404, { message: "API route not found" });
   });
@@ -3092,14 +3177,14 @@ function messageTargets({ dm, sender, members, mentioned, replied, subscribers }
   if (dm) return members.filter((member) => member.id !== sender.id).map((member) => ({ member, reason: "dm" }));
   const targets = mentioned.filter((member) => member.id !== sender.id).map((member) => ({ member, reason: "mention" }));
   const add = (member, reason) => {
-    if (member.id !== sender.id && !targets.some((target) => target.member.id === member.id)) targets.push({ member, reason });
+    if (member.id !== sender.id && !targets.some((target2) => target2.member.id === member.id)) targets.push({ member, reason });
   };
   if (replied && members.some((member) => member.id === replied.id)) add(replied, "reply");
   for (const member of members) if (subscribers.includes(member.id)) add(member, "subscription");
   return targets;
 }
 function echoTargets({ sender, members, subscribers, reached }) {
-  return members.filter((member) => member.id !== sender.id && subscribers.includes(member.id) && !reached.some((target) => target.member.id === member.id)).map((member) => ({ member, reason: "subscription" }));
+  return members.filter((member) => member.id !== sender.id && subscribers.includes(member.id) && !reached.some((target2) => target2.member.id === member.id)).map((member) => ({ member, reason: "subscription" }));
 }
 function reactionTargets({ actorId, author }) {
   return author && author.id !== actorId ? [{ member: author, reason: "author" }] : [];
@@ -3126,9 +3211,9 @@ function mutedUrgency(reason, urgency) {
 
 // src/server/service/delivery/delivery.ts
 function plan(kind, targets, muted = []) {
-  return targets.flatMap((target) => {
-    const urgency = urgencyOf(kind, target.reason);
-    return urgency ? [{ ...target, kind, urgency: muted.includes(target.member.id) ? mutedUrgency(target.reason, urgency) : urgency }] : [];
+  return targets.flatMap((target2) => {
+    const urgency = urgencyOf(kind, target2.reason);
+    return urgency ? [{ ...target2, kind, urgency: muted.includes(target2.member.id) ? mutedUrgency(target2.reason, urgency) : urgency }] : [];
   });
 }
 var Dispatcher = class {
@@ -3650,9 +3735,9 @@ var ChatService = class {
   /** A DM with another member of the actor's space (a Bot DMs its owner or another Bot); one per pair. */
   openDirect(actorId, targetId) {
     const owner = this.repository.channels.ownerOf(actorId), directory = this.repository.channels.directory(owner);
-    const actor = directory.find((member) => member.id === actorId), target = directory.find((member) => member.id === targetId);
-    if (!actor || !target) throw new ChatError(404, "Member not found");
-    const chat = this.repository.openDirect(actorId, targetId, owner, `${actor.name} \xB7 ${target.name}`);
+    const actor = directory.find((member) => member.id === actorId), target2 = directory.find((member) => member.id === targetId);
+    if (!actor || !target2) throw new ChatError(404, "Member not found");
+    const chat = this.repository.openDirect(actorId, targetId, owner, `${actor.name} \xB7 ${target2.name}`);
     this.notifySaved(chat.id);
     return chat;
   }
@@ -3964,8 +4049,8 @@ var Changes = class {
 // src/server/service/bot/activity.ts
 function activityPage(messages, history, limit) {
   const candidates2 = [
-    ...messages.map((record) => ({ kind: "chat", record })),
-    ...history.map((record) => ({ kind: "history", record }))
+    ...messages.map((record2) => ({ kind: "chat", record: record2 })),
+    ...history.map((record2) => ({ kind: "history", record: record2 }))
   ];
   candidates2.sort((a, b) => {
     if (a.record.timestamp !== b.record.timestamp) return b.record.timestamp - a.record.timestamp;
@@ -4121,7 +4206,74 @@ function configureHttp(timeoutMs) {
 
 // src/server/infra/pi/session.ts
 import { Type } from "typebox";
+
+// src/server/infra/pi/live.ts
+var LiveTranslator = class {
+  message = 0;
+  open = /* @__PURE__ */ new Set();
+  translate(event) {
+    switch (event.type) {
+      case "message_start":
+        if (event.message.role === "assistant") this.message++;
+        return [];
+      case "message_update": {
+        const update = event.assistantMessageEvent;
+        if (update.type !== "thinking_start" && update.type !== "thinking_delta" && update.type !== "thinking_end" && update.type !== "text_start" && update.type !== "text_delta" && update.type !== "text_end") return [];
+        const key = `${this.message}:${update.contentIndex}`, kind = update.type.startsWith("thinking") ? "thinking" : "text";
+        const events = [];
+        if (!this.open.has(key) && !update.type.endsWith("_end")) {
+          this.open.add(key);
+          events.push({ type: "block_start", key, kind });
+        }
+        if (update.type.endsWith("_delta") && "delta" in update && update.delta) events.push({ type: "block_delta", key, kind, delta: update.delta });
+        if (update.type.endsWith("_end") && this.open.delete(key)) events.push({ type: "block_end", key });
+        return events;
+      }
+      case "message_end": {
+        if (event.message.role !== "assistant") return [];
+        const prefix = `${this.message}:`, closing = [...this.open].filter((key) => key.startsWith(prefix));
+        for (const key of closing) this.open.delete(key);
+        return closing.map((key) => ({ type: "block_end", key }));
+      }
+      case "tool_execution_start":
+        return [{ type: "tool_start", id: event.toolCallId, parentId: event.parentToolCallId ?? null, name: event.toolName, args: event.args }];
+      case "tool_execution_end":
+        return [{ type: "tool_end", id: event.toolCallId, output: resultText(event.result), failed: event.isError }];
+      case "compaction_start":
+        return [{ type: "compaction_start" }];
+      case "compaction_end":
+        return [{
+          type: "compaction_end",
+          failed: !!event.errorMessage || event.aborted,
+          error: event.errorMessage ?? null,
+          tokensBefore: event.result?.tokensBefore ?? null,
+          tokensAfter: event.result?.estimatedTokensAfter ?? null
+        }];
+      case "auto_retry_start":
+        return [{ type: "retry_start", attempt: event.attempt, maxAttempts: event.maxAttempts, error: event.errorMessage }];
+      case "auto_retry_end":
+        return [{ type: "retry_end", failed: !event.success, error: event.finalError ?? null }];
+      default:
+        return [];
+    }
+  }
+};
+function resultText(result) {
+  const content2 = result?.content;
+  if (Array.isArray(content2)) return content2.map((part) => part?.type === "text" ? String(part.text ?? "") : part?.type === "image" ? "[image]" : "").filter(Boolean).join("\n");
+  if (typeof result === "string") return result;
+  try {
+    return JSON.stringify(result) ?? "";
+  } catch {
+    return String(result);
+  }
+}
+
+// src/server/infra/pi/session.ts
 var HTTP_IDLE_TIMEOUT_MS = 9e5;
+function compactionReserve(contextWindow) {
+  return Math.min(65536, Math.max(16384, Math.min(32768, Math.floor(contextWindow / 4)), Math.floor(contextWindow * 0.13)));
+}
 var PiSession = class _PiSession {
   constructor(options, models, credentials) {
     this.options = options;
@@ -4129,6 +4281,7 @@ var PiSession = class _PiSession {
     this.credentials = credentials;
   }
   session;
+  settings;
   unsubscribe;
   unsubscribeHistory;
   promptActive = false;
@@ -4140,6 +4293,7 @@ var PiSession = class _PiSession {
   abortFailure;
   result = { outcome: "completed" };
   signature = "";
+  translator = new LiveTranslator();
   get context() {
     const usage = this.session.getContextUsage();
     return usage ? { tokens: usage.tokens, contextWindow: usage.contextWindow, percent: usage.percent } : void 0;
@@ -4185,7 +4339,10 @@ var PiSession = class _PiSession {
     const sessionManager = SessionManager.open(reference.file, sessionsDir, bot.workspacePath);
     const adapter = new _PiSession(options, models, credentials);
     configureHttp(HTTP_IDLE_TIMEOUT_MS);
-    const settingsManager = SettingsManager.inMemory({ httpIdleTimeoutMs: HTTP_IDLE_TIMEOUT_MS });
+    const settingsManager = SettingsManager.inMemory({
+      httpIdleTimeoutMs: HTTP_IDLE_TIMEOUT_MS,
+      compaction: { reserveTokens: compactionReserve(model.contextWindow) }
+    });
     const tools = ["bash", "read", "edit", "write", "codemode", ...options.tools.map((tool) => tool.name)];
     const resourceLoader = new DefaultResourceLoader({
       cwd: bot.workspacePath,
@@ -4225,6 +4382,7 @@ var PiSession = class _PiSession {
       tools
     });
     adapter.session = result.session;
+    adapter.settings = settingsManager;
     if (result.extensionsResult.errors.length || !tools.every((name2) => adapter.session.getActiveToolNames().includes(name2))) {
       adapter.session.dispose();
       throw new RuntimeFault("tools_missing", "Couldn't load the run's tools.");
@@ -4238,8 +4396,8 @@ var PiSession = class _PiSession {
         for (let index = entries.length - 1; index >= 0; index--) {
           const entry = entries[index];
           if (entry.type !== "message" || entry.message !== event.message) continue;
-          const record = history.convert(entry);
-          if (record) await options.onHistory(record);
+          const record2 = history.convert(entry);
+          if (record2) await options.onHistory(record2);
           break;
         }
       });
@@ -4281,6 +4439,7 @@ var PiSession = class _PiSession {
       }
     );
     if (event.type === "message_end" && event.message.role === "assistant") this.result = this.classify(event.message);
+    if (this.options.live) for (const live of this.translator.translate(event)) this.options.live(live);
     this.maybeAbort();
   }
   /** The last assistant message decides the prompt (a later retry success replaces an earlier error).
@@ -4324,17 +4483,24 @@ var PiSession = class _PiSession {
     const settled = new Promise((resolve6) => {
       this.settledResolve = resolve6;
     });
+    this.options.live?.({ type: "start" });
+    let outcome = "failed";
     try {
-      await this.session.prompt(xml, { expandPromptTemplates: false });
+      try {
+        await this.session.prompt(xml, { expandPromptTemplates: false });
+      } finally {
+        await this.session.waitForIdle();
+        if (this.started && !this.settled) await settled;
+        this.promptActive = false;
+        await this.abortTask;
+        this.options.store.runtime.recordSession(this.options.bot.id, this.sessionId, existsSync(this.sessionFile));
+      }
+      if (this.abortFailure) throw this.abortFailure;
+      outcome = this.result.outcome;
+      return this.result;
     } finally {
-      await this.session.waitForIdle();
-      if (this.started && !this.settled) await settled;
-      this.promptActive = false;
-      await this.abortTask;
-      this.options.store.runtime.recordSession(this.options.bot.id, this.sessionId, existsSync(this.sessionFile));
+      this.options.live?.({ type: "end", outcome });
     }
-    if (this.abortFailure) throw this.abortFailure;
-    return this.result;
   }
   async configure(selection) {
     const connection = this.options.store.getModelConnection(selection.connectionId), configured2 = connection?.models.find((item) => item.id === selection.modelId);
@@ -4351,6 +4517,7 @@ var PiSession = class _PiSession {
     this.credentials.current = next;
     try {
       await this.session.setModel(model, { persist: false });
+      this.settings.applyOverrides({ compaction: { reserveTokens: compactionReserve(model.contextWindow) } });
       this.session.setThinkingLevel(resolveThinking(model, selection.thinkingLevel), { persist: false });
       this.signature = signature;
       return this.session.thinkingLevel;
@@ -4440,17 +4607,17 @@ var HistoryRepository = class {
     const row = this.db.prepare("SELECT * FROM history WHERE id=?").get(id);
     return row ? this.decode(row) : null;
   }
-  links(record) {
+  links(record2) {
     const links = [];
-    for (const block of record.message.content) {
+    for (const block of record2.message.content) {
       if (block.type !== "tool_call" && block.type !== "tool_result") continue;
       const callId = block.tool_call_id;
       if (block.type === "tool_result") {
-        const call = this.db.prepare(`SELECT id,role FROM history WHERE id<? AND ${CALL} ORDER BY id DESC LIMIT 1`).get(record.id, "tool_call", callId);
+        const call = this.db.prepare(`SELECT id,role FROM history WHERE id<? AND ${CALL} ORDER BY id DESC LIMIT 1`).get(record2.id, "tool_call", callId);
         if (call) links.push({ ...call, tool_call_id: callId });
       } else {
-        const next = this.db.prepare(`SELECT id FROM history WHERE id>? AND ${CALL} ORDER BY id LIMIT 1`).get(record.id, "tool_call", callId);
-        const results = this.db.prepare(`SELECT id,role FROM history WHERE id>? AND id<? AND ${CALL} ORDER BY id`).all(record.id, next?.id ?? Number.MAX_SAFE_INTEGER, "tool_result", callId);
+        const next = this.db.prepare(`SELECT id FROM history WHERE id>? AND ${CALL} ORDER BY id LIMIT 1`).get(record2.id, "tool_call", callId);
+        const results = this.db.prepare(`SELECT id,role FROM history WHERE id>? AND id<? AND ${CALL} ORDER BY id`).all(record2.id, next?.id ?? Number.MAX_SAFE_INTEGER, "tool_result", callId);
         links.push(...results.map((result) => ({ ...result, tool_call_id: callId })));
       }
     }
@@ -4494,14 +4661,14 @@ var Memory = class {
     return this.history().usage(since);
   }
   read(id) {
-    const record = this.history().read(id);
-    return record ? { record, links: this.history().links(record) } : null;
+    const record2 = this.history().read(id);
+    return record2 ? { record: record2, links: this.history().links(record2) } : null;
   }
   readMany(ids, mode) {
     const found = mode === "summary" ? this.history().summaries(ids).map((item) => item && summaryLine(item)) : this.history().details(ids);
     const result = { mode, records: [], missingIds: [] };
-    found.forEach((record, index) => {
-      if (record) result.records.push(record);
+    found.forEach((record2, index) => {
+      if (record2) result.records.push(record2);
       else result.missingIds.push(ids[index]);
     });
     return result;
@@ -4629,17 +4796,17 @@ var Bot = class extends Member {
       workspace: this.workspace.location(),
       tools: this.tools.definitions(),
       onStatus: (status) => this.updateState(status),
-      onHistory: (record) => this.recordHistory(record)
+      onHistory: (record2) => this.recordHistory(record2)
     };
   }
   updateState(status) {
     this.state.update(status);
   }
-  async recordHistory(record) {
-    const historyId = await this.memory.append(record);
-    if (record.role !== "assistant") return;
+  async recordHistory(record2) {
+    const historyId = await this.memory.append(record2);
+    if (record2.role !== "assistant") return;
     this.callHistory.clear();
-    for (const block of record.message.content) {
+    for (const block of record2.message.content) {
       if (block.type === "tool_call") this.callHistory.set(block.tool_call_id, historyId);
     }
   }
@@ -4798,20 +4965,20 @@ ${content(block.result.content, heading + "#")}`;
 function formatHistory(result, format) {
   if (format === "json") return JSON.stringify(result, null, 2);
   const sections = [`# History (${result.mode})`];
-  for (const record of result.records) {
-    sections.push(`## #${record.id} \xB7 ${record.role}`, `Time: ${new Date(record.timestamp).toISOString()}`);
-    if (record.model) sections.push(`Model:
+  for (const record2 of result.records) {
+    sections.push(`## #${record2.id} \xB7 ${record2.role}`, `Time: ${new Date(record2.timestamp).toISOString()}`);
+    if (record2.model) sections.push(`Model:
 
-${jsonBlock(record.model)}`);
-    if ("preview" in record) {
-      sections.push(fence(record.preview));
+${jsonBlock(record2.model)}`);
+    if ("preview" in record2) {
+      sections.push(fence(record2.preview));
       continue;
     }
-    sections.push(content(record.message.content));
-    if (record.message.tools !== void 0) sections.push("### Tool definitions", jsonBlock(record.message.tools));
-    if (record.message.tools_removed !== void 0) sections.push("### Tools removed", jsonBlock(record.message.tools_removed));
-    if (record.message.stop_reason !== void 0) sections.push("### Stop reason", fence(record.message.stop_reason));
-    if (record.message.error !== void 0) sections.push("### Error", fence(record.message.error));
+    sections.push(content(record2.message.content));
+    if (record2.message.tools !== void 0) sections.push("### Tool definitions", jsonBlock(record2.message.tools));
+    if (record2.message.tools_removed !== void 0) sections.push("### Tools removed", jsonBlock(record2.message.tools_removed));
+    if (record2.message.stop_reason !== void 0) sections.push("### Stop reason", fence(record2.message.stop_reason));
+    if (record2.message.error !== void 0) sections.push("### Error", fence(record2.message.error));
   }
   if (result.missingIds.length) sections.push(`## Missing IDs
 
@@ -5739,34 +5906,288 @@ When something will take a while, post a short progress note partway through, an
 `;
 }
 
+// src/server/shared/live.ts
+var LIVE_STEPS = 300;
+var LIVE_TEXT = 4e3;
+var LIVE_OUTPUT_END = 1200;
+var LIVE_INPUT = 300;
+var LIVE_MESSAGE = 2e3;
+
+// src/server/service/bot/live-input.ts
+function clip(text3, length) {
+  return text3.length > length ? `${text3.slice(0, length - 1)}\u2026` : text3;
+}
+var field = (value2, length = LIVE_INPUT) => typeof value2 === "string" ? clip(value2, length) : void 0;
+var record = (value2) => value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : {};
+function liveInput(tool, args, chat) {
+  const values = record(args);
+  switch (tool) {
+    case "bash":
+      return { command: field(values.command) };
+    case "read":
+    case "edit":
+    case "write":
+      return { path: field(values.path) };
+    case "codemode":
+      return { command: field(values.code) };
+    case "chat":
+      return gateway(values, chat);
+    default: {
+      let json2 = "";
+      try {
+        json2 = JSON.stringify(args) ?? "";
+      } catch {
+      }
+      return json2 ? { args: clip(json2, LIVE_INPUT) } : {};
+    }
+  }
+}
+function gateway(values, chat) {
+  const action = values.action === "call" && typeof values.tool === "string" ? values.tool : typeof values.action === "string" ? values.action : "";
+  const inner = record(values.args), where = target(inner, chat);
+  if (action === "messages.send") return { action, chat: where, text: field(inner.message, LIVE_MESSAGE) };
+  if (action === "messages.ask") return {
+    action,
+    chat: where,
+    text: field(inner.question, LIVE_MESSAGE),
+    options: Array.isArray(inner.options) ? inner.options.map((option2) => field(record(option2).label) ?? "").filter(Boolean) : void 0
+  };
+  return where ? { action, chat: where } : { action };
+}
+function target(inner, chat) {
+  if (typeof inner.to === "string") return { id: null, type: "dm", title: clip(inner.to, 80) };
+  return typeof inner.chatId === "string" ? chat(inner.chatId) ?? void 0 : void 0;
+}
+function sentChat(output, chat) {
+  try {
+    const chatId = JSON.parse(output).chatId;
+    return typeof chatId === "string" ? chat(chatId) ?? void 0 : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/server/service/bot/live.ts
+var FLUSH_MS = 100;
+function liveOutput(text3) {
+  if (!text3) return null;
+  if (text3.length <= 2 * LIVE_OUTPUT_END) return { head: text3, tail: "", omitted: 0 };
+  return { head: text3.slice(0, LIVE_OUTPUT_END), tail: text3.slice(-LIVE_OUTPUT_END), omitted: text3.length - 2 * LIVE_OUTPUT_END };
+}
+var LiveTurns = class {
+  constructor(chat) {
+    this.chat = chat;
+  }
+  turn = null;
+  steps = /* @__PURE__ */ new Map();
+  blocks = /* @__PURE__ */ new Map();
+  compaction = null;
+  retry = null;
+  counter = 0;
+  pending = [];
+  timer = null;
+  listeners = /* @__PURE__ */ new Map();
+  /** Listens from now on and returns the turn so far (null when the Bot is not running one). Pending changes go to
+   * the earlier listeners first, so the snapshot and the next patch never overlap. */
+  subscribe(listener, close) {
+    this.flush();
+    this.listeners.set(listener, close);
+    return { turn: this.turn ? structuredClone(this.turn) : null, unsubscribe: () => {
+      this.listeners.delete(listener);
+    } };
+  }
+  /** Ends every listener's stream (the Bot was deleted, or the server is stopping). */
+  close() {
+    for (const close of [...this.listeners.values()]) close();
+    this.listeners.clear();
+  }
+  event(event) {
+    if (event.type === "start") {
+      this.flush();
+      this.reset();
+      this.turn = { startedAt: Date.now(), steps: [], dropped: 0 };
+      this.emit({ type: "start", turn: structuredClone(this.turn) });
+      return;
+    }
+    if (!this.turn) return;
+    switch (event.type) {
+      case "end": {
+        for (const step of this.turn.steps) if (step.state === "running") this.finish(step, event.outcome !== "completed");
+        this.flush();
+        this.emit({ type: "end", outcome: event.outcome, endedAt: Date.now() });
+        this.reset();
+        return;
+      }
+      case "block_start":
+        this.blocks.set(event.key, this.add({ kind: event.kind, text: "", omitted: 0 }).id);
+        return;
+      case "block_delta": {
+        let id = this.blocks.get(event.key);
+        if (!id) {
+          id = this.add({ kind: event.kind, text: "", omitted: 0 }).id;
+          this.blocks.set(event.key, id);
+        }
+        const step = this.steps.get(id);
+        if (!step) return;
+        const text3 = (step.text ?? "") + event.delta, over = Math.max(0, text3.length - LIVE_TEXT);
+        step.text = text3.slice(over);
+        step.omitted = (step.omitted ?? 0) + over;
+        this.queue({ op: "text", id, append: event.delta });
+        return;
+      }
+      case "block_end": {
+        const step = this.steps.get(this.blocks.get(event.key) ?? "");
+        if (step) this.finish(step, false);
+        this.blocks.delete(event.key);
+        return;
+      }
+      case "tool_start":
+        this.add({ id: event.id, kind: "tool", parentId: event.parentId, tool: event.name, input: liveInput(event.name, event.args, this.chat) });
+        return;
+      case "tool_end": {
+        const step = this.steps.get(event.id);
+        if (!step) return;
+        step.output = liveOutput(event.output);
+        if (step.input?.action === "messages.send" && !event.failed) step.input.chat = sentChat(event.output, this.chat) ?? step.input.chat;
+        this.finish(step, event.failed);
+        return;
+      }
+      case "compaction_start":
+        this.compaction = this.add({ kind: "compaction" }).id;
+        return;
+      case "compaction_end": {
+        const step = this.steps.get(this.compaction ?? "");
+        this.compaction = null;
+        if (!step) return;
+        step.tokensBefore = event.tokensBefore;
+        step.tokensAfter = event.tokensAfter;
+        step.output = event.error ? liveOutput(event.error) : null;
+        this.finish(step, event.failed);
+        return;
+      }
+      case "retry_start": {
+        const previous = this.steps.get(this.retry ?? "");
+        if (previous?.state === "running") this.finish(previous, true);
+        this.retry = this.add({ kind: "retry", attempt: event.attempt, maxAttempts: event.maxAttempts, output: liveOutput(event.error) }).id;
+        return;
+      }
+      case "retry_end": {
+        const step = this.steps.get(this.retry ?? "");
+        this.retry = null;
+        if (step) {
+          if (event.error) step.output = liveOutput(event.error);
+          this.finish(step, event.failed);
+        }
+        return;
+      }
+    }
+  }
+  add(fields) {
+    const turn = this.turn;
+    if (turn.steps.length >= LIVE_STEPS) {
+      const index = Math.max(0, turn.steps.findIndex((step2) => step2.state !== "running")), [gone] = turn.steps.splice(index, 1);
+      this.steps.delete(gone.id);
+      turn.dropped++;
+      this.queue({ op: "drop", id: gone.id });
+    }
+    const step = { id: `s${++this.counter}`, state: "running", startedAt: Date.now(), endedAt: null, parentId: null, ...fields };
+    turn.steps.push(step);
+    this.steps.set(step.id, step);
+    this.queue({ op: "step", step: structuredClone(step) });
+    return step;
+  }
+  finish(step, failed) {
+    step.state = failed ? "failed" : "ok";
+    step.endedAt = Date.now();
+    this.queue({ op: "step", step: structuredClone(step) });
+  }
+  queue(patch) {
+    this.pending.push(patch);
+    this.timer ??= setTimeout(() => this.flush(), FLUSH_MS);
+  }
+  /** Sends the pending changes as one patch: text streamed into the same step is joined, and a step sent whole
+   * replaces what came before it for that step. A step is copied when it is queued, so text streamed after that
+   * follows it as its own patch. */
+  flush() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    if (!this.pending.length) return;
+    const patches = [];
+    for (const patch of this.pending) {
+      const last = patches.at(-1);
+      if (patch.op === "text" && last?.op === "text" && last.id === patch.id) {
+        last.append += patch.append;
+        continue;
+      }
+      if (patch.op === "step") {
+        for (let index = patches.length - 1; index >= 0; index--) {
+          const item = patches[index];
+          if ((item.op === "step" ? item.step.id : item.id) === patch.step.id) patches.splice(index, 1);
+        }
+        patches.push(patch);
+        continue;
+      }
+      patches.push({ ...patch });
+    }
+    this.pending = [];
+    this.emit({ type: "patch", patches });
+  }
+  emit(update) {
+    for (const listener of [...this.listeners.keys()]) {
+      try {
+        listener(update);
+      } catch (error) {
+        console.error("[live] listener failed", { error });
+      }
+    }
+  }
+  reset() {
+    this.turn = null;
+    this.steps.clear();
+    this.blocks.clear();
+    this.compaction = null;
+    this.retry = null;
+    this.counter = 0;
+    this.pending = [];
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+};
+
 // src/server/service/bot/service.ts
 var BotService = class {
   constructor(deps) {
     this.deps = deps;
   }
   bots = /* @__PURE__ */ new Map();
+  lives = /* @__PURE__ */ new Map();
   closed = false;
   started = false;
   get(id) {
     if (this.closed) throw new RuntimeFault("stopping", "Shutting down.", 503);
-    const record = this.deps.store.getBot(id);
-    if (!record) throw new RuntimeFault("bot_missing", "Bot not found", 404);
+    const record2 = this.deps.store.getBot(id);
+    if (!record2) throw new RuntimeFault("bot_missing", "Bot not found", 404);
     let bot = this.bots.get(id);
     if (bot) return bot;
-    const { store, chats, files, credentials } = this.deps;
+    const { store, chats, files, credentials } = this.deps, live = this.live(id);
     const runtime = new AgentRuntime(new BotInbox(id, store.runtime, chats, files), (setup, model, reference, activity) => (this.deps.factory ?? PiSession.create)({
       store,
-      bot: record,
+      bot: record2,
       selection: model.selection,
       reference,
       credentials,
       tools: setup.tools,
       systemPrompt: () => botPrompt(setup),
       onHistory: setup.onHistory,
-      activity
+      activity,
+      live: (event) => live.event(event)
     }));
-    const workspace = new Workspace(record.workspacePath);
-    const memory = new Memory(join6(dirname5(record.workspacePath), "history.db"));
+    const workspace = new Workspace(record2.workspacePath);
+    const memory = new Memory(join6(dirname5(record2.workspacePath), "history.db"));
     bot = new Bot(id, {
       identity: new Identity(id, store),
       model: new Model(id, store, resolveThinking),
@@ -5776,7 +6197,7 @@ var BotService = class {
       agentRuntime: runtime,
       state: new BotState(() => this.deps.changed(id))
     }, { deliver: async (message) => {
-      const outgoing = await files.readOutgoing(record.workspacePath, message.attachments ?? [], message.signal);
+      const outgoing = await files.readOutgoing(record2.workspacePath, message.attachments ?? [], message.signal);
       message.signal?.throwIfAborted();
       return chats.deliver(id, message.chatId, {
         content: message.content,
@@ -5792,23 +6213,40 @@ var BotService = class {
     this.bots.set(id, bot);
     return bot;
   }
-  details(record) {
-    const model = record.connectionId ? this.deps.store.getModelConnection(record.connectionId)?.models.find((model2) => model2.id === record.modelId) : void 0;
-    return { ...record, effectiveThinkingLevel: model ? resolveThinking(model, record.thinkingLevel) : null };
+  details(record2) {
+    const model = record2.connectionId ? this.deps.store.getModelConnection(record2.connectionId)?.models.find((model2) => model2.id === record2.modelId) : void 0;
+    return { ...record2, effectiveThinkingLevel: model ? resolveThinking(model, record2.thinkingLevel) : null };
   }
   owns(id) {
     return this.deps.store.getBot(id) !== null;
   }
+  /** The turn a Bot is running, live (A47); kept for a Bot whether or not it has started. */
+  live(id) {
+    if (!this.deps.store.getBot(id)) throw new RuntimeFault("bot_missing", "Bot not found", 404);
+    let live = this.lives.get(id);
+    if (!live) {
+      live = new LiveTurns((chatId) => this.liveChat(id, chatId));
+      this.lives.set(id, live);
+    }
+    return live;
+  }
+  /** A chat as the Bot sees it, for the live turn: a DM is named after the other member. */
+  liveChat(botId, chatId) {
+    const chat = this.deps.chats.get(botId, chatId);
+    if (!chat) return null;
+    const other = chat.type === "dm" ? chat.memberIds.find((member) => member !== botId) : void 0;
+    return { id: chat.id, type: chat.type, title: other ? this.deps.chats.member(other)?.name ?? chat.title : chat.title };
+  }
   list() {
-    return this.deps.store.listBots().map((record) => this.details(record));
+    return this.deps.store.listBots().map((record2) => this.details(record2));
   }
   create(name2) {
     return this.details(this.deps.store.createBot(name2));
   }
   describe(id) {
-    const record = this.deps.store.getBot(id);
-    if (!record) throw new RuntimeFault("bot_missing", "Bot not found", 404);
-    return this.details(record);
+    const record2 = this.deps.store.getBot(id);
+    if (!record2) throw new RuntimeFault("bot_missing", "Bot not found", 404);
+    return this.details(record2);
   }
   runs(id) {
     this.describe(id);
@@ -5856,15 +6294,15 @@ var BotService = class {
   /** Every Bot's run state, for `bots.list` (A43). A Bot not loaded in this process is stopped. */
   roster() {
     const { store } = this.deps;
-    return store.listBots().map((record) => {
-      const bot = this.bots.get(record.id), runId = bot?.agentRuntime.activeRunId ?? null;
+    return store.listBots().map((record2) => {
+      const bot = this.bots.get(record2.id), runId = bot?.agentRuntime.activeRunId ?? null;
       const status = bot?.status() ?? { status: "stop", activity: null, context: null, error: null };
       return {
-        id: record.id,
-        name: record.name,
+        id: record2.id,
+        name: record2.name,
         status,
         runChatIds: status.status === "running" && runId ? store.runtime.inputs(runId).map((input) => input.chatId) : [],
-        errorCode: store.runtime.latestErrorCode(record.id)
+        errorCode: store.runtime.latestErrorCode(record2.id)
       };
     });
   }
@@ -5895,6 +6333,8 @@ var BotService = class {
     const bot = this.get(id), workspacePath = bot.workspace.location().cwd;
     await bot.stop();
     this.bots.delete(id);
+    this.lives.get(id)?.close();
+    this.lives.delete(id);
     if (!this.deps.store.deleteBot(id)) throw new RuntimeFault("bot_missing", "Bot not found", 404);
     if (!keepFiles) await rm2(dirname5(workspacePath), { recursive: true, force: true });
   }
@@ -5902,6 +6342,7 @@ var BotService = class {
     if (this.closed) return;
     this.closed = true;
     await Promise.all([...this.bots.values()].map((bot) => bot.stop()));
+    for (const live of this.lives.values()) live.close();
   }
 };
 
@@ -6003,8 +6444,8 @@ import { join as join8, resolve as resolve5 } from "node:path";
 var pidPath = (dir) => join8(resolve5(dir), "jarvy.pid");
 var logPath = (dir) => join8(resolve5(dir), "jarvy.log");
 function writePidFile(dir, url) {
-  const record = { pid: process.pid, startToken: startToken(process.pid), url, startedAt: Date.now() };
-  writeFileSync(pidPath(dir), JSON.stringify(record), { mode: 384 });
+  const record2 = { pid: process.pid, startToken: startToken(process.pid), url, startedAt: Date.now() };
+  writeFileSync(pidPath(dir), JSON.stringify(record2), { mode: 384 });
 }
 function removePidFile(dir) {
   if (readRecord(dir)?.pid === process.pid) rmSync(pidPath(dir), { force: true });
@@ -6032,14 +6473,14 @@ function alive(pid) {
   }
 }
 function runningServer(dir) {
-  const record = readRecord(dir);
-  if (!record) return null;
-  const token = alive(record.pid) ? startToken(record.pid) : null;
-  if (token === null || token && record.startToken && token !== record.startToken) {
+  const record2 = readRecord(dir);
+  if (!record2) return null;
+  const token = alive(record2.pid) ? startToken(record2.pid) : null;
+  if (token === null || token && record2.startToken && token !== record2.startToken) {
     rmSync(pidPath(dir), { force: true });
     return null;
   }
-  return record;
+  return record2;
 }
 function startBackground(script, runArgs, dir) {
   mkdirSync3(resolve5(dir), { recursive: true, mode: 448 });
@@ -6072,11 +6513,11 @@ function signalReady(url) {
   process.disconnect();
 }
 async function stopServer(dir, waitMs = 3e4) {
-  const record = runningServer(dir);
-  if (!record) return "not_running";
-  process.kill(record.pid, "SIGTERM");
+  const record2 = runningServer(dir);
+  if (!record2) return "not_running";
+  process.kill(record2.pid, "SIGTERM");
   for (const deadline = Date.now() + waitMs; Date.now() < deadline; ) {
-    if (!alive(record.pid)) {
+    if (!alive(record2.pid)) {
       rmSync(pidPath(dir), { force: true });
       return "stopped";
     }