@goodfish/jarvy 0.4.0 → 0.5.0

package/dist/server/cli.js

@@ -466,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));
@@ -607,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();
@@ -809,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";
@@ -1083,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;
@@ -1121,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,
@@ -1206,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);
@@ -1222,6 +1261,7 @@ function migrateDatabase(db) {
     migrateInbox(db);
     migrateQuotes(db);
     migrateTitles(db);
+    migrateAgent(db);
     return;
   }
   db.exec("PRAGMA foreign_keys=OFF; BEGIN IMMEDIATE");
@@ -1295,6 +1335,7 @@ function migrateDatabase(db) {
   migrateInbox(db);
   migrateQuotes(db);
   migrateTitles(db);
+  migrateAgent(db);
 }
 
 // src/server/infra/storage/chat-repository.ts
@@ -1618,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) }));
   }
@@ -1848,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) {
@@ -2191,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";
@@ -2260,6 +2342,7 @@ var Store = class {
   chats;
   runtime;
   credentials;
+  agent;
   constructor(dataDir = defaultDataDir()) {
     const root = resolve(dataDir);
     mkdirSync(root, { recursive: true, mode: 448 });
@@ -2276,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();
@@ -2380,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");
@@ -2784,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);
@@ -3200,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];
@@ -3364,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);
@@ -3835,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);
@@ -4831,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 };
   }
 };
 
@@ -4916,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
@@ -5114,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));
@@ -5261,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.",
@@ -5289,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": {
@@ -5368,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 } : {},
@@ -5379,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;
   }
@@ -5405,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);
@@ -5504,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);
           }
         }
       }
@@ -5523,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");
@@ -5538,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();
@@ -5546,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");
@@ -5589,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();
   }
@@ -5597,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.");
@@ -5621,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 };
@@ -5868,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
@@ -5878,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.
@@ -6158,15 +6426,134 @@ var LiveTurns = class {
   }
 };
 
+// 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 record2 = this.deps.store.getBot(id);
@@ -6193,7 +6580,16 @@ var BotService = class {
       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) => {
@@ -6215,7 +6611,7 @@ var BotService = class {
   }
   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 };
+    return { ...record2, effectiveThinkingLevel: model ? resolveThinking(model, record2.thinkingLevel) : null, agent: record2.id === AGENT_BOT_ID };
   }
   owns(id) {
     return this.deps.store.getBot(id) !== null;
@@ -6300,6 +6696,7 @@ var BotService = class {
       return {
         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(record2.id)
@@ -6311,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();
     }
@@ -6330,6 +6731,7 @@ 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);
@@ -6374,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));