@goodfish/jarvy 0.3.0 → 0.5.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));
@@ -446,10 +466,10 @@ function chatRoutes({ chats, bots }) {
       const page = chats.readBefore(c.get("actorId"), c.req.param("id"), before === void 0 ? null : Number(before), Number(tail ?? c.req.query("limit") ?? 50));
       return c.json({ messages: page.messages.map(messageView), hasOlder: page.hasOlder });
     }
-    const after = Number(c.req.query("after") ?? 0);
+    const after2 = Number(c.req.query("after") ?? 0);
     const limit = Number(c.req.query("limit") ?? 1e3);
-    const messages = chats.read(c.get("actorId"), c.req.param("id"), after, limit);
-    return c.json({ messages: messages.map(messageView), nextSequence: messages.at(-1)?.sequence ?? after, hasMore: messages.length === limit });
+    const messages = chats.read(c.get("actorId"), c.req.param("id"), after2, limit);
+    return c.json({ messages: messages.map(messageView), nextSequence: messages.at(-1)?.sequence ?? after2, hasMore: messages.length === limit });
   });
   routes.post("/:id/messages", jsonBody, async (c) => {
     const message = await chats.send(c.get("actorId"), c.req.param("id"), await readJson(c));
@@ -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"));
@@ -579,6 +607,7 @@ data: ${JSON.stringify(data)}
           if (change.kind === "sections" && change.ownerId === actorId) send("sections", {});
           if (change.kind === "inbox" && change.memberId === actorId) send("inbox", {});
           if (change.kind === "bot" && bots.owns(change.id)) send("bot", { botId: change.id, status: botStatusView(change.status) });
+          if (change.kind === "bots") send("bots", {});
         }, () => disconnect());
         const heartbeat = setInterval(() => {
           if (!account.authenticated(token)) disconnect();
@@ -685,12 +714,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 +784,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" });
   });
@@ -724,9 +810,10 @@ function createJarvyServer(services, webRoot) {
 
 // src/server/shared/models.ts
 var BOT_COLORS = ["gray", "blue", "green", "amber", "rose", "violet"];
+var AGENT_BOT_ID = "00000000-0000-4000-8000-000000000001";
 
 // src/server/infra/storage/store.ts
-import { createHash, randomBytes, randomInt as randomInt2, randomUUID as randomUUID7, scryptSync, timingSafeEqual } from "node:crypto";
+import { createHash, randomBytes, randomInt as randomInt3, randomUUID as randomUUID7, scryptSync, timingSafeEqual } from "node:crypto";
 import { chmodSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
@@ -998,12 +1085,49 @@ function migrateTitles(db) {
   }
 }
 
+// src/server/infra/storage/migrations/agent-schema.ts
+function migrateAgent(db) {
+  const version = db.prepare("PRAGMA user_version").get().user_version;
+  if (version >= 19) return;
+  db.exec("PRAGMA foreign_keys=OFF; BEGIN IMMEDIATE");
+  try {
+    const sequence = db.prepare("SELECT seq FROM sqlite_sequence WHERE name='inbox'").get()?.seq ?? 0;
+    db.exec(`
+      CREATE TABLE settings(key TEXT PRIMARY KEY, value TEXT NOT NULL);
+      CREATE TABLE inbox_next(id INTEGER PRIMARY KEY AUTOINCREMENT, member_id TEXT NOT NULL REFERENCES members(id),
+        kind TEXT NOT NULL CHECK(kind IN ('message','reaction','note','onboard','change')), reason TEXT NOT NULL,
+        urgency TEXT NOT NULL CHECK(urgency IN ('interrupt','queue','digest')),
+        chat_id TEXT NOT NULL REFERENCES chats(id) ON DELETE CASCADE, message_id TEXT REFERENCES messages(id) ON DELETE CASCADE,
+        actor_id TEXT REFERENCES members(id), detail TEXT,
+        state TEXT NOT NULL DEFAULT 'pending' CHECK(state IN ('pending','claimed','told','done','failed','interrupted','unknown','cancelled')),
+        run_id TEXT REFERENCES bot_runs(id), created_at INTEGER NOT NULL, told_at INTEGER);
+      INSERT INTO inbox_next(id,member_id,kind,reason,urgency,chat_id,message_id,actor_id,detail,state,run_id,created_at,told_at)
+        SELECT id,member_id,kind,reason,urgency,chat_id,message_id,actor_id,detail,state,run_id,created_at,told_at FROM inbox ORDER BY id;
+      DROP TABLE inbox;
+      ALTER TABLE inbox_next RENAME TO inbox;
+      CREATE UNIQUE INDEX inbox_one_message ON inbox(member_id, message_id) WHERE kind='message';
+      CREATE INDEX inbox_open ON inbox(member_id, state, id);
+      CREATE INDEX inbox_run ON inbox(run_id) WHERE run_id IS NOT NULL;
+    `);
+    db.prepare("UPDATE sqlite_sequence SET seq=MAX(seq,?) WHERE name='inbox'").run(sequence);
+    db.prepare(`INSERT INTO settings(key,value) SELECT 'agent_onboarded',? FROM bots
+      WHERE id=? AND deleted_at IS NULL AND connection_id IS NOT NULL`).run(String(Date.now()), AGENT_BOT_ID);
+    db.exec("PRAGMA user_version=19");
+    if (db.prepare("PRAGMA foreign_key_check").all().length) throw new Error("Migration has invalid references");
+    db.exec("COMMIT");
+  } catch (error) {
+    db.exec("ROLLBACK");
+    throw error;
+  } finally {
+    db.exec("PRAGMA foreign_keys=ON");
+  }
+}
+
 // src/server/infra/storage/migrations/schema.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 
 // src/server/infra/storage/migrations/prototype-schema.ts
 import { randomUUID } from "node:crypto";
-var DEFAULT_BOT_ID = "00000000-0000-4000-8000-000000000001";
 function migratePrototype(db) {
   const version = db.prepare("PRAGMA user_version").get().user_version;
   if (version >= 4) return;
@@ -1036,9 +1160,9 @@ function migratePrototype(db) {
           system_prompt TEXT NOT NULL, model_id TEXT NOT NULL, avatar_mime TEXT, avatar_data BLOB,
           avatar_updated_at INTEGER NOT NULL DEFAULT 0, created_at INTEGER NOT NULL);
         INSERT INTO bots(id,name,description,system_prompt,model_id,created_at)
-          SELECT '${DEFAULT_BOT_ID}',name,'',system_prompt,'',0 FROM bot_settings WHERE id=1;
+          SELECT '${AGENT_BOT_ID}',name,'',system_prompt,'',0 FROM bot_settings WHERE id=1;
         ALTER TABLE chats ADD COLUMN bot_id TEXT REFERENCES bots(id);
-        UPDATE chats SET bot_id='${DEFAULT_BOT_ID}';
+        UPDATE chats SET bot_id='${AGENT_BOT_ID}';
         CREATE INDEX chat_by_bot ON chats(bot_id,updated_at DESC);
         CREATE TABLE attachments (id TEXT PRIMARY KEY, chat_id TEXT NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
           message_id TEXT REFERENCES messages(id) ON DELETE CASCADE, name TEXT NOT NULL,
@@ -1121,7 +1245,7 @@ function migrateRuntime(db) {
 // src/server/infra/storage/migrations/schema.ts
 function migrateDatabase(db) {
   const version = db.prepare("PRAGMA user_version").get().user_version;
-  if (version > 18) throw new Error(`Unsupported database version: ${version}`);
+  if (version > 19) throw new Error(`Unsupported database version: ${version}`);
   migratePrototype(db);
   if (version >= 5) {
     migrateRuntime(db);
@@ -1137,6 +1261,7 @@ function migrateDatabase(db) {
     migrateInbox(db);
     migrateQuotes(db);
     migrateTitles(db);
+    migrateAgent(db);
     return;
   }
   db.exec("PRAGMA foreign_keys=OFF; BEGIN IMMEDIATE");
@@ -1210,6 +1335,7 @@ function migrateDatabase(db) {
   migrateInbox(db);
   migrateQuotes(db);
   migrateTitles(db);
+  migrateAgent(db);
 }
 
 // src/server/infra/storage/chat-repository.ts
@@ -1533,7 +1659,7 @@ var InteractionRepository = class {
   }
   /** Notices the Bot has not been told, oldest first, in chats it can still read. */
   notices(botId) {
-    const rows2 = this.db.prepare(`SELECT n.id,n.kind,n.chat_id AS chatId,c.title AS chatTitle,c.type AS chatType,n.message_id AS messageId,n.actor_id AS actorId,n.detail,n.created_at AS createdAt
+    const rows2 = this.db.prepare(`SELECT n.id,n.kind,n.urgency,n.chat_id AS chatId,c.title AS chatTitle,c.type AS chatType,n.message_id AS messageId,n.actor_id AS actorId,n.detail,n.created_at AS createdAt
       FROM inbox n JOIN chats c ON c.id=n.chat_id WHERE n.member_id=? AND n.kind<>'message' AND n.state='pending' ORDER BY n.id`).all(botId);
     return rows2.filter((row) => this.chats.canAccess(botId, row.chatId)).map(({ actorId, ...row }) => ({ ...row, actor: this.chats.member(actorId) }));
   }
@@ -1763,9 +1889,9 @@ var ChatRepository = class {
       AND (instr(lower(c.title),lower(?))>0 OR instr(lower(c.topic),lower(?))>0 OR instr(lower(COALESCE(n.text,'')),lower(?))>0)
       ORDER BY c.updated_at DESC LIMIT ?`).all(actorId, query, query, query, limit).map((row) => row.id);
   }
-  messages(actorId, chatId, after = 0, limit = 1e3) {
+  messages(actorId, chatId, after2 = 0, limit = 1e3) {
     this.assertAccess(actorId, chatId);
-    const rows2 = this.db.prepare(`SELECT ${MESSAGE_COLUMNS} FROM messages WHERE chat_id=? AND sequence>? ORDER BY sequence LIMIT ?`).all(chatId, after, limit);
+    const rows2 = this.db.prepare(`SELECT ${MESSAGE_COLUMNS} FROM messages WHERE chat_id=? AND sequence>? ORDER BY sequence LIMIT ?`).all(chatId, after2, limit);
     return rows2.map((row) => this.messageFromRow(row));
   }
   message(actorId, id) {
@@ -2106,6 +2232,47 @@ var CredentialRepository = class {
   }
 };
 
+// src/server/infra/storage/agent-repository.ts
+import { randomInt as randomInt2 } from "node:crypto";
+var AgentRepository = class {
+  constructor(db, ownerId) {
+    this.db = db;
+    this.ownerId = ownerId;
+  }
+  /** Brings the agent Bot back when it is missing (deleted before it became undeletable): the same id, the first free
+   * name of Jarvy, Jarvy 2, …, no persona and no model, so the owner picks one and is welcomed again. */
+  ensure() {
+    const row = this.db.prepare("SELECT deleted_at AS deletedAt FROM bots WHERE id=?").get(AGENT_BOT_ID);
+    if (row && row.deletedAt === null) return;
+    const taken = this.db.prepare(`SELECT 1 FROM account WHERE lower(username)=lower(:name)
+      UNION ALL SELECT 1 FROM bots WHERE lower(name)=lower(:name) AND deleted_at IS NULL LIMIT 1`);
+    let name2 = "Jarvy";
+    for (let n = 2; taken.get({ name: name2 }); n++) name2 = `Jarvy ${n}`;
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      if (row) this.db.prepare(`UPDATE bots SET deleted_at=NULL,name=?,description='',system_prompt='',connection_id=NULL,model_id='',thinking_level='auto'
+        WHERE id=?`).run(name2, AGENT_BOT_ID);
+      else {
+        this.db.prepare("INSERT OR IGNORE INTO members VALUES(?,'bot')").run(AGENT_BOT_ID);
+        this.db.prepare("INSERT INTO bots(id,name,description,system_prompt,model_id,created_at,owner_id,thinking_level,color) VALUES(?,?,'','','',?,?,'auto',?)").run(AGENT_BOT_ID, name2, Date.now(), this.ownerId(), BOT_COLORS[randomInt2(BOT_COLORS.length)]);
+      }
+      this.db.prepare("DELETE FROM settings WHERE key='agent_onboarded'").run();
+      this.db.exec("COMMIT");
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  /** Records that the owner is being welcomed; false when that already happened, so only one caller asks. */
+  markOnboarded() {
+    return Number(this.db.prepare("INSERT OR IGNORE INTO settings(key,value) VALUES('agent_onboarded',?)").run(String(Date.now())).changes) > 0;
+  }
+  /** One delivery about no message, for one Bot; the caller wakes it. */
+  notify(input) {
+    this.db.prepare("INSERT INTO inbox(member_id,kind,reason,urgency,chat_id,actor_id,detail,created_at) VALUES(?,?,?,?,?,?,?,?)").run(input.botId, input.kind, input.reason, input.urgency, input.chatId, input.actorId, input.detail, Date.now());
+  }
+};
+
 // src/server/infra/storage/store.ts
 var defaultDataDir = () => process.env.JARVY_DATA_DIR || join(homedir(), ".jarvy");
 var DATABASE_FILENAME = "jarvy.db";
@@ -2175,6 +2342,7 @@ var Store = class {
   chats;
   runtime;
   credentials;
+  agent;
   constructor(dataDir = defaultDataDir()) {
     const root = resolve(dataDir);
     mkdirSync(root, { recursive: true, mode: 448 });
@@ -2191,6 +2359,8 @@ var Store = class {
     this.chats = new ChatRepository(this.db);
     this.runtime = new RuntimeRepository(this.db);
     this.credentials = new CredentialRepository(this.db);
+    this.agent = new AgentRepository(this.db, () => this.userMemberId());
+    this.agent.ensure();
   }
   close() {
     this.db.close();
@@ -2295,7 +2465,7 @@ var Store = class {
     this.db.exec("BEGIN IMMEDIATE");
     try {
       this.db.prepare("INSERT INTO members VALUES(?,'bot')").run(id);
-      this.db.prepare("INSERT INTO bots(id,name,description,system_prompt,model_id,created_at,owner_id,thinking_level,color) VALUES(?,?,?,?,?,?,?,'auto',?)").run(id, clean, "", "", "", createdAt, this.userMemberId(), BOT_COLORS[randomInt2(BOT_COLORS.length)]);
+      this.db.prepare("INSERT INTO bots(id,name,description,system_prompt,model_id,created_at,owner_id,thinking_level,color) VALUES(?,?,?,?,?,?,?,'auto',?)").run(id, clean, "", "", "", createdAt, this.userMemberId(), BOT_COLORS[randomInt3(BOT_COLORS.length)]);
       this.db.exec("COMMIT");
     } catch (error) {
       this.db.exec("ROLLBACK");
@@ -2699,8 +2869,8 @@ function candidates(query) {
   const q = query.trim().toLowerCase();
   if (!q) return [];
   const all = catalog();
-  const same2 = all.filter((row) => row.model.id.toLowerCase() === q || strip(row.model.id) === strip(q));
-  return same2.length ? same2 : all.filter((row) => row.model.id.toLowerCase().includes(strip(q)));
+  const same3 = all.filter((row) => row.model.id.toLowerCase() === q || strip(row.model.id) === strip(q));
+  return same3.length ? same3 : all.filter((row) => row.model.id.toLowerCase().includes(strip(q)));
 }
 function similar(query) {
   const q = strip(query);
@@ -3092,14 +3262,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" }] : [];
@@ -3115,7 +3285,11 @@ var POLICY = {
   // Marks on your messages are queued: they wake you but never interrupt (A39).
   reaction: { author: "queue" },
   // A new version of a notice or summary is queued like a mark.
-  note: { member: "queue", follower: "queue" }
+  note: { member: "queue", follower: "queue" },
+  // The owner just gave the agent Bot its first model: it should welcome them now (A48).
+  onboard: { setup: "interrupt" },
+  // What the agent Bot changed about a Bot rides along with that Bot's next batch, without waking it.
+  change: { agent: "digest" }
 };
 function urgencyOf(kind, reason) {
   return POLICY[kind][reason];
@@ -3126,9 +3300,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 {
@@ -3279,8 +3453,8 @@ var ChatMessages = class {
     const message = this.repository.message(this.actor, id);
     return message?.chatId === this.id ? message : null;
   }
-  async list({ after = 0, limit }) {
-    return this.repository.messages(this.actor, this.id, after, limit);
+  async list({ after: after2 = 0, limit }) {
+    return this.repository.messages(this.actor, this.id, after2, limit);
   }
   async search(query, { limit }) {
     return this.repository.search(this.actor, this.id, query, limit);
@@ -3650,9 +3824,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;
   }
@@ -3750,10 +3924,10 @@ var ChatService = class {
     const messages = this.repository.messagesBefore(actorId, chatId, before ?? Number.MAX_SAFE_INTEGER, limit + 1);
     return { messages: messages.slice(-limit), hasOlder: messages.length > limit };
   }
-  read(actorId, chatId, after = 0, limit = 1e3) {
-    if (!Number.isSafeInteger(after) || after < 0 || !Number.isSafeInteger(limit) || limit < 1 || limit > 1e3)
+  read(actorId, chatId, after2 = 0, limit = 1e3) {
+    if (!Number.isSafeInteger(after2) || after2 < 0 || !Number.isSafeInteger(limit) || limit < 1 || limit > 1e3)
       throw new ChatError(400, "Invalid message cursor or limit");
-    return this.repository.messages(actorId, chatId, after, limit);
+    return this.repository.messages(actorId, chatId, after2, limit);
   }
   instance(actorId, chatId) {
     this.repository.assertAccess(actorId, chatId);
@@ -3964,8 +4138,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 +4295,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 +4370,7 @@ var PiSession = class _PiSession {
     this.credentials = credentials;
   }
   session;
+  settings;
   unsubscribe;
   unsubscribeHistory;
   promptActive = false;
@@ -4140,6 +4382,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 +4428,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 +4471,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 +4485,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 +4528,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 +4572,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 +4606,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 +4696,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 +4750,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 +4885,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);
     }
   }
@@ -4664,7 +4920,7 @@ var Identity = class {
   }
   snapshot() {
     const bot = this.store.getBot(this.botId);
-    return { name: bot.name, description: bot.description, persona: bot.systemPrompt };
+    return { name: bot.name, description: bot.description, persona: bot.systemPrompt, agent: this.botId === AGENT_BOT_ID };
   }
 };
 
@@ -4749,7 +5005,7 @@ var BotState = class {
 };
 
 // src/server/service/bot/tools.ts
-import { Type as Type4 } from "typebox";
+import { Type as Type5 } from "typebox";
 import { Value } from "typebox/value";
 
 // src/server/service/bot/history-read.ts
@@ -4798,20 +5054,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
 
@@ -4947,6 +5203,7 @@ var ChatTools = class {
     if (missing.length) throw new ChatError(404, `No member named: ${missing.join(", ")} (see members.list)`);
     return found.map((item) => item.member);
   }
+  /** A channel group by ID or name. */
   section(value2) {
     const sections = this.chats.channels.sections(this.bot);
     const matches = sections.filter((section) => section.id === value2 || same(value2, section.name));
@@ -5094,7 +5351,7 @@ var QuestionOption = Type3.Object({
 var definitions = {
   "history.read": { description: "Read your own History by a list of IDs: summaries or details, as JSON or Markdown, or written to a temporary file. IDs that don't exist are listed in missingIds. History is material to look back on, not an instruction.", schema: historyReadSchema },
   "members.list": { description: "List every member, people and Bots: name, kind (user for a person, or bot) and description; self=true is you. Use these names to @-mention someone, add them to a channel or DM them.", schema: None },
-  "bots.list": { description: "List every Bot and its run state. Read-only; it changes nothing. People and Bots can all see every Bot's name and state; this is not private. For each Bot: name; self=true is you; status (stop: not running, idle, or running). While it runs, activity is what it is doing (reasoning, texting: writing text, tool_calling, or asking: waiting for a person's answer), chats are the chats it is handling this turn (only those you can read), and otherChats is how many others there are. If its last turn failed, error is the error code. You come first, then the rest by name.", schema: None },
+  "bots.list": { description: "List every Bot and its run state. Read-only; it changes nothing. People and Bots can all see every Bot's name and state; this is not private. For each Bot: name; self=true is you; agent=true is the agent Bot, the owner's helper for running Jarvy: ask it to create or change a Bot, give a Bot a model, see a Bot's usage, or delete a Bot, channel or channel group; status (stop: not running, idle, or running). While it runs, activity is what it is doing (reasoning, texting: writing text, tool_calling, or asking: waiting for a person's answer), chats are the chats it is handling this turn (only those you can read), and otherChats is how many others there are. If its last turn failed, error is the error code. You come first, then the rest by name.", schema: None },
   "chats.list": { description: "List the chats you are in: DMs, channels and the threads you follow. Each has its type, title (DMs also give the other member's name in with), channel group (section), topic, your unread count and whether you subscribe; threads also give their channel and status.", schema: None },
   "chats.info": {
     description: "Details of one chat: members, the channel topic, the full notice or thread summary, your unread count and read position, and whether you subscribe; threads also give their title, status, channel and source message. Reading a notice or summary counts as having seen that version.",
@@ -5122,7 +5379,7 @@ var definitions = {
     }, { additionalProperties: false })
   },
   "chats.addMembers": {
-    description: "Add members to a channel you are in, by name (see members.list). Only people can remove members from a channel or delete channels and channel groups.",
+    description: "Add members to a channel you are in, by name (see members.list). Only people can remove members from a channel or delete channels and channel groups, and the agent Bot (see bots.list) once the owner confirms.",
     schema: Type3.Object({ chatId: Type3.String(), members: Type3.Array(Type3.String({ minLength: 1, maxLength: 80 }), { minItems: 1, maxItems: 50 }) }, { additionalProperties: false })
   },
   "chats.subscribe": {
@@ -5201,6 +5458,7 @@ function botRows(chats, viewerId, entries) {
     return { self: entry.id === viewerId, row: {
       name: entry.name,
       ...entry.id === viewerId ? { self: true } : {},
+      ...entry.agent ? { agent: true } : {},
       status: entry.status.status,
       ...running && entry.status.activity ? { activity: entry.status.activity } : {},
       ...visible.length ? { chats: visible } : {},
@@ -5212,19 +5470,177 @@ function botRows(chats, viewerId, entries) {
   return rows2.map((item) => item.row);
 }
 
+// src/server/service/bot/agent-tools.ts
+var AgentTools = class {
+  constructor(scope) {
+    this.scope = scope;
+  }
+  get ops() {
+    return this.scope.ops;
+  }
+  async confirmed(input, ask) {
+    const chat = this.scope.tools.chat(input.askIn);
+    if (!chat.memberIds.includes(this.ops.owner)) throw new ChatError(400, "The owner is not in askIn; use a chat they are in, such as your DM with them");
+    const answer = await ask(chat.id, {
+      question: input.question,
+      multiple: false,
+      allowCustom: false,
+      options: [{ label: input.confirm, value: "confirm", style: "danger" }, { label: input.cancel, value: "cancel" }]
+    });
+    if (answer.status === "dismissed") return { deleted: false, answer: "dismissed" };
+    return answer.selected[0]?.value === "confirm" ? null : { deleted: false, answer: "cancelled" };
+  }
+  channel(chatId) {
+    const chat = this.scope.tools.chat(chatId);
+    if (chat.type !== "channel") throw new ChatError(400, "Not a channel");
+    return chat;
+  }
+  async call(name2, args, ask) {
+    switch (name2) {
+      case "models.list":
+        return this.ops.models();
+      case "bots.create": {
+        const bot = await this.ops.create(args);
+        return { name: bot.name, model: bot.connectionId ? this.ops.modelLabel(bot) : null, thinking: bot.thinkingLevel };
+      }
+      case "bots.update": {
+        const { bot, ...settings } = args;
+        const result = await this.ops.update(this.ops.bot(bot), settings);
+        return { name: result.bot.name, changed: result.changed };
+      }
+      case "bots.start":
+      case "bots.stop": {
+        const bot = this.ops.bot(args.bot);
+        return { name: bot.name, status: await this.ops.run(bot, name2 === "bots.start" ? "start" : "stop") };
+      }
+      case "bots.usage": {
+        const input = args, bot = this.ops.bot(input.bot);
+        return { name: bot.name, ...this.ops.usage(bot, input.days ?? 7) };
+      }
+      case "bots.delete": {
+        const input = args, bot = this.ops.bot(input.bot);
+        if (bot.id === this.ops.agentId) throw new ChatError(400, "You can't delete yourself");
+        const declined = await this.confirmed(input, ask);
+        if (declined) return declined;
+        await this.ops.deleteBot(this.ops.bot(input.bot));
+        return { deleted: true, name: bot.name };
+      }
+      case "chats.delete": {
+        const input = args, chat = this.channel(input.chatId);
+        const declined = await this.confirmed(input, ask);
+        if (declined) return declined;
+        await this.ops.deleteChannel(chat.id);
+        return { deleted: true, name: chat.title };
+      }
+      case "chats.removeMembers": {
+        const input = args, chat = this.channel(input.chatId);
+        const members = this.scope.tools.members(input.members).filter((member) => chat.memberIds.includes(member.id));
+        if (!members.length) throw new ChatError(400, "None of them is in this channel");
+        const declined = await this.confirmed(input, ask);
+        if (declined) return { removed: [], answer: declined.answer };
+        for (const member of members) this.ops.removeMember(chat.id, member.id);
+        return { removed: members.map((member) => member.name) };
+      }
+      case "sections.delete": {
+        const input = args, section = this.scope.tools.section(input.section);
+        const declined = await this.confirmed(input, ask);
+        if (declined) return declined;
+        this.ops.deleteSection(section);
+        return { deleted: true };
+      }
+    }
+  }
+};
+
+// src/server/service/bot/agent-schemas.ts
+import { Type as Type4 } from "typebox";
+var None2 = Type4.Object({}, { additionalProperties: false });
+var Name2 = Type4.String({ minLength: 1, maxLength: 80, description: "Unique among all members, people and Bots" });
+var BotName = Type4.String({ minLength: 1, maxLength: 80, description: "The Bot's name, as bots.list shows it" });
+var Model2 = Type4.Object({
+  connection: Type4.String({ minLength: 1, maxLength: 200, description: "A connection's name or ID from models.list" }),
+  model: Type4.String({ minLength: 1, maxLength: 200, description: "A model's ID or name in that connection" })
+}, { additionalProperties: false });
+var Thinking = Type4.Union(
+  ["auto", "off", "minimal", "low", "medium", "high", "xhigh", "max"].map((level) => Type4.Literal(level)),
+  { description: "How much the model thinks; auto lets Jarvy choose. models.list gives the levels each model has" }
+);
+var Settings = {
+  description: Type4.Optional(Type4.String({ maxLength: 1e3, description: "One line that other members see in members.list" })),
+  persona: Type4.Optional(Type4.String({ maxLength: 16e3, description: "Its standing instructions: who it is and how it works (the Persona section of its prompt)" })),
+  model: Type4.Optional(Model2),
+  thinking: Type4.Optional(Thinking)
+};
+var Confirm = {
+  askIn: Type4.String({ description: "ID of a chat the owner is in, where the confirmation card goes; usually the chat you were asked in" }),
+  question: Type4.String({ minLength: 1, maxLength: 500, description: "The card's question, in the owner's language: what will be deleted and what goes with it" }),
+  confirm: Type4.String({ minLength: 1, maxLength: 40, description: "Label of the button that deletes, in the owner's language" }),
+  cancel: Type4.String({ minLength: 1, maxLength: 40, description: "Label of the button that keeps everything, in the owner's language" })
+};
+var after = "The owner first gets a card in askIn, and nothing is deleted unless they confirm; the result says what they chose.";
+var agentDefinitions = {
+  "models.list": { description: "List the models you can give a Bot: each connection with its models and their thinking levels. Only the owner adds connections, keys and logins, in Settings.", schema: None2 },
+  "bots.create": {
+    description: "Create a Bot. Give it a model so it can work; without one it waits until it gets one. It starts when a message first arrives for it. bots.update changes everything later.",
+    schema: Type4.Object({ name: Name2, ...Settings }, { additionalProperties: false })
+  },
+  "bots.update": {
+    description: "Change a Bot's name, description, persona, model or thinking; give only what changes. Works for any Bot, yourself included. The Bot is told what changed with its next batch, in its DM with you.",
+    schema: Type4.Object({ bot: BotName, name: Type4.Optional(Name2), ...Settings }, { additionalProperties: false })
+  },
+  "bots.start": { description: "Start a stopped Bot. A stopped Bot also starts by itself when a message arrives for it.", schema: Type4.Object({ bot: BotName }, { additionalProperties: false }) },
+  "bots.stop": { description: "Stop a Bot (not yourself): its current turn ends, and it stays stopped until it is started or a message arrives for it.", schema: Type4.Object({ bot: BotName }, { additionalProperties: false }) },
+  "bots.usage": {
+    description: "A Bot's token use and cost over the last days (7 by default), per model.",
+    schema: Type4.Object({ bot: BotName, days: Type4.Optional(Type4.Integer({ minimum: 1, maximum: 365 })) }, { additionalProperties: false })
+  },
+  "bots.delete": {
+    description: `Delete a Bot (not yourself). ${after} Its DMs and channel memberships go; its messages in channels and its workspace stay.`,
+    schema: Type4.Object({ bot: BotName, ...Confirm }, { additionalProperties: false })
+  },
+  "chats.delete": {
+    description: `Delete a channel you are in, with its threads, messages and files. ${after}`,
+    schema: Type4.Object({ chatId: Type4.String({ description: "Channel ID" }), ...Confirm }, { additionalProperties: false })
+  },
+  "chats.removeMembers": {
+    description: `Remove members from a channel you are in, by name (see members.list). ${after}`,
+    schema: Type4.Object({ chatId: Type4.String({ description: "Channel ID" }), members: Type4.Array(Type4.String({ minLength: 1, maxLength: 80 }), { minItems: 1, maxItems: 50 }), ...Confirm }, { additionalProperties: false })
+  },
+  "sections.delete": {
+    description: `Delete a channel group; its channels stay, outside any group. ${after}`,
+    schema: Type4.Object({ section: Type4.String({ minLength: 1, maxLength: 80, description: "The group's name or ID (see sections.list)" }), ...Confirm }, { additionalProperties: false })
+  }
+};
+
 // src/server/service/bot/tools.ts
-var Gateway = Type4.Object({
-  action: Type4.Union([Type4.Literal("list"), Type4.Literal("describe"), Type4.Literal("call")]),
-  tool: Type4.Optional(Type4.String()),
-  args: Type4.Optional(Type4.Record(Type4.String(), Type4.Unknown()))
+var Gateway = Type5.Object({
+  action: Type5.Union([Type5.Literal("list"), Type5.Literal("describe"), Type5.Literal("call")]),
+  tool: Type5.Optional(Type5.String()),
+  args: Type5.Optional(Type5.Record(Type5.String(), Type5.Unknown()))
 }, { additionalProperties: false });
 var Tools = class {
   constructor(scope) {
     this.scope = scope;
     this.tools = new ChatTools(scope);
+    if (scope.agent) this.agent = new AgentTools({ ops: scope.agent, tools: this.tools });
   }
   send;
   tools;
+  /** The agent Bot's own tools (A48); other Bots have none. */
+  agent;
+  get catalog() {
+    return this.agent ? { ...definitions, ...agentDefinitions } : definitions;
+  }
+  /** Posts a card and waits for the person's answer (messages.ask, and the agent's confirmations). */
+  async ask(chatId, question, toolCallId, signal) {
+    const sent = await this.send(chatId, { content: question.question, question, toolCallId, signal });
+    this.scope.asking?.(true);
+    try {
+      return { messageId: sent.id, ...await this.scope.chats.questions.wait(this.scope.chats.message(this.scope.botId, sent.id), signal) };
+    } finally {
+      if (!signal?.aborted) this.scope.asking?.(false);
+    }
+  }
   bindSend(send) {
     this.send = send;
   }
@@ -5238,16 +5654,18 @@ var Tools = class {
         signal?.throwIfAborted();
         if (raw.action === "list") {
           if (raw.tool !== void 0 || raw.args !== void 0) throw new ChatError(400, "list does not accept tool or args");
-          return Object.entries(definitions).map(([name3, tool]) => ({ name: name3, description: tool.description }));
+          return Object.entries(this.catalog).map(([name3, tool]) => ({ name: name3, description: tool.description }));
         }
-        if (!raw.tool || !Object.hasOwn(definitions, raw.tool)) throw new ChatError(400, "Unknown chat tool; use list first");
-        const name2 = raw.tool, definition = definitions[name2];
+        if (!raw.tool || !Object.hasOwn(this.catalog, raw.tool)) throw new ChatError(400, "Unknown chat tool; use list first");
+        const name2 = raw.tool, definition = this.catalog[name2];
         if (raw.action === "describe") {
           if (raw.args !== void 0) throw new ChatError(400, "describe does not accept args");
           return { name: name2, description: definition.description, parameters: definition.schema };
         }
         const args = raw.args;
         if (!args || !Value.Check(definition.schema, args)) throw new ChatError(400, "Invalid tool arguments; use describe for the parameter schema");
+        if (this.agent && Object.hasOwn(agentDefinitions, name2))
+          return this.agent.call(name2, args, (chatId, question) => this.ask(chatId, question, toolCallId, signal));
         switch (name2) {
           case "history.read":
             return readHistory(this.scope.memory, this.scope.workspace, args, signal);
@@ -5337,13 +5755,7 @@ var Tools = class {
               multiple: parsed.multiple === true,
               allowCustom: parsed.allowCustom === true
             };
-            const sent = await this.send(parsed.chatId, { content: parsed.question, question, toolCallId, signal });
-            this.scope.asking?.(true);
-            try {
-              return { messageId: sent.id, ...await this.scope.chats.questions.wait(this.scope.chats.message(this.scope.botId, sent.id), signal) };
-            } finally {
-              if (!signal?.aborted) this.scope.asking?.(false);
-            }
+            return this.ask(parsed.chatId, question, toolCallId, signal);
           }
         }
       }
@@ -5356,6 +5768,12 @@ import { join as join5, dirname as dirname4 } from "node:path";
 
 // src/server/service/chat/envelope.ts
 import { isAbsolute } from "node:path";
+
+// src/server/shared/agent.ts
+var WELCOME_LANGUAGES = { en: "English", zh: "Chinese" };
+var welcomeLanguage = (value2) => typeof value2 === "string" && Object.hasOwn(WELCOME_LANGUAGES, value2) ? value2 : "en";
+
+// src/server/service/chat/envelope.ts
 var INVALID_XML = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\ud800-\udfff\ufffe\uffff]/u;
 function escape(value2) {
   if (INVALID_XML.test(value2)) throw new Error("Invalid XML character");
@@ -5371,6 +5789,7 @@ function remember(map, id, definition) {
   map.set(id, definition);
 }
 var iso2 = (time) => new Date(time).toISOString().replace(".000Z", "Z");
+var welcome = (owner, language) => `${owner} has just set up Jarvy and picked your model. You are their agent Bot. In this DM, welcome them in ${WELCOME_LANGUAGES[language]}, the language of their interface: say in a few sentences what Jarvy is and how you can help, such as building a team of Bots for their work and running Jarvy for them. Then ask what they want to get done: a software project, writing, research or something else.`;
 function encodeNoticeBatch(botId, notices) {
   if (!notices.length) throw new Error("Empty notice batch");
   const chats = /* @__PURE__ */ new Map(), members = /* @__PURE__ */ new Map();
@@ -5379,14 +5798,16 @@ function encodeNoticeBatch(botId, notices) {
 }
 function noticeTail(notices, chats, members) {
   for (const notice of notices) {
-    if (!chats.has(notice.chat.id)) chats.set(notice.chat.id, `<chat${attribute("id", notice.chat.id)}${attribute("type", notice.chat.type)}${attribute("title", notice.chat.title)}/>`);
+    if (!chats.has(notice.chat.id)) chats.set(notice.chat.id, `<chat${attribute("id", notice.chat.id)}${attribute("type", notice.chat.type)}${notice.chat.title ? attribute("title", notice.chat.title) : ""}/>`);
     remember(members, notice.actor.id, `<member${attribute("id", notice.actor.id)}${attribute("name", notice.actor.name)}${attribute("kind", notice.actor.kind)}/>`);
   }
   const latest = /* @__PURE__ */ new Map();
   for (const notice of notices) if (notice.kind === "note" && (latest.get(notice.chat.id)?.version ?? 0) < notice.version) latest.set(notice.chat.id, notice);
   const updates = [...latest.values()].map((note) => `<${note.chat.type === "thread" ? "summary" : "notice"}${attribute("chat", note.chat.id)}${attribute("version", String(note.version))}${attribute("by", note.actor.id)}${attribute("at", iso2(note.createdAt))}/>`);
   const marks = notices.flatMap((notice) => notice.kind !== "reaction" ? [] : [`<reaction${attribute("message", notice.message.id)}${attribute("chat", notice.chat.id)}${attribute("by", notice.actor.id)}${attribute("emoji", notice.emoji)}${attribute("at", iso2(notice.createdAt))}>${escape(notice.message.text)}</reaction>`]);
-  return (updates.length ? `<updates>${updates.join("")}</updates>` : "") + (marks.length ? `<notices>${marks.join("")}<note>These are reactions to your messages. Act on them if you need to; no reply is required.</note></notices>` : "");
+  const changes = notices.flatMap((notice) => notice.kind !== "change" ? [] : [`<change${attribute("chat", notice.chat.id)}${attribute("by", notice.actor.id)}${attribute("what", notice.what)}${attribute("at", iso2(notice.createdAt))}${notice.value === null ? "/>" : `>${escape(notice.value)}</change>`}`]);
+  const onboard = notices.flatMap((notice) => notice.kind !== "onboard" ? [] : [`<onboard${attribute("chat", notice.chat.id)}${attribute("by", notice.actor.id)}${attribute("at", iso2(notice.createdAt))}><note>${escape(welcome(notice.actor.name, notice.language))}</note></onboard>`]).slice(-1);
+  return (updates.length ? `<updates>${updates.join("")}</updates>` : "") + (marks.length ? `<notices>${marks.join("")}<note>These are reactions to your messages. Act on them if you need to; no reply is required.</note></notices>` : "") + (changes.length ? `<changes>${changes.join("")}<note>The agent Bot changed your settings, and the changes already apply. A persona change is already in your instructions. If something is unclear, ask it in that DM.</note></changes>` : "") + onboard.join("");
 }
 function encodeChatBatch(botId, messages, digest, notices) {
   if (!messages.length) throw new Error("Empty chat batch");
@@ -5422,7 +5843,8 @@ var BotInbox = class {
     this.chats = chats;
     this.files = files;
   }
-  /** Messages and other deliveries wait in the inbox (A41); either kind is work for the next run. */
+  /** Messages and other deliveries wait in the inbox (A41); either kind is work for the next run. A digest delivery
+   * (a change the agent Bot made, A48) is not work of its own: it rides along with the next batch. */
   pending() {
     return this.repository.hasPending(this.botId) || this.hasNotices();
   }
@@ -5430,7 +5852,7 @@ var BotInbox = class {
     return this.repository.claim(this.botId, selection, this.hasNotices());
   }
   hasNotices() {
-    return this.chats.notices(this.botId).length > 0;
+    return this.chats.notices(this.botId).some((notice) => notice.urgency !== "digest");
   }
   reference(workspace) {
     if (this.repository.hasUncertainModel(this.botId)) throw new RuntimeFault("model_switch_uncertain", "The model switch didn't finish. Pick the model again.");
@@ -5454,6 +5876,11 @@ var BotInbox = class {
     return notices.map((notice) => {
       const chat = { id: notice.chatId, type: notice.chatType, title: notice.chatTitle };
       if (notice.kind === "note") return { kind: "note", id: notice.id, chat, actor: notice.actor, version: Number(notice.detail), createdAt: notice.createdAt };
+      if (notice.kind === "onboard") return { kind: "onboard", id: notice.id, chat, actor: notice.actor, language: welcomeLanguage(notice.detail), createdAt: notice.createdAt };
+      if (notice.kind === "change") {
+        const change = JSON.parse(notice.detail);
+        return { kind: "change", id: notice.id, chat, actor: notice.actor, what: change.what, value: change.value, createdAt: notice.createdAt };
+      }
       const marked = notice.messageId ? this.chats.message(this.botId, notice.messageId) : null;
       const text3 = marked ? previewQuotes(marked.content, marked.quotes).slice(0, 120) : "";
       return { kind: "reaction", id: notice.id, chat, message: { id: notice.messageId ?? "", text: text3 }, actor: notice.actor, emoji: notice.detail, createdAt: notice.createdAt };
@@ -5701,6 +6128,14 @@ var AgentRuntime = class {
 };
 
 // src/server/service/bot/prompt.ts
+var AGENT_ROLE = `
+## Your role
+You are the owner's agent Bot. Besides working like any Bot, you help them set up and run Jarvy itself.
+Help a new owner get started: find out what they want to get done, suggest a team of Bots for it, then create and set up those Bots.
+The chat gateway lists tools only you have: models.list, bots.create, bots.update, bots.start, bots.stop and bots.usage. bots.delete, chats.delete, chats.removeMembers and sections.delete first ask the owner on a card, and delete nothing unless they confirm.
+Other Bots may ask you to do these things for them. Do the ordinary ones; deleting always waits for the owner's confirmation.
+You can't add model connections, keys or logins. The owner does that in Settings, so point them there when a model is missing.
+`;
 function botPrompt(setup) {
   const bot = { ...setup.identity(), workspacePath: setup.workspace.cwd };
   return `# Persona
@@ -5711,7 +6146,7 @@ ${bot.persona}
 ## Environment
 You are in a group chat with people and other Bots. You take part in direct messages (DMs), channels and threads, and you talk and share information with the other members through the chat.
 Here your name is ${bot.name}, and your description is: ${bot.description}
-
+${bot.agent ? AGENT_ROLE : ""}
 ## Language
 Write to people in the language they write to you in. In a channel or thread, use the language its conversation is held in.
 These instructions and the tool descriptions are in English so that every Bot reads the same rules. They do not decide which language you use with people.
@@ -5739,44 +6174,426 @@ 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/agent.ts
+var same2 = (a, b) => a.trim().replace(/^@/, "").toLocaleLowerCase() === b.trim().toLocaleLowerCase();
+var AgentOps = class {
+  constructor(bots, store, chats) {
+    this.bots = bots;
+    this.store = store;
+    this.chats = chats;
+  }
+  get owner() {
+    return this.store.userMemberId();
+  }
+  agentId = AGENT_BOT_ID;
+  /** A Bot by name, ignoring case and a leading @. */
+  bot(name2) {
+    const bot = this.store.listBots().find((record2) => same2(name2, record2.name));
+    if (!bot) throw new ChatError(404, `No Bot named ${name2} (see bots.list)`);
+    return bot;
+  }
+  /** Connected models and their thinking levels; never credentials. */
+  models() {
+    return this.store.listModelConnections().filter((connection) => connection.models.length).map((connection) => ({
+      connection: connection.displayName,
+      connectionId: connection.id,
+      models: connection.models.map((model) => ({ id: model.id, name: model.name, thinking: ["auto", ...thinkingOptions(model).levels] }))
+    }));
+  }
+  selection(bot, input) {
+    if (!input.model && input.thinking === void 0) return null;
+    let connectionId = bot?.connectionId ?? null, modelId = bot?.modelId ?? "";
+    if (input.model) {
+      const { connection, model } = input.model;
+      const found = this.store.listModelConnections().find((item) => item.id === connection || same2(connection, item.displayName));
+      if (!found) throw new ChatError(404, `No connection named ${connection} (see models.list)`);
+      const picked = found.models.find((item) => item.id === model || same2(model, item.name));
+      if (!picked) throw new ChatError(404, `No model ${model} in ${found.displayName} (see models.list)`);
+      connectionId = found.id;
+      modelId = picked.id;
+    }
+    if (!connectionId) throw new ChatError(400, "This Bot has no model yet; give model too");
+    return { connectionId, modelId, ...input.thinking === void 0 ? {} : { thinkingLevel: input.thinking } };
+  }
+  /** "model (connection)", as the agent and the changed Bot read it. */
+  modelLabel(bot) {
+    const connection = bot.connectionId ? this.store.getModelConnection(bot.connectionId) : null;
+    const model = connection?.models.find((item) => item.id === bot.modelId);
+    return model ? `${model.name} (${connection.displayName})` : bot.modelId;
+  }
+  async create(input) {
+    const selection = this.selection(null, input);
+    const created = this.bots.create(input.name);
+    if (input.description !== void 0 || input.persona !== void 0)
+      this.bots.get(created.id).identity.update({ name: created.name, description: input.description ?? "", persona: input.persona ?? "" });
+    if (selection) await this.bots.selectModel(created.id, selection);
+    this.bots.listChanged();
+    return this.store.getBot(created.id);
+  }
+  async update(bot, input) {
+    const selection = this.selection(bot, input);
+    if (input.name !== void 0 || input.description !== void 0 || input.persona !== void 0)
+      this.bots.get(bot.id).identity.update({ name: input.name ?? bot.name, description: input.description ?? bot.description, persona: input.persona ?? bot.systemPrompt });
+    if (selection) await this.bots.selectModel(bot.id, selection);
+    const after2 = this.store.getBot(bot.id), changes = [];
+    if (after2.name !== bot.name) changes.push({ what: "name", value: after2.name });
+    if (after2.description !== bot.description) changes.push({ what: "description", value: after2.description });
+    if (after2.systemPrompt !== bot.systemPrompt) changes.push({ what: "persona", value: null });
+    if (after2.connectionId !== bot.connectionId || after2.modelId !== bot.modelId) changes.push({ what: "model", value: this.modelLabel(after2) });
+    if (after2.thinkingLevel !== bot.thinkingLevel) changes.push({ what: "thinking", value: after2.thinkingLevel });
+    this.tell(bot.id, changes);
+    this.bots.listChanged();
+    return { bot: after2, changed: changes.map((change) => change.what) };
+  }
+  async run(bot, action) {
+    if (action === "stop" && bot.id === AGENT_BOT_ID) throw new ChatError(400, "You can't stop yourself");
+    const runtime = this.bots.get(bot.id);
+    await (action === "start" ? runtime.start() : runtime.stop());
+    this.tell(bot.id, [{ what: "run", value: action }]);
+    return this.bots.status(bot.id).status;
+  }
+  usage(bot, days) {
+    const since = Date.now() - days * 24 * 60 * 60 * 1e3;
+    return { since: new Date(since).toISOString(), models: this.bots.memory(bot.id).usage(since) };
+  }
+  /** Deletions run as the owner, who has just confirmed them on a card. */
+  async deleteBot(bot) {
+    if (bot.id === AGENT_BOT_ID) throw new ChatError(400, "You can't delete yourself");
+    await this.bots.delete(bot.id, true);
+    this.bots.listChanged();
+  }
+  async deleteChannel(chatId) {
+    if (!await this.chats.delete(this.owner, chatId)) throw new ChatError(404, "Channel not found");
+    await this.bots.chatDeleted(chatId, AGENT_BOT_ID);
+  }
+  removeMember(chatId, memberId) {
+    this.chats.channels.removeMember(this.owner, chatId, memberId);
+  }
+  deleteSection(sectionId) {
+    if (!this.chats.channels.deleteSection(this.owner, sectionId)) throw new ChatError(404, "Section not found");
+  }
+  /** The changed Bot is told with its next batch (digest: it is not woken for it), in its DM with the agent. */
+  tell(botId, changes) {
+    if (botId === AGENT_BOT_ID || !changes.length) return;
+    const chatId = this.chats.openDirect(AGENT_BOT_ID, botId).id;
+    for (const change of changes) this.store.agent.notify({ botId, kind: "change", reason: "agent", urgency: "digest", chatId, actorId: AGENT_BOT_ID, detail: JSON.stringify(change) });
+  }
+  /** The agent's first model: ask it, once, to welcome the owner in their DM, in their interface language. */
+  onboard(language) {
+    if (!this.store.agent.markOnboarded()) return;
+    const chatId = this.chats.openDirect(this.owner, AGENT_BOT_ID).id;
+    this.store.agent.notify({ botId: AGENT_BOT_ID, kind: "onboard", reason: "setup", urgency: "interrupt", chatId, actorId: this.owner, detail: language });
+    this.bots.deliver(AGENT_BOT_ID, "interrupt");
+  }
+};
+
 // src/server/service/bot/service.ts
 var BotService = class {
   constructor(deps) {
     this.deps = deps;
+    this.agent = new AgentOps(this, deps.store, deps.chats);
   }
   bots = /* @__PURE__ */ new Map();
+  lives = /* @__PURE__ */ new Map();
   closed = false;
   started = false;
+  /** What only the agent Bot does (A48). */
+  agent;
+  listChanged() {
+    this.deps.listChanged?.();
+  }
   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),
       workspace,
       memory,
-      tools: new Tools({ botId: id, chats, files, memory, workspace, asking: (on) => runtime.waitingForUser(on), roster: () => this.roster() }),
+      tools: new Tools({
+        botId: id,
+        chats,
+        files,
+        memory,
+        workspace,
+        asking: (on) => runtime.waitingForUser(on),
+        roster: () => this.roster(),
+        ...id === AGENT_BOT_ID ? { agent: this.agent } : {}
+      }),
       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 +6609,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, agent: record2.id === AGENT_BOT_ID };
   }
   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 +6690,16 @@ 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,
+        agent: record2.id === AGENT_BOT_ID,
         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)
       };
     });
   }
@@ -5873,18 +6708,22 @@ var BotService = class {
     const bot = this.bots.get(id);
     return { ...bot?.status() ?? { status: "stop", activity: null, context: null, error: null }, botId: id, runId: bot?.agentRuntime.activeRunId ?? null };
   }
+  /** `language` is the browser's interface language: the agent Bot's first model asks it to welcome the owner in it (A48). */
   async selectModel(id, input) {
     const selection = this.deps.store.validateSelection(id, input);
     if (!selection) throw new RuntimeFault("bot_missing", "Bot not found", 404);
     await this.get(id).changeModel(selection);
     this.resume(id);
+    if (id === AGENT_BOT_ID) this.agent.onboard(welcomeLanguage(input.language));
     return this.deps.store.getBot(id);
   }
   connectionChanged(connectionId) {
     for (const bot of this.deps.store.listBots()) if (bot.connectionId === connectionId) this.resume(bot.id);
   }
-  async chatDeleted(chatId) {
-    for (const bot of this.bots.values()) {
+  /** A deleted chat ends the turns handling it; `except` is the agent Bot that deleted it from inside its turn. */
+  async chatDeleted(chatId, except) {
+    for (const [id, bot] of this.bots) {
+      if (id === except) continue;
       const runId = bot.agentRuntime.activeRunId;
       if (runId && this.deps.store.runtime.inputs(runId).some((input) => input.chatId === chatId)) await bot.abort();
     }
@@ -5892,9 +6731,12 @@ var BotService = class {
   /** Deletes a Bot: stop it, drop its data, keep its messages. `keepFiles` leaves the workspace (and
    * the History database) on disk, since it may hold work worth keeping. */
   async delete(id, keepFiles) {
+    if (id === AGENT_BOT_ID) throw new RuntimeFault("agent_undeletable", "The agent Bot can't be deleted", 409);
     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 +6744,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();
   }
 };
 
@@ -5933,6 +6776,7 @@ var Application = class _Application {
       files: this.files,
       credentials: this.credentials,
       changed: (id) => this.events.publish({ kind: "bot", id, status: this.bots.status(id) }),
+      listChanged: () => this.events.publish({ kind: "bots" }),
       factory
     });
     this.auth = new CredentialLogins(store, this.credentials, (id) => this.bots.connectionChanged(id));
@@ -6003,8 +6847,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 +6876,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 +6916,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";
     }