@goodfish/jarvy 0.4.0 → 0.6.0

package/dist/server/cli.js

@@ -3,7 +3,7 @@
 // src/server/cli.ts
 import { existsSync as existsSync2 } from "node:fs";
 import { createInterface } from "node:readline/promises";
-import { dirname as dirname6, join as join9 } from "node:path";
+import { dirname as dirname8, join as join11 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/server/api/server.ts
@@ -12,7 +12,7 @@ import { getRequestListener } from "@hono/node-server";
 
 // src/server/api/app.ts
 import { Hono as Hono10 } from "hono";
-import { HTTPException as HTTPException9 } from "hono/http-exception";
+import { HTTPException as HTTPException10 } from "hono/http-exception";
 import { serveStatic } from "@hono/node-server/serve-static";
 
 // src/server/api/middleware/security.ts
@@ -184,6 +184,7 @@ function installAuthentication(api, account) {
 
 // src/server/api/routes/bots.ts
 import { Hono as Hono4 } from "hono";
+import { HTTPException as HTTPException7 } from "hono/http-exception";
 
 // src/server/api/views/bot-status.ts
 function botStatusView(status) {
@@ -379,7 +380,18 @@ function botRoutes(bots) {
   routes.get("/", (c) => c.json({ bots: bots.list() }));
   routes.post("/", jsonBody, async (c) => {
     const input = await readJson(c);
-    return c.json(bots.create(textField(input, "name")), 201);
+    return c.json(bots.create(textField(input, "name"), input.environment === void 0 ? void 0 : environmentKind(input.environment)), 201);
+  });
+  routes.put("/:id/environment", jsonBody, async (c) => {
+    const input = await readJson(c), id = c.req.param("id");
+    if (input.hostGranted === void 0) return c.json(bots.setHome(id, environmentKind(input.home)));
+    if (typeof input.hostGranted !== "boolean") throw new HTTPException7(400, { message: "hostGranted must be true or false" });
+    return c.json(bots.grantHost(id, input.hostGranted));
+  });
+  routes.post("/:id/computer/:action", async (c) => {
+    const action = c.req.param("action");
+    if (action !== "start" && action !== "stop" && action !== "reset") throw new HTTPException7(404, { message: "Not found" });
+    return c.json(await bots.computer(c.req.param("id"), action));
   });
   routes.get("/:id", (c) => c.json(bots.describe(c.req.param("id"))));
   routes.delete("/:id", async (c) => {
@@ -428,10 +440,14 @@ function botRoutes(bots) {
   routes.route("/", activityRoutes(bots));
   return routes;
 }
+function environmentKind(value2) {
+  if (value2 !== "computer" && value2 !== "host") throw new HTTPException7(400, { message: "environment must be computer or host" });
+  return value2;
+}
 
 // src/server/api/routes/chats.ts
 import { Hono as Hono5 } from "hono";
-import { HTTPException as HTTPException7 } from "hono/http-exception";
+import { HTTPException as HTTPException8 } 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"]);
@@ -466,10 +482,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,16 +500,16 @@ function chatRoutes({ chats, bots }) {
     try {
       name2 = decodeURIComponent(c.req.header("x-file-name") ?? "");
     } catch {
-      throw new HTTPException7(400, { message: "Invalid filename" });
+      throw new HTTPException8(400, { message: "Invalid filename" });
     }
     const data = Buffer.from(await c.req.arrayBuffer());
-    if (!data.length) throw new HTTPException7(400, { message: "Empty attachment" });
+    if (!data.length) throw new HTTPException8(400, { message: "Empty attachment" });
     const mime = (c.req.header("content-type") ?? "application/octet-stream").slice(0, 100);
     return c.json(chats.upload(c.get("actorId"), c.req.param("id"), name2, mime, data), 201);
   });
   routes.delete("/:id", async (c) => {
     const id = c.req.param("id");
-    if (!await chats.delete(c.get("actorId"), id)) throw new HTTPException7(404, { message: "Chat not found" });
+    if (!await chats.delete(c.get("actorId"), id)) throw new HTTPException8(404, { message: "Chat not found" });
     await bots.chatDeleted(id);
     return c.json({ ok: true });
   });
@@ -503,7 +519,7 @@ function attachmentRoutes(chats) {
   const routes = new Hono5();
   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" });
+    if (!attachment) throw new HTTPException8(404, { message: "Attachment not found" });
     const size = attachment.data.length, range = byteRange(c.req.header("Range"), size);
     const headers2 = {
       "Content-Type": downloadType(attachment.file.mimeType),
@@ -520,14 +536,14 @@ function attachmentRoutes(chats) {
   });
   routes.get("/:id/run", (c) => {
     const attachment = chats.download(c.get("actorId"), c.req.param("id"));
-    if (!attachment) throw new HTTPException7(404, { message: "Attachment not found" });
+    if (!attachment) throw new HTTPException8(404, { message: "Attachment not found" });
     const { name: name2, mimeType } = attachment.file;
-    if (!/\.html?$/i.test(name2) && mimeType !== "text/html") throw new HTTPException7(415, { message: "Only HTML attachments can run" });
+    if (!/\.html?$/i.test(name2) && mimeType !== "text/html") throw new HTTPException8(415, { message: "Only HTML attachments can run" });
     c.set("sandboxedDocument", true);
     return c.body(new Uint8Array(attachment.data), 200, { "Content-Type": "text/html; charset=utf-8", "Content-Length": String(attachment.data.length) });
   });
   routes.delete("/:id", (c) => {
-    if (!chats.removePendingAttachment(c.get("actorId"), c.req.param("id"))) throw new HTTPException7(404, { message: "Pending attachment not found" });
+    if (!chats.removePendingAttachment(c.get("actorId"), c.req.param("id"))) throw new HTTPException8(404, { message: "Pending attachment not found" });
     return c.json({ ok: true });
   });
   return routes;
@@ -607,6 +623,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();
@@ -637,13 +654,13 @@ data: ${JSON.stringify(data)}
 
 // src/server/api/routes/channels.ts
 import { Hono as Hono8 } from "hono";
-import { HTTPException as HTTPException8 } from "hono/http-exception";
+import { HTTPException as HTTPException9 } from "hono/http-exception";
 function channelRoutes({ chats }) {
   const routes = new Hono8();
   const channels = chats.channels;
   const chat = (actorId, id) => {
     const found = chats.get(actorId, id);
-    if (!found) throw new HTTPException8(404, { message: "Chat not found" });
+    if (!found) throw new HTTPException9(404, { message: "Chat not found" });
     return chatView(found, (member) => chats.member(member));
   };
   routes.get("/members", (c) => c.json({ members: channels.everyone(c.get("actorId")) }));
@@ -664,7 +681,7 @@ function channelRoutes({ chats }) {
   routes.post("/sections", jsonBody, async (c) => c.json(channels.createSection(c.get("actorId"), await readJson(c)), 201));
   routes.patch("/sections/:id", jsonBody, async (c) => c.json(channels.updateSection(c.get("actorId"), c.req.param("id"), await readJson(c))));
   routes.delete("/sections/:id", (c) => {
-    if (!channels.deleteSection(c.get("actorId"), c.req.param("id"))) throw new HTTPException8(404, { message: "Section not found" });
+    if (!channels.deleteSection(c.get("actorId"), c.req.param("id"))) throw new HTTPException9(404, { message: "Section not found" });
     return c.json({ ok: true });
   });
   routes.post("/channels", jsonBody, async (c) => {
@@ -680,7 +697,7 @@ function channelRoutes({ chats }) {
   routes.get("/chats/:id", (c) => c.json(chat(c.get("actorId"), c.req.param("id"))));
   routes.get("/messages/:id", (c) => {
     const found = chats.message(c.get("actorId"), c.req.param("id"));
-    if (!found) throw new HTTPException8(404, { message: "Message not found" });
+    if (!found) throw new HTTPException9(404, { message: "Message not found" });
     return c.json(messageView(found));
   });
   routes.post("/messages/:id/thread", (c) => {
@@ -785,7 +802,7 @@ function createHttpApp(services, webRoot) {
   api.route("/", eventRoutes(services));
   api.route("/", liveRoutes(services));
   api.all("*", () => {
-    throw new HTTPException9(404, { message: "API route not found" });
+    throw new HTTPException10(404, { message: "API route not found" });
   });
   app.route("/api", api);
   app.get("*", serveStatic({ root: webRoot, onFound: (path, c) => {
@@ -795,8 +812,8 @@ function createHttpApp(services, webRoot) {
     c.header("Cache-Control", "no-store");
   } }));
   app.all("*", (c) => {
-    if (c.req.method !== "GET" && c.req.method !== "HEAD") throw new HTTPException9(405, { message: "Method not allowed" });
-    throw new HTTPException9(404, { message: "Web assets missing; run npm run build" });
+    if (c.req.method !== "GET" && c.req.method !== "HEAD") throw new HTTPException10(405, { message: "Method not allowed" });
+    throw new HTTPException10(404, { message: "Web assets missing; run npm run build" });
   });
   return app;
 }
@@ -809,12 +826,13 @@ 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 randomUUID8, scryptSync, timingSafeEqual } from "node:crypto";
 import { chmodSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { dirname as dirname2, join as join2, resolve } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 
 // src/server/infra/storage/migrations/composition-schema.ts
@@ -936,13 +954,13 @@ function migrateChannels(db) {
         SELECT cm.chat_id, cm.member_id, COALESCE((SELECT MAX(sequence) FROM messages m WHERE m.chat_id=cm.chat_id), 0) FROM chat_members cm;
     `);
     const taken = new Set(db.prepare("SELECT username FROM account").all().map((row) => row.username.toLowerCase()));
-    const rename2 = db.prepare("UPDATE bots SET name=? WHERE id=?");
+    const rename3 = db.prepare("UPDATE bots SET name=? WHERE id=?");
     for (const bot of db.prepare("SELECT id,name FROM bots ORDER BY created_at,id").all()) {
       const base = bot.name.replace(/@/g, "").trim() || "Bot";
       let name2 = base;
       for (let suffix = 2; taken.has(name2.toLowerCase()); suffix++) name2 = `${base} ${suffix}`;
       taken.add(name2.toLowerCase());
-      if (name2 !== bot.name) rename2.run(name2, bot.id);
+      if (name2 !== bot.name) rename3.run(name2, bot.id);
     }
     db.exec("PRAGMA user_version=12; COMMIT;");
   } catch (error) {
@@ -1083,12 +1101,76 @@ 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/environment-schema.ts
+function migrateEnvironments(db) {
+  const version = db.prepare("PRAGMA user_version").get().user_version;
+  if (version >= 20) return;
+  db.exec("BEGIN IMMEDIATE");
+  try {
+    db.exec(`
+      CREATE TABLE environments(id TEXT PRIMARY KEY, owner_id TEXT NOT NULL REFERENCES members(id),
+        kind TEXT NOT NULL CHECK(kind IN ('host','computer')), name TEXT NOT NULL DEFAULT '',
+        connection TEXT NOT NULL DEFAULT '{}', directory TEXT, bot_id TEXT REFERENCES bots(id),
+        created_at INTEGER NOT NULL, deleted_at INTEGER);
+      CREATE UNIQUE INDEX environments_host ON environments(owner_id) WHERE kind='host' AND deleted_at IS NULL;
+      CREATE UNIQUE INDEX environments_computer ON environments(bot_id) WHERE kind='computer' AND deleted_at IS NULL;
+      CREATE TABLE environment_grants(environment_id TEXT NOT NULL REFERENCES environments(id),
+        bot_id TEXT NOT NULL REFERENCES bots(id), granted_by TEXT NOT NULL REFERENCES members(id),
+        granted_at INTEGER NOT NULL, PRIMARY KEY(environment_id, bot_id));
+      ALTER TABLE bots ADD COLUMN home_environment_id TEXT REFERENCES environments(id);
+      ALTER TABLE bots ADD COLUMN current_environment_id TEXT REFERENCES environments(id);
+      PRAGMA user_version=20;
+    `);
+    db.exec("COMMIT");
+  } catch (error) {
+    db.exec("ROLLBACK");
+    throw error;
+  }
+}
+
 // 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 +1203,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 +1288,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 > 20) throw new Error(`Unsupported database version: ${version}`);
   migratePrototype(db);
   if (version >= 5) {
     migrateRuntime(db);
@@ -1222,6 +1304,8 @@ function migrateDatabase(db) {
     migrateInbox(db);
     migrateQuotes(db);
     migrateTitles(db);
+    migrateAgent(db);
+    migrateEnvironments(db);
     return;
   }
   db.exec("PRAGMA foreign_keys=OFF; BEGIN IMMEDIATE");
@@ -1295,6 +1379,8 @@ function migrateDatabase(db) {
   migrateInbox(db);
   migrateQuotes(db);
   migrateTitles(db);
+  migrateAgent(db);
+  migrateEnvironments(db);
 }
 
 // src/server/infra/storage/chat-repository.ts
@@ -1618,7 +1704,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 +1934,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) {
@@ -1874,7 +1960,7 @@ var ChatRepository = class {
     return rows2.map(({ historyId, toolCallId, ...row }) => ({ ...row, source: historyId === null ? null : { historyId, toolCallId } }));
   }
   messageFromRow(row) {
-    const attachments = this.db.prepare("SELECT id,name,mime_type AS mimeType,size FROM attachments WHERE message_id=? ORDER BY created_at,id").all(row.id);
+    const attachments = this.db.prepare("SELECT id,name,mime_type AS mimeType,size FROM attachments WHERE message_id=? ORDER BY created_at,rowid").all(row.id);
     return {
       id: row.id,
       chatId: row.chatId,
@@ -2135,9 +2221,112 @@ var RuntimeRepository = class {
 };
 
 // src/server/infra/pi/catalog.ts
-import { builtinProviders } from "@earendil-works/pi-ai/providers/all";
-function providerCatalog() {
-  return builtinProviders().flatMap((provider) => {
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { builtinProviders, getBuiltinModelDataGeneratedAt } from "@earendil-works/pi-ai/providers/all";
+var CATALOG_URL = "https://pi.dev/api/models";
+var REFRESH_MS = 4 * 60 * 60 * 1e3;
+var TIMEOUT_MS = 15e3;
+var modelApis = new Set(builtinProviders().flatMap((provider) => provider.getModels().map((model) => model.api)));
+var ModelCatalog = class {
+  path;
+  kept;
+  loaded = false;
+  overlaid;
+  loading;
+  constructor(dataDir) {
+    this.path = join(dataDir, "pi", "models.json");
+  }
+  providers() {
+    this.refresh();
+    return this.overlaid ?? builtinProviders();
+  }
+  /** Newer entries for one provider's models (a connection's catalog comes from Pi with its credentials). */
+  overlay(providerId, models) {
+    return merge(models, this.entries(providerId));
+  }
+  /** Loads the kept catalog, then checks pi.dev when the last check is 4 hours old; never waits. */
+  refresh() {
+    const due = process.env.PI_OFFLINE === void 0 && Date.now() - (this.kept?.checkedAt ?? 0) >= REFRESH_MS;
+    if (this.loading || this.loaded && !due) return;
+    this.loading = (async () => {
+      if (!this.loaded) {
+        this.kept = await this.read();
+        this.loaded = true;
+        this.apply();
+      }
+      if (!due) return;
+      await this.fetch();
+      this.apply();
+    })().catch((error) => console.warn("[models] catalog refresh failed", { error: error instanceof Error ? error.message : String(error) })).finally(() => {
+      this.loading = void 0;
+    });
+  }
+  async fetch() {
+    const previous = this.kept;
+    const checkedAt = Date.now();
+    try {
+      const response = await fetch(CATALOG_URL, {
+        signal: AbortSignal.timeout(TIMEOUT_MS),
+        headers: { accept: "application/json", "user-agent": "Jarvy", ...previous?.etag ? { "if-none-match": previous.etag } : {} }
+      });
+      if (response.status === 304 && previous) {
+        this.kept = { ...previous, checkedAt };
+        return;
+      }
+      if (!response.ok) throw new Error(`HTTP ${response.status}`);
+      const body = await response.json();
+      if (!body || typeof body !== "object" || Array.isArray(body)) throw new Error("not a catalog");
+      const lastModified = Date.parse(response.headers.get("last-modified") ?? "");
+      this.kept = { models: body, etag: response.headers.get("etag") ?? void 0, lastModified: Number.isNaN(lastModified) ? 0 : lastModified, checkedAt };
+    } catch (error) {
+      this.kept = { ...previous ?? { models: {}, lastModified: 0 }, checkedAt };
+      throw error;
+    } finally {
+      await this.write().catch((error) => console.warn("[models] catalog not saved", { error: error instanceof Error ? error.message : String(error) }));
+    }
+  }
+  apply() {
+    this.overlaid = builtinProviders().map((provider) => {
+      const entries = this.entries(provider.id);
+      if (!entries.length) return provider;
+      const models = merge(provider.getModels(), entries);
+      return { ...provider, getModels: () => models };
+    });
+  }
+  entries(providerId) {
+    const kept = this.kept, generatedAt = getBuiltinModelDataGeneratedAt();
+    if (!kept || generatedAt !== void 0 && kept.lastModified <= generatedAt) return [];
+    const models = kept.models[providerId];
+    if (!models || typeof models !== "object") return [];
+    return Object.values(models).filter((model) => typeof model?.id === "string" && typeof model.api === "string" && modelApis.has(model.api) && (model.type === void 0 || model.type === "chat")).map((model) => ({ ...model, provider: providerId }));
+  }
+  async read() {
+    try {
+      const kept = JSON.parse(await readFile(this.path, "utf8"));
+      return kept && typeof kept.models === "object" ? kept : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  async write() {
+    await mkdir(dirname(this.path), { recursive: true, mode: 448 });
+    const next = `${this.path}.tmp`;
+    await writeFile(next, JSON.stringify(this.kept), { mode: 384 });
+    await rename(next, this.path);
+  }
+};
+function merge(models, newer) {
+  const merged = [...models];
+  for (const model of newer) {
+    const index = merged.findIndex((entry) => entry.id === model.id);
+    if (index >= 0) merged[index] = model;
+    else merged.push(model);
+  }
+  return merged;
+}
+function providerCatalog(providers) {
+  return providers.flatMap((provider) => {
     const models = provider.getModels();
     if (!models.length && provider.getAllModels?.().length) return [];
     const common = { id: provider.id, api: models[0]?.api ?? "openai-completions", modelCount: models.length };
@@ -2147,7 +2336,6 @@ function providerCatalog() {
     ];
   }).sort((a, b) => a.name.localeCompare(b.name));
 }
-var modelApis = new Set(builtinProviders().flatMap((provider) => provider.getModels().map((model) => model.api)));
 
 // src/server/infra/storage/credential-repository.ts
 function credentialValue(value2) {
@@ -2191,8 +2379,133 @@ 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/environment-repository.ts
+import { randomUUID as randomUUID7 } from "node:crypto";
+var COLUMNS = "id, owner_id AS ownerId, kind, bot_id AS botId, connection";
+var record = (row) => ({ id: row.id, ownerId: row.ownerId, kind: row.kind, botId: row.botId, spec: JSON.parse(row.connection) });
+var EnvironmentRepository = class {
+  constructor(db, ownerId) {
+    this.db = db;
+    this.ownerId = ownerId;
+  }
+  get(id) {
+    const row = this.db.prepare(`SELECT ${COLUMNS} FROM environments WHERE id=? AND deleted_at IS NULL`).get(id);
+    return row ? record(row) : null;
+  }
+  /** The owner's computer. */
+  host() {
+    const owner = this.ownerId();
+    const find = () => this.db.prepare(`SELECT ${COLUMNS} FROM environments WHERE owner_id=? AND kind='host' AND deleted_at IS NULL`).get(owner);
+    const found = find();
+    if (found) return record(found);
+    this.db.prepare("INSERT OR IGNORE INTO environments(id,owner_id,kind,created_at) VALUES(?,?,'host',?)").run(randomUUID7(), owner, Date.now());
+    return record(find());
+  }
+  computerOf(botId) {
+    const row = this.db.prepare(`SELECT ${COLUMNS} FROM environments WHERE bot_id=? AND kind='computer' AND deleted_at IS NULL`).get(botId);
+    return row ? record(row) : null;
+  }
+  /** Every live Bot's computer. */
+  computers() {
+    return this.db.prepare(`SELECT e.id, e.owner_id AS ownerId, e.kind, e.bot_id AS botId, e.connection FROM environments e JOIN bots b ON b.id=e.bot_id
+      WHERE e.kind='computer' AND e.deleted_at IS NULL AND b.deleted_at IS NULL`).all().map(record);
+  }
+  /** Gives the Bot a computer, reached by the container's name. */
+  addComputer(botId, container) {
+    const existing = this.computerOf(botId);
+    if (existing) return existing;
+    const id = randomUUID7();
+    this.db.prepare("INSERT INTO environments(id,owner_id,kind,connection,directory,bot_id,created_at) VALUES(?,?,'computer',?,'/workspace',?,?)").run(id, this.ownerId(), JSON.stringify({ container }), botId, Date.now());
+    return this.get(id);
+  }
+  /** The Bot's computer is gone: whoever was placed on it is back on the owner's computer. */
+  dropComputer(botId) {
+    const computer = this.computerOf(botId);
+    if (!computer) return;
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      this.db.prepare("UPDATE bots SET home_environment_id=NULL WHERE home_environment_id=?").run(computer.id);
+      this.db.prepare("UPDATE bots SET current_environment_id=NULL WHERE current_environment_id=?").run(computer.id);
+      this.db.prepare("DELETE FROM environment_grants WHERE environment_id=?").run(computer.id);
+      this.db.prepare("UPDATE environments SET deleted_at=? WHERE id=?").run(Date.now(), computer.id);
+      this.db.exec("COMMIT");
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  /** The Bot's default environment and the one it works in now. */
+  placement(botId) {
+    const row = this.db.prepare("SELECT home_environment_id AS home, current_environment_id AS current FROM bots WHERE id=?").get(botId);
+    const home = row?.home && this.get(row.home) || this.host();
+    const current = row?.current && this.get(row.current) || home;
+    return { home, current };
+  }
+  /** Makes an environment the Bot's default and moves the Bot there. */
+  setHome(botId, environmentId) {
+    this.db.prepare("UPDATE bots SET home_environment_id=?, current_environment_id=? WHERE id=?").run(environmentId, environmentId, botId);
+  }
+  /** Moves the Bot without changing its default. */
+  setCurrent(botId, environmentId) {
+    this.db.prepare("UPDATE bots SET current_environment_id=? WHERE id=?").run(environmentId, botId);
+  }
+  /** The environments the owner granted the Bot, oldest grant first. */
+  grants(botId) {
+    return this.db.prepare(`SELECT e.id, e.owner_id AS ownerId, e.kind, e.bot_id AS botId, e.connection FROM environment_grants g JOIN environments e ON e.id=g.environment_id
+      WHERE g.bot_id=? AND e.deleted_at IS NULL ORDER BY g.granted_at, e.id`).all(botId).map(record);
+  }
+  /** A grant lasts until it is revoked (A50); false when nothing changed. */
+  grant(environmentId, botId, by) {
+    return Number(this.db.prepare("INSERT OR IGNORE INTO environment_grants(environment_id,bot_id,granted_by,granted_at) VALUES(?,?,?,?)").run(environmentId, botId, by, Date.now()).changes) > 0;
+  }
+  revoke(environmentId, botId) {
+    return Number(this.db.prepare("DELETE FROM environment_grants WHERE environment_id=? AND bot_id=?").run(environmentId, botId).changes) > 0;
+  }
+};
+
 // src/server/infra/storage/store.ts
-var defaultDataDir = () => process.env.JARVY_DATA_DIR || join(homedir(), ".jarvy");
+var defaultDataDir = () => process.env.JARVY_DATA_DIR || join2(homedir(), ".jarvy");
 var DATABASE_FILENAME = "jarvy.db";
 var SESSION_LIFETIME_MS = 7 * 24 * 60 * 60 * 1e3;
 function passwordHash(password, salt) {
@@ -2260,10 +2573,12 @@ var Store = class {
   chats;
   runtime;
   credentials;
+  agent;
+  environments;
   constructor(dataDir = defaultDataDir()) {
     const root = resolve(dataDir);
     mkdirSync(root, { recursive: true, mode: 448 });
-    this.path = join(root, DATABASE_FILENAME);
+    this.path = join2(root, DATABASE_FILENAME);
     this.db = new DatabaseSync(this.path);
     chmodSync(this.path, 384);
     this.db.exec("PRAGMA journal_mode=WAL; PRAGMA synchronous=FULL; PRAGMA foreign_keys=ON; PRAGMA busy_timeout=5000;");
@@ -2276,6 +2591,9 @@ 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.environments = new EnvironmentRepository(this.db, () => this.userMemberId());
+    this.agent.ensure();
   }
   close() {
     this.db.close();
@@ -2284,7 +2602,7 @@ var Store = class {
   installationDeviceId() {
     const row = this.db.prepare("SELECT device_id FROM installation WHERE id=1").get();
     if (row) return row.device_id;
-    const id = randomUUID7();
+    const id = randomUUID8();
     this.db.prepare("INSERT INTO installation(id,device_id) VALUES(1,?)").run(id);
     return id;
   }
@@ -2332,8 +2650,8 @@ var Store = class {
     if (token) this.db.prepare("DELETE FROM auth_sessions WHERE token_hash=?").run(tokenHash(token));
   }
   botFromRow(row) {
-    const workspacePath = join(dirname(this.path), "bots", row.id, "workspace");
-    mkdirSync(join(workspacePath, "temp"), { recursive: true, mode: 448 });
+    const workspacePath = join2(dirname2(this.path), "bots", row.id, "workspace");
+    mkdirSync(join2(workspacePath, "temp"), { recursive: true, mode: 448 });
     return { ...row, workspacePath };
   }
   listBots() {
@@ -2360,6 +2678,7 @@ var Store = class {
       this.db.prepare("DELETE FROM chats WHERE type='dm' AND id IN (SELECT chat_id FROM chat_members WHERE member_id=?)").run(id);
       for (const table of ["chat_members", "chat_states", "inbox"]) this.db.prepare(`DELETE FROM ${table} WHERE member_id=?`).run(id);
       this.db.prepare("DELETE FROM bot_sessions WHERE bot_id=?").run(id);
+      this.db.prepare("DELETE FROM environment_grants WHERE bot_id=?").run(id);
       this.db.exec("COMMIT");
     } catch (error) {
       this.db.exec("ROLLBACK");
@@ -2376,11 +2695,11 @@ var Store = class {
   /** The caller names the Bot (A45: the interface picks a free default in its own language). */
   createBot(name2) {
     const clean = this.botName(name2);
-    const id = randomUUID7(), createdAt = Date.now();
+    const id = randomUUID8(), createdAt = Date.now();
     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");
@@ -2448,7 +2767,7 @@ var Store = class {
     }
     const key = input.apiKey === void 0 ? null : requireText(input.apiKey, "API Key", 8192);
     if (key && authType !== "api_key") throw new ValidationError("Invalid credential type");
-    const id = randomUUID7(), now = Date.now();
+    const id = randomUUID8(), now = Date.now();
     this.db.exec("BEGIN IMMEDIATE");
     try {
       this.db.prepare("INSERT INTO provider_connections(id,provider_name,display_name,kind,auth_type,base_url,api,created_at,updated_at,owner_id) VALUES(?,?,?,?,?,?,?,?,?,?)").run(id, providerName, displayName, kind, authType, baseUrl, api, now, now, this.userMemberId());
@@ -2582,7 +2901,6 @@ var AccountService = class {
 };
 
 // src/server/infra/pi/model.ts
-import { builtinProviders as builtinProviders2 } from "@earendil-works/pi-ai/providers/all";
 import { ModelRuntime } from "@earendil-works/pi-coding-agent";
 var FORMATS = /* @__PURE__ */ new Set(["openai", "openrouter", "deepseek", "together", "baseten", "zai", "qwen", "chat-template", "qwen-chat-template", "string-thinking", "ant-ling"]);
 function installModel(runtime, connection, configured2, headers2 = {}) {
@@ -2617,12 +2935,12 @@ function installModel(runtime, connection, configured2, headers2 = {}) {
   model.headers = { ...model.headers, ...headers2 };
   return model;
 }
-async function modelCatalog(credentials, providerName) {
+async function modelCatalog(credentials, providerName, catalog) {
   const runtime = await ModelRuntime.create({ credentials, modelsPath: null, allowModelNetwork: false, refreshOnCreate: false });
-  return runtime.getModels(providerName).map(publicModel);
+  return catalog.overlay(providerName, runtime.getModels(providerName)).map(publicModel);
 }
-function builtinModelCatalog(providerName) {
-  return (builtinProviders2().find((provider) => provider.id === providerName)?.getModels() ?? []).map(publicModel);
+function providerModels(providers, providerName) {
+  return (providers.find((provider) => provider.id === providerName)?.getModels() ?? []).map(publicModel);
 }
 function catalogCompat(model) {
   const { thinkingFormat: _format, ...compat } = model.compat ?? {};
@@ -2664,12 +2982,12 @@ var CredentialCoordinator = class {
       if (this.tails.get(connectionId) === tail) this.tails.delete(connectionId);
     });
     if (!signal) return operation;
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve5, reject) => {
       const aborted = () => reject(signal.reason);
       signal.addEventListener("abort", aborted, { once: true });
       operation.then((value2) => {
         signal.removeEventListener("abort", aborted);
-        resolve6(value2);
+        resolve5(value2);
       }, (error) => {
         signal.removeEventListener("abort", aborted);
         reject(error);
@@ -2752,7 +3070,6 @@ function resolveThinking(model, choice) {
 }
 
 // src/server/infra/pi/autoconfig.ts
-import { builtinProviders as builtinProviders3 } from "@earendil-works/pi-ai/providers/all";
 var VENDORS = [
   [/^glm/i, ["zai"]],
   [/^deepseek/i, ["deepseek"]],
@@ -2773,23 +3090,20 @@ function officialScore(provider, id) {
   return (id.includes("/") ? 0 : 1) + (words.some((word) => provider.includes(word)) ? 1 : 0);
 }
 var strip = (id) => id.toLowerCase().replace(/^.*\//, "").replace(/-(\d{6,8})$/, "");
-var rows;
-function catalog() {
-  rows ??= builtinProviders3().flatMap((provider) => provider.getModels().map((model) => ({ provider: provider.id, model, official: officialScore(provider.id, model.id) })));
-  return rows;
+function rows(providers) {
+  return providers.flatMap((provider) => provider.getModels().map((model) => ({ provider: provider.id, model, official: officialScore(provider.id, model.id) })));
 }
 var source = (row) => ({ provider: row.provider, modelId: row.model.id, name: row.model.name, api: row.model.api, official: row.official === 2 });
 var completeness = (row) => Object.values(row.model.thinkingLevelMap ?? {}).filter((value2) => value2 !== void 0).length + Object.keys(row.model.compat ?? {}).length + (row.model.cost.input > 0 ? 1 : 0);
-function candidates(query) {
+function candidates(all, 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) {
+function similar(all, query) {
   const q = strip(query);
-  return catalog().map((row) => ({ row, ...similarity(strip(row.model.id), q) })).filter((item) => item.prefix >= 3).sort((a, b) => b.score - a.score || b.row.official - a.row.official).slice(0, 5).map((item) => item.row);
+  return all.map((row) => ({ row, ...similarity(strip(row.model.id), q) })).filter((item) => item.prefix >= 3).sort((a, b) => b.score - a.score || b.row.official - a.row.official).slice(0, 5).map((item) => item.row);
 }
 function similarity(a, b) {
   let prefix = 0;
@@ -2826,14 +3140,14 @@ function matched(row, api, alternatives, reseller) {
     alternatives: alternatives.filter((item) => item !== row).slice(0, 8).map(source)
   };
 }
-function autoconfigure(modelId, api, choice) {
-  const hits = candidates(modelId);
+function autoconfigure(providers, modelId, api, choice) {
+  const all = rows(providers), hits = candidates(all, modelId);
   if (choice) {
-    const row = catalog().find((item) => item.provider === choice.provider && item.model.id === choice.modelId);
+    const row = all.find((item) => item.provider === choice.provider && item.model.id === choice.modelId);
     if (row) return matched(row, api, hits, row.official < 2);
   }
   if (!hits.length) {
-    const options = similar(modelId);
+    const options = similar(all, modelId);
     return options.length ? { status: "choose", reason: "similar", options: options.map(source) } : { status: "none" };
   }
   const official = hits.filter((row) => row.official === 2);
@@ -2917,11 +3231,12 @@ async function discoverModels(input, signal) {
 
 // src/server/service/models/service.ts
 var ModelService = class {
-  constructor(store, credentials, logins, changed) {
+  constructor(store, credentials, logins, changed, models) {
     this.store = store;
     this.credentials = credentials;
     this.logins = logins;
     this.changed = changed;
+    this.models = models;
   }
   required(value2) {
     if (!value2) throw new RuntimeFault("connection_missing", "Connection not found", 404);
@@ -2956,15 +3271,19 @@ var ModelService = class {
     return this.required(this.store.deleteConnectionModel(id, modelId));
   }
   providers() {
-    return providerCatalog();
+    return providerCatalog(this.models.providers());
+  }
+  /** Brings pi.dev's newer catalog entries in the background (A49). */
+  refreshCatalog() {
+    this.models.refresh();
   }
   builtinModels(provider) {
-    return builtinModelCatalog(provider);
+    return providerModels(this.models.providers(), provider);
   }
   async catalog(id) {
     const connection = this.required(this.store.getModelConnection(id));
     const credentials = new ConnectionCredentials(this.store.credentials, this.credentials, this.store.userMemberId(), id, connection.providerName);
-    return modelCatalog(credentials, connection.providerName);
+    return modelCatalog(credentials, connection.providerName, this.models);
   }
   discover(input, signal) {
     if (typeof input.baseUrl !== "string") throw new RuntimeFault("discovery_url_missing", "Enter the API URL.", 400);
@@ -2977,7 +3296,7 @@ var ModelService = class {
     if (!key) throw new RuntimeFault("discovery_key", "Enter the API key.", 400);
     return discoverModels({ api: String(input.api ?? "openai-completions"), baseUrl: input.baseUrl, key }, signal);
   }
-  /** Suggests model fields from the local Pi catalog; the caller decides whether to save them. */
+  /** Suggests model fields from Pi's catalog (with pi.dev's newer entries, A49); the caller decides whether to save them. */
   autoconfigure(input) {
     const text3 = (value2) => typeof value2 === "string" && value2.trim() && value2.length <= 200 ? value2.trim() : null;
     const modelId = text3(input.modelId), api = text3(input.api);
@@ -2989,7 +3308,7 @@ var ModelService = class {
       if (!provider || !chosen) throw new RuntimeFault("autoconfig_source", "The setup source isn't valid.", 400);
       choice = { provider, modelId: chosen };
     }
-    return autoconfigure(modelId, api, choice);
+    return autoconfigure(this.models.providers(), modelId, api, choice);
   }
   options() {
     return this.list().filter((connection) => connection.models.length).map((connection) => ({
@@ -3016,7 +3335,7 @@ var ModelService = class {
 };
 
 // src/server/infra/pi/auth.ts
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 import { ModelRuntime as ModelRuntime2 } from "@earendil-works/pi-coding-agent";
 var CredentialLogins = class {
   constructor(store, credentials, changed) {
@@ -3064,7 +3383,7 @@ var CredentialLogins = class {
   prompt(flow, prompt) {
     const signal = prompt.signal ? AbortSignal.any([flow.controller.signal, prompt.signal]) : flow.controller.signal;
     signal.throwIfAborted();
-    const id = randomUUID8();
+    const id = randomUUID9();
     flow.state.prompt = {
       id,
       type: prompt.type,
@@ -3072,7 +3391,7 @@ var CredentialLogins = class {
       ..."placeholder" in prompt ? { placeholder: prompt.placeholder } : {},
       ...prompt.type === "select" ? { options: prompt.options } : {}
     };
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve5, reject) => {
       const clear = () => {
         signal.removeEventListener("abort", aborted);
         flow.answer = void 0;
@@ -3084,7 +3403,7 @@ var CredentialLogins = class {
       };
       flow.answer = (value2) => {
         clear();
-        resolve6(value2);
+        resolve5(value2);
       };
       signal.addEventListener("abort", aborted, { once: true });
       if (signal.aborted) aborted();
@@ -3149,9 +3468,9 @@ var User = class extends Member {
 };
 
 // src/server/application.ts
-import { createHash as createHash4 } from "node:crypto";
-import { mkdir as mkdir4, realpath as realpath2 } from "node:fs/promises";
-import { join as join7, resolve as resolve4 } from "node:path";
+import { createHash as createHash6 } from "node:crypto";
+import { mkdir as mkdir5, realpath } from "node:fs/promises";
+import { join as join9, resolve as resolve3 } from "node:path";
 import lockfile from "proper-lockfile";
 
 // src/server/service/chat/mentions.ts
@@ -3159,12 +3478,12 @@ var WORD = /[\p{Script=Latin}\p{Nd}_]/u;
 function findMentions(source2, candidates2) {
   const text3 = source2.replace(/```[\s\S]*?```|`[^`\n]*`/g, (code) => " ".repeat(code.length));
   const lower = text3.toLowerCase(), sorted = [...candidates2].sort((a, b) => b.name.length - a.name.length), found = [];
-  for (let at = lower.indexOf("@"); at >= 0; at = lower.indexOf("@", at + 1)) {
-    if (at > 0 && WORD.test(text3[at - 1])) continue;
+  for (let at2 = lower.indexOf("@"); at2 >= 0; at2 = lower.indexOf("@", at2 + 1)) {
+    if (at2 > 0 && WORD.test(text3[at2 - 1])) continue;
     const match = sorted.find((candidate) => {
       const name2 = candidate.name.toLowerCase();
-      if (!name2 || !lower.startsWith(name2, at + 1)) return false;
-      const next = text3[at + 1 + name2.length];
+      if (!name2 || !lower.startsWith(name2, at2 + 1)) return false;
+      const next = text3[at2 + 1 + name2.length];
       return !(next && WORD.test(next) && WORD.test(name2.at(-1)));
     });
     if (match && !found.includes(match)) found.push(match);
@@ -3200,7 +3519,13 @@ 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. The owner moving
+  // a Bot to another work environment stops its running turn like an @, so it doesn't go on in the old place (A50); a
+  // Bot not running, and a change of access alone, hear of it with their next batch instead (fish m1012-m1015).
+  change: { agent: "digest", owner: "interrupt" }
 };
 function urgencyOf(kind, reason) {
   return POLICY[kind][reason];
@@ -3364,8 +3689,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);
@@ -3424,7 +3749,7 @@ var ChatQuestions = class {
     if (question.state === "answered") return Promise.resolve(resultOf(question, question.answer));
     if (question.state === "dismissed") return Promise.resolve({ status: "dismissed" });
     if (question.state === "ignored") return Promise.reject(new ChatError(409, "The question has expired", "question_expired"));
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve5, reject) => {
       const stop = () => {
         this.waiting.delete(message.id);
         if (this.repository.settleQuestion(message.id, "ignored", null)) this.changed(message.chatId);
@@ -3437,7 +3762,7 @@ var ChatQuestions = class {
       signal?.addEventListener("abort", stop, { once: true });
       this.waiting.set(message.id, (result) => {
         signal?.removeEventListener("abort", stop);
-        resolve6(result);
+        resolve5(result);
       });
     });
   }
@@ -3795,13 +4120,13 @@ var ChatService = class {
     return this.repository.getChat(actorId, chatId);
   }
   /** The message with up to `context` messages before and after it (read position unchanged). */
-  around(actorId, messageId, context) {
+  around(actorId, messageId, context2) {
     const message = this.repository.message(actorId, messageId);
     if (!message) throw new ChatError(404, "Message not found");
     return [
-      ...this.repository.messagesBefore(actorId, message.chatId, message.sequence, context),
+      ...this.repository.messagesBefore(actorId, message.chatId, message.sequence, context2),
       message,
-      ...this.repository.messages(actorId, message.chatId, message.sequence, context)
+      ...this.repository.messages(actorId, message.chatId, message.sequence, context2)
     ];
   }
   /** Exactly the unread messages of a chat, oldest first; the caller moves the read position. */
@@ -3818,10 +4143,10 @@ var ChatService = class {
   find(actorId, query, { within, limit = 50 } = {}) {
     const messages = this.searchAll(actorId, query, limit, within);
     const chats = within ? [] : this.repository.searchChatIds(actorId, query.trim(), 30).map((id) => this.repository.getChat(actorId, id)).filter((chat) => chat !== null);
-    const where = /* @__PURE__ */ new Map();
+    const where2 = /* @__PURE__ */ new Map();
     const chatOf = (id) => {
-      if (!where.has(id)) where.set(id, this.repository.getChat(actorId, id));
-      return where.get(id);
+      if (!where2.has(id)) where2.set(id, this.repository.getChat(actorId, id));
+      return where2.get(id);
     };
     return { chats, messages: messages.flatMap((message) => {
       const chat = chatOf(message.chatId);
@@ -3835,10 +4160,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);
@@ -3913,70 +4238,11 @@ var ChatService = class {
   }
 };
 
-// src/server/infra/files/attachments.ts
-import { constants } from "node:fs";
-import { mkdir, open, realpath, rename, rm } from "node:fs/promises";
-import { join as join2, resolve as resolve2 } from "node:path";
-import { randomUUID as randomUUID9 } from "node:crypto";
-var MAX_FILE = 10 * 1024 * 1024;
-var AttachmentFiles = class {
-  constructor(dataDir) {
-    this.dataDir = dataDir;
-  }
-  async materialize(file, signal) {
-    const dir = join2(this.dataDir, "attachments", file.id);
-    await mkdir(dir, { recursive: true, mode: 448 });
-    if (await realpath(dir) !== resolve2(dir)) throw new ChatError(400, "Invalid attachment directory");
-    const path = join2(dir, file.name), temporary = join2(dir, `.${randomUUID9()}.tmp`);
-    try {
-      const handle = await open(temporary, "wx", 384);
-      try {
-        await handle.writeFile(file.data, { signal });
-      } finally {
-        await handle.close();
-      }
-      signal?.throwIfAborted();
-      await rename(temporary, path);
-    } finally {
-      await rm(temporary, { force: true });
-    }
-    return { path, name: file.name };
-  }
-  async readOutgoing(workspace, items, signal) {
-    if (items.length > 5) throw new ChatError(400, "Too many attachments");
-    const result = [];
-    for (const item of items) {
-      signal?.throwIfAborted();
-      const path = await realpath(resolve2(workspace, item.path));
-      const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
-      try {
-        const stat = await handle.stat();
-        if (!stat.isFile() || !stat.size || stat.size > MAX_FILE) throw new ChatError(400, "Invalid attachment size or type");
-        const data = Buffer.alloc(Math.min(MAX_FILE + 1, stat.size + 1));
-        let bytes = 0;
-        while (bytes < data.length) {
-          signal?.throwIfAborted();
-          const read = await handle.read(data, bytes, data.length - bytes, bytes);
-          if (!read.bytesRead) break;
-          bytes += read.bytesRead;
-        }
-        if (bytes !== stat.size) throw new ChatError(409, "Attachment changed while reading");
-        result.push({ name: item.name, mimeType: "application/octet-stream", data: data.subarray(0, bytes) });
-      } finally {
-        await handle.close();
-      }
-    }
-    return result;
-  }
-};
-
 // src/server/service/chat/files.ts
 var ChatFiles = class {
-  constructor(dataDir, chats) {
+  constructor(chats) {
     this.chats = chats;
-    this.files = new AttachmentFiles(dataDir);
   }
-  files;
   async envelope(botId, messageIds, signal) {
     const output = [];
     for (const id of messageIds) {
@@ -4000,7 +4266,7 @@ var ChatFiles = class {
         sender: message.sender,
         content: expandQuotes(message.content, message.quotes, (memberId) => this.chats.member(memberId)?.name ?? memberId),
         createdAt: message.createdAt,
-        attachments: await this.paths(botId, message, signal),
+        attachments: listing(message),
         ...this.reply(message)
       });
     }
@@ -4011,20 +4277,21 @@ var ChatFiles = class {
     const sender = message.replyTo ? this.chats.member(message.replyTo.senderId) : null;
     return message.replyTo && sender ? { replyTo: { id: message.replyTo.id, sender, text: replyExcerpt(message.replyTo) } } : {};
   }
-  async paths(actorId, message, signal) {
-    const paths = [];
-    for (const item of message.attachments) {
-      signal?.throwIfAborted();
-      const attachment = this.chats.download(actorId, item.id);
-      if (!attachment) throw new ChatError(404, "Attachment not found");
-      paths.push(await this.files.materialize({ ...attachment, id: item.id, name: item.name }, signal));
-    }
-    return paths;
-  }
-  readOutgoing(workspace, items, signal) {
-    return this.files.readOutgoing(workspace, items, signal);
+  /** A file of a message the actor can read, with its contents. */
+  open(actorId, attachmentId) {
+    const found = this.chats.download(actorId, attachmentId);
+    if (!found) throw new ChatError(404, "File not found, or in a message you can't read");
+    return found;
   }
 };
+function listing(message) {
+  return message.attachments.map((file) => ({ id: file.id, name: file.name, type: file.mimeType || "application/octet-stream", size: byteSize(file.size) }));
+}
+function byteSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
 
 // src/server/service/events.ts
 var Changes = class {
@@ -4049,8 +4316,8 @@ var Changes = class {
 // src/server/service/bot/activity.ts
 function activityPage(messages, history, limit) {
   const candidates2 = [
-    ...messages.map((record2) => ({ kind: "chat", record: record2 })),
-    ...history.map((record2) => ({ kind: "history", record: record2 }))
+    ...messages.map((record3) => ({ kind: "chat", record: record3 })),
+    ...history.map((record3) => ({ kind: "history", record: record3 }))
   ];
   candidates2.sort((a, b) => {
     if (a.record.timestamp !== b.record.timestamp) return b.record.timestamp - a.record.timestamp;
@@ -4063,8 +4330,8 @@ function activityPage(messages, history, limit) {
 }
 
 // src/server/service/bot/service.ts
-import { dirname as dirname5, join as join6 } from "node:path";
-import { rm as rm2 } from "node:fs/promises";
+import { dirname as dirname7, join as join8 } from "node:path";
+import { rm as rm3 } from "node:fs/promises";
 
 // src/server/infra/pi/history.ts
 var value = (input) => JSON.parse(JSON.stringify(input));
@@ -4181,7 +4448,7 @@ var PiHistoryAdapter = class {
 // src/server/infra/pi/session.ts
 import { existsSync, readFileSync } from "node:fs";
 import { mkdir as mkdir2 } from "node:fs/promises";
-import { dirname as dirname2, join as join3, resolve as resolve3, sep } from "node:path";
+import { dirname as dirname3, join as join3, resolve as resolve2, sep } from "node:path";
 import { createAgentSession, createCodemodeExtension, DefaultResourceLoader, ModelRuntime as ModelRuntime3, SessionManager, SettingsManager } from "@earendil-works/pi-coding-agent";
 
 // src/server/infra/pi/http.ts
@@ -4207,6 +4474,9 @@ function configureHttp(timeoutMs) {
 // src/server/infra/pi/session.ts
 import { Type } from "typebox";
 
+// src/server/shared/tools.ts
+var isToolMedia = (value2) => !!value2 && typeof value2 === "object" && value2.kind === "media" && Array.isArray(value2.images);
+
 // src/server/infra/pi/live.ts
 var LiveTranslator = class {
   message = 0;
@@ -4269,6 +4539,130 @@ function resultText(result) {
   }
 }
 
+// src/server/infra/pi/environment-tools.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import { readFile as readLocal, rm } from "node:fs/promises";
+import { basename } from "node:path";
+import { createBashToolDefinition, createEditToolDefinition, createReadToolDefinition, createWriteToolDefinition } from "@earendil-works/pi-coding-agent";
+
+// src/server/infra/pi/image-kind.ts
+var IMAGE_SNIFF_BYTES = 4100;
+function imageKind(bytes) {
+  if (startsWith(bytes, [255, 216, 255])) return bytes[3] === 247 ? null : "image/jpeg";
+  if (startsWith(bytes, PNG)) return isPng(bytes) && !isAnimatedPng(bytes) ? "image/png" : null;
+  if (ascii(bytes, 0, "GIF87a") || ascii(bytes, 0, "GIF89a")) return "image/gif";
+  if (ascii(bytes, 0, "RIFF") && ascii(bytes, 8, "WEBP")) return "image/webp";
+  if (ascii(bytes, 0, "BM") && isBmp(bytes)) return "image/bmp";
+  return null;
+}
+var PNG = [137, 80, 78, 71, 13, 10, 26, 10];
+var isPng = (bytes) => bytes.length >= 16 && u32be(bytes, PNG.length) === 13 && ascii(bytes, 12, "IHDR");
+function isAnimatedPng(bytes) {
+  let offset = PNG.length;
+  while (offset + 8 <= bytes.length) {
+    const length = u32be(bytes, offset), type = offset + 4;
+    if (ascii(bytes, type, "acTL")) return true;
+    if (ascii(bytes, type, "IDAT")) return false;
+    const next = offset + 8 + length + 4;
+    if (next <= offset || next > bytes.length) return false;
+    offset = next;
+  }
+  return false;
+}
+function isBmp(bytes) {
+  if (bytes.length < 26) return false;
+  const size = u32le(bytes, 2), pixels = u32le(bytes, 10), header = u32le(bytes, 14);
+  if (size !== 0 && size < 26) return false;
+  if (pixels < 14 + header) return false;
+  if (size !== 0 && pixels >= size) return false;
+  let planes, bits;
+  if (header === 12) {
+    planes = u16le(bytes, 22);
+    bits = u16le(bytes, 24);
+  } else if (header >= 40 && header <= 124) {
+    if (bytes.length < 30) return false;
+    planes = u16le(bytes, 26);
+    bits = u16le(bytes, 28);
+  } else return false;
+  return planes === 1 && [1, 4, 8, 16, 24, 32].includes(bits);
+}
+var at = (bytes, offset) => bytes[offset] ?? 0;
+var u16le = (bytes, offset) => at(bytes, offset) + (at(bytes, offset + 1) << 8);
+var u32be = (bytes, offset) => at(bytes, offset) * 16777216 + (at(bytes, offset + 1) << 16) + (at(bytes, offset + 2) << 8) + at(bytes, offset + 3);
+var u32le = (bytes, offset) => at(bytes, offset) + (at(bytes, offset + 1) << 8) + (at(bytes, offset + 2) << 16) + at(bytes, offset + 3) * 16777216;
+var startsWith = (bytes, prefix) => bytes.length >= prefix.length && prefix.every((byte, index) => bytes[index] === byte);
+function ascii(bytes, offset, text3) {
+  if (bytes.length < offset + text3.length) return false;
+  for (let index = 0; index < text3.length; index++) if (bytes[offset + index] !== text3.charCodeAt(index)) return false;
+  return true;
+}
+
+// src/server/infra/pi/environment-tools.ts
+function environmentTools(lookup) {
+  const pinned = new AsyncLocalStorage();
+  const current = () => pinned.getStore() ?? lookup();
+  const access = async (path) => {
+    if (!await current().exists(path)) throw Object.assign(new Error(`ENOENT: no such file or directory, access '${path}'`), { code: "ENOENT" });
+  };
+  const readFile3 = (path) => current().readFile(path), writeFile4 = (path, content2) => current().writeFile(path, content2);
+  const cwd = current().cwd;
+  const definitions2 = [
+    relocated(createBashToolDefinition(cwd, { operations: {
+      exec: (command, dir, { onData, signal, timeout, env }) => current().exec(command, {
+        cwd: dir,
+        onData,
+        ...signal ? { signal } : {},
+        ...timeout ? { timeout } : {},
+        ...env ? { env: defined(env) } : {}
+      })
+    } }), current),
+    // Pictures go to the model as pictures; the kind comes from a file's first bytes, as Pi's local read does.
+    createReadToolDefinition(cwd, { operations: { readFile: readFile3, access, detectImageMimeType: async (path) => imageKind(await current().head(path, IMAGE_SNIFF_BYTES)) } }),
+    createWriteToolDefinition(cwd, { operations: { writeFile: writeFile4, mkdir: (path) => current().mkdir(path) } }),
+    createEditToolDefinition(cwd, { operations: { readFile: readFile3, writeFile: writeFile4, access } })
+  ];
+  return definitions2.map((definition) => inside(definition, lookup, pinned));
+}
+function inside(definition, lookup, pinned) {
+  const execute = definition.execute.bind(definition);
+  return { ...definition, execute: ((...args) => {
+    const env = lookup(), ctx = args[4];
+    if (ctx && typeof ctx === "object") args[4] = new Proxy(ctx, { get: (target2, key) => key === "cwd" ? env.cwd : Reflect.get(target2, key, target2) });
+    return pinned.run(env, () => execute(...args));
+  }) };
+}
+function relocated(definition, current) {
+  const execute = definition.execute.bind(definition);
+  return { ...definition, execute: (async (...args) => {
+    const env = current();
+    if (env.kind === "host") return execute(...args);
+    try {
+      const result = await execute(...args), path = result.details?.fullOutputPath;
+      if (typeof path !== "string") return result;
+      const target2 = await moveOut(path, env), swap = (text3) => text3?.replaceAll(path, target2);
+      return {
+        ...result,
+        content: result.content.map((part) => part.type === "text" ? { ...part, text: swap(part.text) } : part),
+        details: { ...result.details, fullOutputPath: target2 },
+        ...result.structuredContent?.full_output_path ? { structuredContent: { ...result.structuredContent, full_output_path: target2 } } : {}
+      };
+    } catch (error) {
+      const path = error instanceof Error ? /Full output: (\S+?)\]/.exec(error.message)?.[1] : void 0;
+      if (!path) throw error;
+      throw new Error(error.message.replaceAll(path, await moveOut(path, env)));
+    }
+  }) };
+}
+async function moveOut(path, env) {
+  const target2 = `${env.cwd}/temp/${basename(path)}`;
+  await env.writeFile(target2, await readLocal(path));
+  await rm(path, { force: true });
+  return target2;
+}
+function defined(vars) {
+  return Object.fromEntries(Object.entries(vars).filter((entry) => entry[1] !== void 0));
+}
+
 // src/server/infra/pi/session.ts
 var HTTP_IDLE_TIMEOUT_MS = 9e5;
 function compactionReserve(contextWindow) {
@@ -4309,10 +4703,10 @@ var PiSession = class _PiSession {
   }
   static async create(options) {
     const { bot, store, reference, selection } = options;
-    const agentDir = join3(dirname2(bot.workspacePath), "agent", "pi"), sessionsDir = join3(agentDir, "sessions");
+    const agentDir = join3(dirname3(bot.workspacePath), "agent", "pi"), sessionsDir = join3(agentDir, "sessions");
     await mkdir2(sessionsDir, { recursive: true, mode: 448 });
-    const expected = resolve3(sessionsDir) + sep;
-    if (!resolve3(reference.file).startsWith(expected) || dirname2(resolve3(reference.file)) !== resolve3(sessionsDir))
+    const expected = resolve2(sessionsDir) + sep;
+    if (!resolve2(reference.file).startsWith(expected) || dirname3(resolve2(reference.file)) !== resolve2(sessionsDir))
       throw new RuntimeFault("session_path", "The session file path isn't valid.");
     const exists = existsSync(reference.file);
     if (!exists && (reference.persisted || store.runtime.runs(bot.id).some((run) => run.state === "unknown")))
@@ -4363,6 +4757,10 @@ var PiSession = class _PiSession {
           executionMode: "sequential",
           execute: async (toolCallId, args, signal) => {
             const output = await tool.execute(args, { toolCallId, signal });
+            if (isToolMedia(output)) return { content: [
+              { type: "text", text: output.text },
+              ...output.images.map((image) => ({ type: "image", data: image.data, mimeType: image.mimeType }))
+            ], details: {} };
             return { content: [{ type: "text", text: typeof output === "string" ? output : JSON.stringify(output) }], details: {} };
           }
         });
@@ -4379,7 +4777,8 @@ var PiSession = class _PiSession {
       modelRuntime: models,
       model,
       thinkingLevel: resolveThinking(model, selection.thinkingLevel),
-      tools
+      tools,
+      customTools: environmentTools(options.environment)
     });
     adapter.session = result.session;
     adapter.settings = settingsManager;
@@ -4396,8 +4795,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 record2 = history.convert(entry);
-          if (record2) await options.onHistory(record2);
+          const record3 = history.convert(entry);
+          if (record3) await options.onHistory(record3);
           break;
         }
       });
@@ -4444,7 +4843,7 @@ var PiSession = class _PiSession {
   }
   /** The last assistant message decides the prompt (a later retry success replaces an earlier error).
    * pi-ai providers and Agent.handleRunFailure report a failure as "aborted" when the run's signal was
-   * cancelled, but Pi 0.99.1's lazyStream reports request-setup failures as "error" regardless — e.g. the
+   * cancelled, but Pi 1.2.0's lazyStream reports request-setup failures as "error" regardless — e.g. the
    * request that follows a tool cancelled mid-run. Apply the same signal rule to those. */
   classify(message) {
     if (message.stopReason === "aborted" || message.stopReason === "error" && this.session.agent.signal?.aborted) return { outcome: "interrupted" };
@@ -4480,8 +4879,8 @@ var PiSession = class _PiSession {
     this.wantsAbort = false;
     this.abortFailure = void 0;
     this.result = { outcome: "completed" };
-    const settled = new Promise((resolve6) => {
-      this.settledResolve = resolve6;
+    const settled = new Promise((resolve5) => {
+      this.settledResolve = resolve5;
     });
     this.options.live?.({ type: "start" });
     let outcome = "failed";
@@ -4536,10 +4935,617 @@ var PiSession = class _PiSession {
   }
 };
 
+// src/server/infra/env/docker.ts
+import { execFile, spawn } from "node:child_process";
+import { createHash as createHash3 } from "node:crypto";
+import { createWriteStream } from "node:fs";
+import { mkdir as mkdir3, mkdtemp, readFile as readFile2, rename as rename2, rm as rm2, writeFile as writeFile2 } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join as join4 } from "node:path";
+import { Connection, RemoteExecutionEnv, packagedDaemon } from "@earendil-works/pi-env";
+
+// src/server/infra/env/computer-image.ts
+var COMPUTER_DOCKERFILE = `FROM mcr.microsoft.com/playwright:v1.61.1-noble
+ARG UID=1000
+ARG GID=1000
+RUN apt-get update \\
+ && apt-get install -y --no-install-recommends build-essential ca-certificates curl fonts-noto-cjk git python3 python3-dev python3-pip python3-venv sudo \\
+ && rm -rf /var/lib/apt/lists/* \\
+ && npm install -g playwright@1.61.1 && npm cache clean --force \\
+ && taken="$(getent passwd "$UID" | cut -d: -f1)"; if [ -n "$taken" ]; then userdel -r "$taken" 2>/dev/null || userdel "$taken"; fi \\
+ && (getent group "$GID" > /dev/null || groupadd -g "$GID" bot) \\
+ && useradd -m -d /workspace -u "$UID" -g "$GID" -s /bin/bash bot \\
+ && install -d -o "$UID" -g "$GID" /home/bot/.npm-global /home/bot/.npm-global/bin /home/bot/.npm-global/lib \\
+ && echo "bot ALL=(ALL) NOPASSWD:ALL" > /etc/sudoers.d/bot && chmod 0440 /etc/sudoers.d/bot \\
+ && mkdir -p /workspace && chown "$UID:$GID" /workspace
+ENV NPM_CONFIG_PREFIX=/home/bot/.npm-global PATH=/home/bot/.npm-global/bin:$PATH \\
+    NODE_PATH=/home/bot/.npm-global/lib/node_modules:/usr/lib/node_modules
+USER bot
+WORKDIR /workspace
+`;
+
+// src/server/infra/env/durable.ts
+import { BACKGROUND_CONTEXT, withAbortSignal } from "@earendil-works/chord/context";
+function overDurable(id, kind, env, options) {
+  let closed = false;
+  return {
+    id,
+    kind,
+    cwd: env.cwd,
+    async exec(command, exec) {
+      const result = await env.exec(command, {
+        cwd: exec.cwd,
+        ...options.passEnv && exec.env ? { env: exec.env, inheritEnv: false } : { inheritEnv: true },
+        ...exec.timeout ? { timeout: exec.timeout } : {},
+        onOutput: (text3) => exec.onData(Buffer.from(text3))
+      }, context(exec.signal));
+      if (result.ok) return { exitCode: result.value.exitCode };
+      if (result.error.code === "aborted") throw new Error("aborted");
+      if (result.error.code === "timeout") throw new Error(`timeout:${exec.timeout}`);
+      throw fault(result.error);
+    },
+    async readFile(path) {
+      return Buffer.from(unwrap(await env.readBinaryFile(path, BACKGROUND_CONTEXT)));
+    },
+    async head(path, bytes) {
+      const reader = unwrap(await env.openBinaryReader(path, void 0, BACKGROUND_CONTEXT));
+      try {
+        return Buffer.from(unwrap(await reader.read(0, bytes, BACKGROUND_CONTEXT)));
+      } finally {
+        await reader.close(BACKGROUND_CONTEXT);
+      }
+    },
+    async writeFile(path, content2) {
+      unwrap(await env.writeFile(path, content2, BACKGROUND_CONTEXT));
+    },
+    async mkdir(path) {
+      unwrap(await env.createDir(path, { recursive: true }, BACKGROUND_CONTEXT));
+    },
+    async exists(path) {
+      return unwrap(await env.exists(path, BACKGROUND_CONTEXT));
+    },
+    async fileSize(path) {
+      const real = await env.canonicalPath(path, BACKGROUND_CONTEXT);
+      if (!real.ok) {
+        if (real.error.code === "not_found") return null;
+        throw fault(real.error);
+      }
+      const info = unwrap(await env.fileInfo(real.value, BACKGROUND_CONTEXT));
+      return info.kind === "file" ? info.size : null;
+    },
+    async close() {
+      if (closed) return;
+      closed = true;
+      await options.close?.();
+    }
+  };
+}
+var context = (signal) => signal ? withAbortSignal(signal, BACKGROUND_CONTEXT) : BACKGROUND_CONTEXT;
+function unwrap(result) {
+  if (result.ok) return result.value;
+  throw fault(result.error);
+}
+function fault(error) {
+  return Object.assign(new Error(error.message), { code: error.code });
+}
+
+// src/server/infra/env/docker.ts
+var COMPUTER_CWD = "/workspace";
+var DAEMON_DIR = "/opt/jarvy";
+function docker(args, timeoutMs = 6e4) {
+  return new Promise((resolve5, reject) => execFile("docker", args, { timeout: timeoutMs, maxBuffer: 8 << 20 }, (error, stdout, stderr) => {
+    if (error) reject(Object.assign(new Error((stderr || error.message).trim().split("\n").at(-1) ?? "docker failed"), { code: "docker_failed" }));
+    else resolve5(stdout.trim());
+  }));
+}
+async function dockerAvailable() {
+  try {
+    await docker(["version", "--format", "{{.Server.Version}}"], 1e4);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function computerImage(uid, gid) {
+  return `jarvy-computer:${createHash3("sha256").update(`${COMPUTER_DOCKERFILE}
+${uid}:${gid}`).digest("hex").slice(0, 12)}`;
+}
+async function pruneImages(keep) {
+  const tags = (await docker(["images", "--filter", "label=jarvy.computer=1", "--format", "{{.Repository}}:{{.Tag}}"])).split("\n").filter(Boolean);
+  const removed = [];
+  for (const tag of tags) if (tag !== keep) {
+    try {
+      await docker(["image", "rm", tag], 12e4);
+      removed.push(tag);
+    } catch {
+    }
+  }
+  return removed;
+}
+async function imageExists(tag) {
+  try {
+    await docker(["image", "inspect", "--format", "{{.Id}}", tag]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function buildImage(tag, uid, gid, logFile) {
+  const dir = await mkdtemp(join4(tmpdir(), "jarvy-computer-"));
+  try {
+    await writeFile2(join4(dir, "Dockerfile"), COMPUTER_DOCKERFILE);
+    const log = createWriteStream(logFile, { flags: "w", mode: 384 });
+    const code = await new Promise((resolve5, reject) => {
+      const child = spawn(
+        "docker",
+        ["build", "-t", tag, "--label", "jarvy.computer=1", "--build-arg", `UID=${uid}`, "--build-arg", `GID=${gid}`, dir],
+        { stdio: ["ignore", "pipe", "pipe"] }
+      );
+      child.stdout.pipe(log, { end: false });
+      child.stderr.pipe(log, { end: false });
+      child.on("error", reject);
+      child.on("close", resolve5);
+    }).finally(() => log.end());
+    if (code !== 0) throw Object.assign(new Error(`docker build exited with ${code}`), { code: "docker_failed" });
+  } finally {
+    await rm2(dir, { recursive: true, force: true });
+  }
+}
+async function containerStates(label) {
+  const out = await docker(["ps", "-a", "--filter", `label=${label}`, "--format", "{{.Names}}	{{.State}}"]);
+  const states = /* @__PURE__ */ new Map();
+  for (const line of out.split("\n").filter(Boolean)) {
+    const [name2, state] = line.split("	");
+    if (name2) states.set(name2, state === "running" ? "running" : "stopped");
+  }
+  return states;
+}
+async function containerState(name2) {
+  try {
+    return await docker(["inspect", "--format", "{{.State.Running}}", name2]) === "true" ? "running" : "stopped";
+  } catch (error) {
+    if (/no such (object|container)/i.test(error.message)) return "missing";
+    throw error;
+  }
+}
+async function runContainer(spec) {
+  await docker([
+    "run",
+    "-d",
+    "--name",
+    spec.name,
+    "--init",
+    "--user",
+    `${spec.uid}:${spec.gid}`,
+    "--shm-size",
+    "1g",
+    ...Object.entries(spec.labels).flatMap(([key, value2]) => ["--label", `${key}=${value2}`]),
+    "-v",
+    `${spec.workspace}:${COMPUTER_CWD}`,
+    "-v",
+    `${spec.daemonDir}:${DAEMON_DIR}:ro`,
+    "-w",
+    COMPUTER_CWD,
+    spec.image,
+    "sleep",
+    "infinity"
+  ], 12e4);
+}
+async function startContainer(name2) {
+  await docker(["start", name2], 6e4);
+}
+async function homeAtWorkspace(name2) {
+  const home = await docker(["exec", name2, "sh", "-c", "getent passwd bot | cut -d: -f6"], 3e4);
+  if (home !== COMPUTER_CWD) await docker(["exec", "-u", "root", name2, "usermod", "-d", COMPUTER_CWD, "bot"], 3e4);
+}
+async function stopContainer(name2) {
+  await docker(["stop", "--time", "5", name2], 6e4);
+}
+async function removeContainer(name2) {
+  try {
+    await docker(["rm", "--force", name2], 6e4);
+  } catch (error) {
+    if (!/no such (object|container)/i.test(error.message)) throw error;
+  }
+}
+async function syncDaemon(dir) {
+  const arch = process.arch === "arm64" ? "arm64" : "x64";
+  const wanted = await readFile2(packagedDaemon({ platform: "linux", arch }));
+  const target2 = join4(dir, "pi-env");
+  const current = await readFile2(target2).catch(() => null);
+  if (current?.equals(wanted)) return;
+  await mkdir3(dir, { recursive: true, mode: 448 });
+  const temp = `${target2}.${process.pid}.tmp`;
+  await writeFile2(temp, wanted, { mode: 493 });
+  await rename2(temp, target2);
+}
+function containerEnvironment(id, container, log) {
+  const connection = new Connection({ command: ["docker", "exec", "-i", container, `${DAEMON_DIR}/pi-env`], onLog: (text3) => log(text3.trim()) });
+  return overDurable(id, "computer", new RemoteExecutionEnv({ connection, id, cwd: COMPUTER_CWD }), { passEnv: false, close: () => connection.close() });
+}
+
+// src/server/infra/env/host.ts
+import { NodeExecutionEnv } from "@earendil-works/pi-durable/env/node";
+function hostEnvironment(cwd) {
+  return overDurable("host", "host", new NodeExecutionEnv({ cwd }), { passEnv: true });
+}
+
+// src/server/service/bot/environments.ts
+var ABOUT = {
+  computer: "A Linux container only you use, with Node, Python, git, build tools, and Playwright with its browsers. You can install software there with sudo; it stays until the owner resets your sandbox, and /workspace, your home there, is kept when it is reset.",
+  host: "The machine running Jarvy. Your tools run there as your owner and can reach their files: work in your directory, and leave other members' workspaces, live data directories (such as ~/.jarvy), main repository checkouts and system directories alone unless the task needs it; say in your reply what you changed there."
+};
+var BotEnvironments = class {
+  constructor(store, computers) {
+    this.store = store;
+    this.computers = computers;
+  }
+  open = /* @__PURE__ */ new Map();
+  current(botId, workspacePath) {
+    const target2 = this.store.environments.placement(botId).current;
+    const open = this.open.get(botId);
+    if (open?.id === target2.id) return open.view;
+    if (open) this.retire(open);
+    const opened = this.track(target2.id, target2.kind === "computer" ? this.computers.environment(target2.botId ?? botId, target2) : hostEnvironment(workspacePath));
+    this.open.set(botId, opened);
+    return opened.view;
+  }
+  placement(botId) {
+    const environments = this.store.environments, { home, current } = environments.placement(botId);
+    const hostId = environments.host().id;
+    return {
+      home: home.kind,
+      current: current.kind,
+      computer: this.computers.status(botId),
+      docker: this.computers.available,
+      hostGranted: environments.grants(botId).some((grant) => grant.id === hostId)
+    };
+  }
+  /** The environments the Bot may be in: its sandbox, its default, and the ones its owner granted it. */
+  usable(botId) {
+    const environments = this.store.environments;
+    const all = [environments.computerOf(botId), environments.placement(botId).home, ...environments.grants(botId)];
+    return [...new Map(all.filter((record3) => !!record3).map((record3) => [record3.id, record3])).values()];
+  }
+  place(botId, record3, workspacePath) {
+    if (record3.kind === "host") return { id: record3.id, kind: "host", name: "your owner's computer", directory: workspacePath };
+    return { id: record3.id, kind: "sandbox", name: record3.botId === botId ? "your sandbox" : "another Bot's sandbox", directory: COMPUTER_CWD };
+  }
+  /** A Bot's environments as other Bots see them in bots.list. */
+  summary(botId) {
+    const name2 = (record3) => record3.kind === "host" ? "owner's computer" : record3.botId === botId ? "own sandbox" : "another Bot's sandbox";
+    const { home, current } = this.store.environments.placement(botId);
+    return { default: name2(home), current: name2(current), usable: this.usable(botId).map(name2) };
+  }
+  /** The Bot's default environment, which its instructions describe. */
+  home(botId, workspacePath) {
+    return this.place(botId, this.store.environments.placement(botId).home, workspacePath);
+  }
+  /** Where the Bot works now, for the end of each batch. */
+  here(botId, workspacePath) {
+    return this.place(botId, this.store.environments.placement(botId).current, workspacePath);
+  }
+  /** environments.list: where the Bot is and where else it may go. */
+  list(botId, workspacePath) {
+    const { home, current } = this.store.environments.placement(botId);
+    return { current: current.id, environments: this.usable(botId).map((record3) => ({
+      ...this.place(botId, record3, workspacePath),
+      ...record3.id === home.id ? { default: true } : {},
+      ...record3.kind === "computer" ? { state: this.computers.status(record3.botId ?? botId)?.state ?? "stopped" } : {}
+    })) };
+  }
+  /** environments.switch: the Bot moves itself, like cd, until it switches back. A sandbox is started first; if it
+   * can't start, the Bot stays where it was. */
+  async switch(botId, environmentId, workspacePath) {
+    const target2 = this.usable(botId).find((record3) => record3.id === environmentId);
+    if (!target2) throw new ChatError(404, "No work environment with this id that you may use; see environments.list");
+    const already = this.store.environments.placement(botId).current.id === target2.id;
+    if (target2.kind === "computer") await this.computers.ensure(target2.botId ?? botId);
+    this.store.environments.setCurrent(botId, target2.id);
+    return { ...this.place(botId, target2, workspacePath), about: ABOUT[target2.kind], ...already ? { note: "You were already here." } : {} };
+  }
+  /** The owner makes the Bot's sandbox (given it on first use) or their computer its default, and moves it there. */
+  setHome(botId, kind, workspacePath) {
+    const environments = this.store.environments, from = this.here(botId, workspacePath);
+    if (kind === "host") environments.setHome(botId, environments.host().id);
+    else {
+      const computer = environments.computerOf(botId);
+      if (computer) {
+        environments.setHome(botId, computer.id);
+        void this.computers.ensure(botId).catch(() => {
+        });
+      } else this.computers.create(botId);
+    }
+    const to = this.here(botId, workspacePath);
+    return from.id === to.id ? null : { from, to };
+  }
+  /** The owner grants or takes back their computer (A50); taking it back while the Bot works there sends it home. */
+  grantHost(botId, granted, by, workspacePath) {
+    const environments = this.store.environments, host = environments.host();
+    if (granted) return { changed: environments.grant(host.id, botId, by), moved: null };
+    const changed = environments.revoke(host.id, botId), { home, current } = environments.placement(botId);
+    if (current.id !== host.id || home.id === host.id) return { changed, moved: null };
+    const from = this.here(botId, workspacePath);
+    environments.setCurrent(botId, home.id);
+    return { changed, moved: { from, to: this.here(botId, workspacePath) } };
+  }
+  async release(botId) {
+    const open = this.open.get(botId);
+    this.open.delete(botId);
+    await open?.env.close();
+    await this.computers.remove(botId);
+  }
+  async close() {
+    const all = [...this.open.values()];
+    this.open.clear();
+    await Promise.all(all.map((open) => open.env.close()));
+    await this.computers.close();
+  }
+  retire(open) {
+    open.retired = true;
+    if (!open.busy) void open.env.close();
+  }
+  /** Counts the operations running on an environment, so one the Bot has left closes only when they are done. */
+  track(id, env) {
+    const opened = { id, env, view: env, busy: 0, retired: false };
+    const run = async (work) => {
+      opened.busy++;
+      try {
+        return await work();
+      } finally {
+        if (--opened.busy === 0 && opened.retired) void env.close();
+      }
+    };
+    opened.view = {
+      id: env.id,
+      kind: env.kind,
+      cwd: env.cwd,
+      exec: (command, options) => run(() => env.exec(command, options)),
+      readFile: (path) => run(() => env.readFile(path)),
+      head: (path, bytes) => run(() => env.head(path, bytes)),
+      writeFile: (path, content2) => run(() => env.writeFile(path, content2)),
+      mkdir: (path) => run(() => env.mkdir(path)),
+      exists: (path) => run(() => env.exists(path)),
+      fileSize: (path) => run(() => env.fileSize(path)),
+      close: () => env.close()
+    };
+    return opened;
+  }
+};
+
+// src/server/service/bot/computers.ts
+import { createHash as createHash4 } from "node:crypto";
+import { dirname as dirname4, join as join5 } from "node:path";
+var SWEEP_MS = 6e4;
+var Computers = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.dataDir = dirname4(deps.store.path);
+    this.tag = createHash4("sha256").update(this.dataDir).digest("hex").slice(0, 12);
+  }
+  docker = null;
+  probing = null;
+  image = null;
+  timer = null;
+  states = /* @__PURE__ */ new Map();
+  preparing = /* @__PURE__ */ new Map();
+  connections = /* @__PURE__ */ new Map();
+  /** Containers whose home was checked since Jarvy started (`homeAtWorkspace`). */
+  homes = /* @__PURE__ */ new Map();
+  dataDir;
+  /** Tells this Jarvy's containers from those of other data directories on the same Docker. */
+  tag;
+  uid = process.getuid?.() ?? 1e3;
+  gid = process.getgid?.() ?? 1e3;
+  /** Looks for Docker and learns the state of every computer, once; every computer waits for it. */
+  start() {
+    this.probing ??= this.probe();
+    return this.probing;
+  }
+  async probe() {
+    this.docker = await dockerAvailable();
+    if (!this.docker) return;
+    try {
+      await syncDaemon(join5(this.dataDir, "computers", "bin"));
+    } catch (error) {
+      this.docker = false;
+      this.log(`computers disabled: ${error.message}`);
+      return;
+    }
+    await this.sweep().catch((error) => this.log(`computer sweep failed: ${error.message}`));
+    this.timer = setInterval(() => void this.sweep().catch((error) => this.log(`computer sweep failed: ${error.message}`)), SWEEP_MS);
+    this.timer.unref();
+  }
+  /** Whether new computers can be made here; false until `start` found Docker. */
+  get available() {
+    return this.docker === true;
+  }
+  status(botId) {
+    if (!this.deps.store.environments.computerOf(botId)) return null;
+    if (!this.available) return { state: "unavailable" };
+    return this.states.get(botId) ?? { state: "stopped" };
+  }
+  /** Gives a Bot its computer and makes it the Bot's default environment; the container is made in the background. */
+  create(botId) {
+    if (!this.available) throw new RuntimeFault("docker_unavailable", "Docker is not available on this machine.", 409);
+    const computer = this.deps.store.environments.addComputer(botId, `jarvy-${this.tag.slice(0, 6)}-${botId.slice(0, 8)}`);
+    this.deps.store.environments.setHome(botId, computer.id);
+    void this.ensure(botId).catch(() => {
+    });
+  }
+  /** What the Bot's tools use while it works on its computer: every call first makes sure the container runs. */
+  environment(botId, record3) {
+    const run = async (op) => {
+      try {
+        return await op(await this.connect(botId, record3));
+      } catch (error) {
+        if (error instanceof RuntimeFault || await containerState(record3.spec.container).catch(() => "missing") === "running") throw error;
+        await this.disconnect(botId);
+        this.set(botId, { state: "stopped" });
+        return op(await this.connect(botId, record3));
+      }
+    };
+    return {
+      id: record3.id,
+      kind: "computer",
+      cwd: COMPUTER_CWD,
+      exec: (command, options) => run((env) => env.exec(command, options)),
+      readFile: (path) => run((env) => env.readFile(path)),
+      head: (path, bytes) => run((env) => env.head(path, bytes)),
+      writeFile: (path, content2) => run((env) => env.writeFile(path, content2)),
+      mkdir: (path) => run((env) => env.mkdir(path)),
+      exists: (path) => run((env) => env.exists(path)),
+      fileSize: (path) => run((env) => env.fileSize(path)),
+      close: () => this.disconnect(botId)
+    };
+  }
+  async connect(botId, record3) {
+    const container = await this.ensure(botId);
+    let home = this.homes.get(container);
+    if (!home) {
+      home = homeAtWorkspace(container).catch((error) => this.log(`home of ${botId} not moved: ${error.message}`));
+      this.homes.set(container, home);
+    }
+    await home;
+    let env = this.connections.get(botId);
+    if (!env) {
+      env = containerEnvironment(record3.id, container, (text3) => this.log(`[${botId.slice(0, 8)}] ${text3}`));
+      this.connections.set(botId, env);
+    }
+    return env;
+  }
+  /** Makes sure the container exists and runs, building the image first when needed; returns its name. */
+  ensure(botId) {
+    const pending = this.preparing.get(botId);
+    if (pending) return pending;
+    const computer = this.deps.store.environments.computerOf(botId);
+    if (!computer) return Promise.reject(new RuntimeFault("computer_missing", "This Bot has no sandbox.", 404));
+    const container = computer.spec.container;
+    if (this.states.get(botId)?.state === "running") return Promise.resolve(container);
+    if (this.docker !== false) this.set(botId, { state: "preparing" });
+    const task = (async () => {
+      try {
+        await this.start();
+        if (!this.available) throw new RuntimeFault("docker_unavailable", "Docker is not available on this machine.", 503);
+        const image = await this.imageReady();
+        const state = await containerState(container);
+        if (state === "missing") await runContainer({
+          name: container,
+          image,
+          workspace: join5(this.dataDir, "bots", botId, "workspace"),
+          daemonDir: join5(this.dataDir, "computers", "bin"),
+          uid: this.uid,
+          gid: this.gid,
+          labels: { "jarvy.data": this.tag, "jarvy.bot": botId }
+        });
+        else if (state === "stopped") await startContainer(container);
+        this.set(botId, { state: "running" });
+        return container;
+      } catch (error) {
+        this.set(botId, { state: "failed", error: error instanceof RuntimeFault ? error.code : "computer_failed" });
+        this.log(`computer of ${botId} failed: ${error.message}`);
+        if (error instanceof RuntimeFault) throw error;
+        throw new RuntimeFault("computer_failed", `Your sandbox could not start: ${error.message}`, 503);
+      }
+    })().finally(() => this.preparing.delete(botId));
+    this.preparing.set(botId, task);
+    return task;
+  }
+  async stop(botId) {
+    const computer = this.need(botId);
+    await this.disconnect(botId);
+    await stopContainer(computer.spec.container);
+    this.set(botId, { state: "stopped" });
+  }
+  /** Removes the container, so the next start makes a fresh one from the image: what was installed goes, the
+   * workspace stays. */
+  async reset(botId) {
+    const computer = this.need(botId);
+    await this.disconnect(botId);
+    await removeContainer(computer.spec.container);
+    this.homes.delete(computer.spec.container);
+    this.set(botId, { state: "stopped" });
+  }
+  /** The Bot is being deleted: its container goes with it. */
+  async remove(botId) {
+    const computer = this.deps.store.environments.computerOf(botId);
+    if (!computer) return;
+    await this.disconnect(botId);
+    if (this.available) await removeContainer(computer.spec.container);
+    this.deps.store.environments.dropComputer(botId);
+    this.states.delete(botId);
+  }
+  /** Closes the connections; containers keep running. */
+  async close() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    await Promise.all([...this.connections.keys()].map((botId) => this.disconnect(botId)));
+  }
+  need(botId) {
+    const computer = this.deps.store.environments.computerOf(botId);
+    if (!computer) throw new RuntimeFault("computer_missing", "This Bot has no sandbox.", 404);
+    if (!this.available) throw new RuntimeFault("docker_unavailable", "Docker is not available on this machine.", 409);
+    return computer;
+  }
+  imageReady() {
+    this.image ??= (async () => {
+      const tag = computerImage(this.uid, this.gid);
+      if (!await imageExists(tag)) {
+        this.log(`building ${tag}`);
+        await buildImage(tag, this.uid, this.gid, join5(this.dataDir, "computers", "build.log"));
+        void pruneImages(tag).then((removed) => {
+          if (removed.length) this.log(`removed ${removed.join(", ")}`);
+        }).catch(() => {
+        });
+      }
+      return tag;
+    })().catch((error) => {
+      this.image = null;
+      throw error;
+    });
+    return this.image;
+  }
+  async disconnect(botId) {
+    const env = this.connections.get(botId);
+    this.connections.delete(botId);
+    await env?.close();
+  }
+  set(botId, status) {
+    const before = this.states.get(botId);
+    this.states.set(botId, status);
+    if (before?.state !== status.state || before?.error !== status.error) this.deps.changed();
+  }
+  /** Learns what happened to containers outside Jarvy, and removes containers of this Jarvy that no Bot has any more
+   * (a Bot deleted while Docker was out of reach). */
+  async sweep() {
+    const states = await containerStates(`jarvy.data=${this.tag}`);
+    const computers = this.deps.store.environments.computers();
+    const owned = new Set(computers.map((computer) => computer.spec.container));
+    for (const name2 of states.keys()) if (!owned.has(name2)) {
+      this.log(`removing ${name2}, which no Bot has`);
+      await removeContainer(name2).catch((error) => this.log(`removing ${name2} failed: ${error.message}`));
+    }
+    for (const computer of computers) {
+      const botId = computer.botId;
+      if (this.preparing.has(botId)) continue;
+      const running = states.get(computer.spec.container) === "running";
+      if (!running) {
+        if (this.states.get(botId)?.state !== "failed") this.set(botId, { state: "stopped" });
+        await this.disconnect(botId);
+        continue;
+      }
+      this.set(botId, { state: "running" });
+    }
+  }
+  log(text3) {
+    (this.deps.log ?? console.log)(`[computers] ${text3}`);
+  }
+};
+
 // src/server/infra/storage/history-repository.ts
 import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
 import { chmodSync as chmodSync2, mkdirSync as mkdirSync2 } from "node:fs";
-import { dirname as dirname3 } from "node:path";
+import { dirname as dirname5 } from "node:path";
 var json = (value2) => value2 == null ? null : JSON.stringify(value2);
 var CALL = "EXISTS (SELECT 1 FROM json_each(history.message, '$.content') b WHERE json_extract(b.value, '$.type')=? AND json_extract(b.value, '$.tool_call_id')=?)";
 var BLOCKS = "FROM json_each(history.message,'$.content') b WHERE json_extract(b.value,'$.type')";
@@ -4551,7 +5557,7 @@ var SUMMARY = `SELECT id,timestamp,role,model,
 var HistoryRepository = class {
   db;
   constructor(path) {
-    mkdirSync2(dirname3(path), { recursive: true, mode: 448 });
+    mkdirSync2(dirname5(path), { recursive: true, mode: 448 });
     this.db = new DatabaseSync2(path);
     chmodSync2(path, 384);
     const version = this.db.prepare("PRAGMA user_version").get().user_version;
@@ -4607,17 +5613,17 @@ var HistoryRepository = class {
     const row = this.db.prepare("SELECT * FROM history WHERE id=?").get(id);
     return row ? this.decode(row) : null;
   }
-  links(record2) {
+  links(record3) {
     const links = [];
-    for (const block of record2.message.content) {
+    for (const block of record3.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(record2.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(record3.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(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);
+        const next = this.db.prepare(`SELECT id FROM history WHERE id>? AND ${CALL} ORDER BY id LIMIT 1`).get(record3.id, "tool_call", callId);
+        const results = this.db.prepare(`SELECT id,role FROM history WHERE id>? AND id<? AND ${CALL} ORDER BY id`).all(record3.id, next?.id ?? Number.MAX_SAFE_INTEGER, "tool_result", callId);
         links.push(...results.map((result) => ({ ...result, tool_call_id: callId })));
       }
     }
@@ -4661,14 +5667,14 @@ var Memory = class {
     return this.history().usage(since);
   }
   read(id) {
-    const record2 = this.history().read(id);
-    return record2 ? { record: record2, links: this.history().links(record2) } : null;
+    const record3 = this.history().read(id);
+    return record3 ? { record: record3, links: this.history().links(record3) } : 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((record2, index) => {
-      if (record2) result.records.push(record2);
+    found.forEach((record3, index) => {
+      if (record3) result.records.push(record3);
       else result.missingIds.push(ids[index]);
     });
     return result;
@@ -4680,7 +5686,7 @@ var Memory = class {
 };
 
 // src/server/service/bot/bot.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 var Bot = class extends Member {
   kind = "bot";
   identity;
@@ -4771,7 +5777,7 @@ var Bot = class extends Member {
       ...message.question ? { question: message.question } : {},
       ...message.alsoToChannel ? { alsoToChannel: true } : {},
       ...message.replyTo ? { replyTo: message.replyTo } : {},
-      clientMessageId: source2 ? createHash3("sha256").update(JSON.stringify([this.id, source2.historyId, source2.toolCallId])).digest("hex") : void 0
+      clientMessageId: source2 ? createHash5("sha256").update(JSON.stringify([this.id, source2.historyId, source2.toolCallId])).digest("hex") : void 0
     });
   }
   /** 由 Bot 协调配置与运行实例；配置在应用成功后提交。执行中切换从下一次模型请求生效（A28）。 */
@@ -4794,19 +5800,20 @@ var Bot = class extends Member {
       identity: () => this.identity.snapshot(),
       model: () => this.model.current(),
       workspace: this.workspace.location(),
+      home: () => this.workspace.home(),
       tools: this.tools.definitions(),
       onStatus: (status) => this.updateState(status),
-      onHistory: (record2) => this.recordHistory(record2)
+      onHistory: (record3) => this.recordHistory(record3)
     };
   }
   updateState(status) {
     this.state.update(status);
   }
-  async recordHistory(record2) {
-    const historyId = await this.memory.append(record2);
-    if (record2.role !== "assistant") return;
+  async recordHistory(record3) {
+    const historyId = await this.memory.append(record3);
+    if (record3.role !== "assistant") return;
     this.callHistory.clear();
-    for (const block of record2.message.content) {
+    for (const block of record3.message.content) {
       if (block.type === "tool_call") this.callHistory.set(block.tool_call_id, historyId);
     }
   }
@@ -4831,16 +5838,16 @@ 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 };
   }
 };
 
 // src/server/service/bot/model.ts
 var Model = class {
-  constructor(botId, store, resolve6) {
+  constructor(botId, store, resolve5) {
     this.botId = botId;
     this.store = store;
-    this.resolve = resolve6;
+    this.resolve = resolve5;
   }
   current() {
     const bot = this.store.getBot(this.botId);
@@ -4861,43 +5868,86 @@ var Model = class {
   }
 };
 
+// src/server/service/bot/workspace.ts
+import { posix } from "node:path";
+
 // src/server/infra/files/workspace.ts
-import { mkdir as mkdir3, writeFile } from "node:fs/promises";
-import { join as join4 } from "node:path";
+import { mkdir as mkdir4, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join6 } from "node:path";
 var LocalWorkspace = class {
   constructor(cwd) {
     this.cwd = cwd;
   }
   get tempDir() {
-    return join4(this.cwd, "temp");
+    return join6(this.cwd, "temp");
   }
   async prepare() {
-    await mkdir3(this.tempDir, { recursive: true, mode: 448 });
+    await mkdir4(this.tempDir, { recursive: true, mode: 448 });
   }
   async writeTempFile(name2, content2, signal) {
     await this.prepare();
-    const path = join4(this.tempDir, name2);
-    await writeFile(path, content2, { encoding: "utf8", flag: "wx", mode: 384, signal });
+    const path = join6(this.tempDir, name2);
+    await writeFile3(path, content2, { encoding: "utf8", flag: "wx", mode: 384, signal });
     return path;
   }
 };
 
 // src/server/service/bot/workspace.ts
+var MAX_FILE = 10 * 1024 * 1024;
 var Workspace = class {
-  local;
-  constructor(cwd) {
+  constructor(cwd, current, home) {
+    this.current = current;
+    this.home = home;
     this.local = new LocalWorkspace(cwd);
   }
+  local;
   prepare() {
     return this.local.prepare();
   }
-  writeTempFile(name2, content2, signal) {
-    return this.local.writeTempFile(name2, content2, signal);
+  /** A file in the temporary directory of the environment the Bot works in, by the path it sees there. */
+  async writeTempFile(name2, content2, signal) {
+    const env = this.current();
+    if (env.kind === "host") return this.local.writeTempFile(name2, content2, signal);
+    const path = `${env.cwd}/temp/${name2}`;
+    await env.writeFile(path, content2);
+    return path;
+  }
+  /** Puts a chat file into the Bot's environment: at `path`, or in temp/files/ under its own name (with part of its
+   * id when another file has that name). Returns where it went. */
+  async put(name2, id, data, path) {
+    const env = this.current();
+    let target2 = path ? posix.resolve(env.cwd, path) : `${env.cwd}/temp/files/${plain(name2)}`;
+    if (!path && await env.exists(target2)) {
+      const dot = plain(name2).lastIndexOf("."), stem = dot > 0 ? plain(name2).slice(0, dot) : plain(name2), extension = dot > 0 ? plain(name2).slice(dot) : "";
+      target2 = `${env.cwd}/temp/files/${stem}-${id.slice(0, 8)}${extension}`;
+    }
+    await env.mkdir(posix.dirname(target2));
+    await env.writeFile(target2, data);
+    return target2;
+  }
+  /** The files a Bot attaches to a message, read from its environment: paths there, relative to its directory. */
+  async readOutgoing(items, signal) {
+    if (items.length > 5) throw new ChatError(400, "Too many attachments");
+    const env = this.current(), files = [];
+    for (const item of items) {
+      signal?.throwIfAborted();
+      const path = posix.resolve(env.cwd, item.path), size = await env.fileSize(path);
+      if (size === null) throw new ChatError(400, `No file at ${path} in your environment`);
+      if (!size || size > MAX_FILE) throw new ChatError(400, "Invalid attachment size or type");
+      const data = await env.readFile(path);
+      if (data.length !== size) throw new ChatError(409, "Attachment changed while reading");
+      files.push({ name: item.name, mimeType: "application/octet-stream", data });
+    }
+    return files;
   }
   location() {
     return { type: "local", cwd: this.local.cwd, tempDir: this.local.tempDir };
   }
 };
+function plain(name2) {
+  const cleaned = name2.replace(/[/\\\0]/g, "_").trim();
+  return cleaned && cleaned !== "." && cleaned !== ".." ? cleaned : "file";
+}
 
 // src/server/service/bot/state.ts
 var BotState = class {
@@ -4916,7 +5966,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
@@ -4965,20 +6015,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 record2 of result.records) {
-    sections.push(`## #${record2.id} \xB7 ${record2.role}`, `Time: ${new Date(record2.timestamp).toISOString()}`);
-    if (record2.model) sections.push(`Model:
+  for (const record3 of result.records) {
+    sections.push(`## #${record3.id} \xB7 ${record3.role}`, `Time: ${new Date(record3.timestamp).toISOString()}`);
+    if (record3.model) sections.push(`Model:
 
-${jsonBlock(record2.model)}`);
-    if ("preview" in record2) {
-      sections.push(fence(record2.preview));
+${jsonBlock(record3.model)}`);
+    if ("preview" in record3) {
+      sections.push(fence(record3.preview));
       continue;
     }
-    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));
+    sections.push(content(record3.message.content));
+    if (record3.message.tools !== void 0) sections.push("### Tool definitions", jsonBlock(record3.message.tools));
+    if (record3.message.tools_removed !== void 0) sections.push("### Tools removed", jsonBlock(record3.message.tools_removed));
+    if (record3.message.stop_reason !== void 0) sections.push("### Stop reason", fence(record3.message.stop_reason));
+    if (record3.message.error !== void 0) sections.push("### Error", fence(record3.message.error));
   }
   if (result.missingIds.length) sections.push(`## Missing IDs
 
@@ -5004,6 +6054,38 @@ async function readHistory(memory, workspace, input, signal) {
   return workspace.writeTempFile(name2, rendered, signal);
 }
 
+// src/server/service/bot/file-view.ts
+var TEXT_LIMIT = 64 * 1024;
+var PICTURE_LIMIT = 4 * 1024 * 1024;
+function viewFile(file, data) {
+  const head = `${file.name} (${file.mimeType || "application/octet-stream"}, ${byteSize(file.size)})`;
+  const picture = pictureType(data);
+  if (picture) {
+    if (data.length > PICTURE_LIMIT) throw new ChatError(400, "This picture is over 4 MB; use files.get and look at a smaller copy");
+    return { kind: "media", text: head, images: [{ data: data.toString("base64"), mimeType: picture }] };
+  }
+  const text3 = data.length <= TEXT_LIMIT ? asText(data) : null;
+  if (text3 !== null) return `${head}
+
+${text3}`;
+  throw new ChatError(400, "files.view shows pictures and text files up to 64 KB; use files.get to work on this file with your tools");
+}
+function pictureType(data) {
+  if (data.length >= 8 && data.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) return "image/png";
+  if (data.length >= 3 && data[0] === 255 && data[1] === 216 && data[2] === 255) return "image/jpeg";
+  if (data.length >= 6 && /^GIF8[79]a$/.test(data.subarray(0, 6).toString("latin1"))) return "image/gif";
+  if (data.length >= 12 && data.subarray(0, 4).toString("latin1") === "RIFF" && data.subarray(8, 12).toString("latin1") === "WEBP") return "image/webp";
+  return null;
+}
+function asText(data) {
+  if (data.includes(0)) return null;
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(data);
+  } catch {
+    return null;
+  }
+}
+
 // src/server/service/bot/chat-views.ts
 var iso = (time) => new Date(time).toISOString();
 var name = (chats) => (memberId) => chats.member(memberId)?.name ?? memberId;
@@ -5114,6 +6196,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));
@@ -5228,7 +6311,8 @@ var ChatTools = class {
     return { messages: await this.rows(page, signal), ...messages.length > limit ? { hasMore: true } : {} };
   }
   async rows(messages, signal) {
-    return Promise.all(messages.map(async (message) => messageRow(this.chats, this.bot, message, await this.scope.files.paths(this.bot, message, signal))));
+    signal?.throwIfAborted();
+    return messages.map((message) => messageRow(this.chats, this.bot, message, listing(message)));
   }
   search(input) {
     const found = input.chatId === void 0 ? this.chats.searchAll(this.bot, input.query, input.limit ?? 30) : this.chats.search(this.bot, this.chat(input.chatId).id, input.query, input.limit ?? 30);
@@ -5237,13 +6321,7 @@ var ChatTools = class {
       if (!chats.has(id)) chats.set(id, this.chats.get(this.bot, id));
       return chats.get(id);
     };
-    return found.map((message) => messageRow(
-      this.chats,
-      this.bot,
-      message,
-      message.attachments.map((file) => ({ name: file.name })),
-      input.chatId === void 0 ? chatOf(message.chatId) : null
-    ));
+    return found.map((message) => messageRow(this.chats, this.bot, message, listing(message), input.chatId === void 0 ? chatOf(message.chatId) : null));
   }
 };
 
@@ -5252,6 +6330,7 @@ import { Type as Type3 } from "typebox";
 var None = Type3.Object({}, { additionalProperties: false });
 var Name = (description) => Type3.String({ minLength: 1, maxLength: 80, description });
 var MessageId = Type3.String({ pattern: "^m\\d+$" });
+var FileId = Type3.String({ minLength: 1, maxLength: 80, description: "The file's id: from <file id=\u2026/> in a message, or the attachments of messages.read and messages.search" });
 var QuestionOption = Type3.Object({
   label: Type3.String({ minLength: 1, maxLength: 80, description: "Text shown on the option" }),
   value: Type3.Optional(Type3.String({ minLength: 1, maxLength: 500, description: "What you get back when it is picked, written as the person would naturally say it; label by default" })),
@@ -5261,7 +6340,10 @@ 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. With environments=true, each Bot also has environment: its default work environment, the one it is in now (current) and the ones it may use. You come first, then the rest by name.",
+    schema: Type3.Object({ environments: Type3.Optional(Type3.Boolean({ description: "Also give each Bot's work environments" })) }, { additionalProperties: false })
+  },
   "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 +6371,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": {
@@ -5311,7 +6393,7 @@ var definitions = {
     schema: Type3.Object({ section: Type3.String({ minLength: 1, maxLength: 80 }), name: Name("New name") }, { additionalProperties: false })
   },
   "messages.read": {
-    description: "Read messages and the paths of the attachments you can read. Three ways: \u2460 chatId + after: read on from that sequence number (from the start by default); \u2461 around with a message ID: that message and context messages on each side (5 by default), to see the context; this doesn't move your read position; \u2462 unread=true: your unread messages, in one chat with chatId, or in every chat (grouped by chat) without it. \u2460 and \u2462 move your read position to the last message read; hasMore=true means there is more, so call again.",
+    description: "Read messages; their files are listed by id, name, type and size, for files.get and files.view. Three ways: \u2460 chatId + after: read on from that sequence number (from the start by default); \u2461 around with a message ID: that message and context messages on each side (5 by default), to see the context; this doesn't move your read position; \u2462 unread=true: your unread messages, in one chat with chatId, or in every chat (grouped by chat) without it. \u2460 and \u2462 move your read position to the last message read; hasMore=true means there is more, so call again.",
     schema: Type3.Object({
       chatId: Type3.Optional(Type3.String()),
       after: Type3.Optional(Type3.Integer({ minimum: 0 })),
@@ -5322,9 +6404,22 @@ var definitions = {
     }, { additionalProperties: false })
   },
   "messages.search": {
-    description: "Search message text. With chatId, only that chat; without it, every chat you can see, and each result says which chat it is in. Use messages.read to read attachments.",
+    description: "Search message text. With chatId, only that chat; without it, every chat you can see, and each result says which chat it is in. Results list their files like messages.read.",
     schema: Type3.Object({ chatId: Type3.Optional(Type3.String()), query: Type3.String({ minLength: 1, maxLength: 500 }), limit: Type3.Optional(Type3.Integer({ minimum: 1, maximum: 100 })) }, { additionalProperties: false })
   },
+  "files.get": {
+    description: "Put a file from a message into your environment, to work on it with your tools; the result has its path there. It goes to temp/files/ under its own name unless you give a path.",
+    schema: Type3.Object({ id: FileId, path: Type3.Optional(Type3.String({ minLength: 1, maxLength: 1e3, description: "Where to put it instead: absolute, or relative to your directory" })) }, { additionalProperties: false })
+  },
+  "environments.list": { description: "List the work environments you may use: your sandbox, your default and the ones your owner granted you. current is the id of the one you are in. Each has its id, name, the directory your file and command tools start in there, default=true for your default, and state for a sandbox (it starts when you switch to it).", schema: None },
+  "environments.switch": {
+    description: "Move your file and command tools (bash, read, write, edit) to another work environment from environments.list, like cd one level up: you stay there, across turns, until you switch back. The result has your directory there and what you can do there. Commands already running finish where they started.",
+    schema: Type3.Object({ id: Type3.String({ minLength: 1, maxLength: 80, description: "The environment's id from environments.list" }) }, { additionalProperties: false })
+  },
+  "files.view": {
+    description: "Look at a file from a message without putting it anywhere: a picture (PNG, JPEG, GIF or WebP, up to 4 MB) is shown to you, and a text file up to 64 KB comes back as text. Anything else needs files.get.",
+    schema: Type3.Object({ id: FileId }, { additionalProperties: false })
+  },
   "messages.react": {
     description: `Add or remove an emoji reaction on a message (people and Bots can both react). on=false removes it. Giving an emoji the message already has from you removes it instead (and the other way round); marked or unmarked and note in the result say which happened. Use this toggle to signal states such as "got it", "on it" and "done". Only the message's author is told: if they are running, it joins their current turn without interrupting; if they are idle, it starts a turn.`,
     schema: Type3.Object({ messageId: MessageId, emoji: Type3.String({ minLength: 1, maxLength: 32, description: "A single emoji, such as \u{1F44D}" }), on: Type3.Optional(Type3.Boolean()) }, { additionalProperties: false })
@@ -5341,7 +6436,7 @@ var definitions = {
     }, { additionalProperties: false })
   },
   "messages.send": {
-    description: "Send a message, with files from the tool host if you like (path and name). Give chatId or to, not both: to is a member's name and sends them a DM (a person or a Bot; the first time creates the DM). Only messages sent successfully are visible in the chat. In channels and threads, only the members whose @name is in the text and the members subscribed there receive it; DMs need no @. The result lists who was @-mentioned (notified), who got it through a subscription (subscribers), and the names that aren't in the channel and weren't told. thread: the ID of a message in the channel, to reply in that message's thread (created if it has none; chatId is the channel). replyTo: the ID of a message in the same chat, to reply to it as a quote; this tells its author, like an @. When replying in a thread, alsoToChannel=true also posts a copy to the channel.",
+    description: "Send a message, with files from your environment if you like (path there, absolute or relative to your directory, and the name people see). Give chatId or to, not both: to is a member's name and sends them a DM (a person or a Bot; the first time creates the DM). Only messages sent successfully are visible in the chat. In channels and threads, only the members whose @name is in the text and the members subscribed there receive it; DMs need no @. The result lists who was @-mentioned (notified), who got it through a subscription (subscribers), and the names that aren't in the channel and weren't told. thread: the ID of a message in the channel, to reply in that message's thread (created if it has none; chatId is the channel). replyTo: the ID of a message in the same chat, to reply to it as a quote; this tells its author, like an @. When replying in a thread, alsoToChannel=true also posts a copy to the channel.",
     schema: Type3.Object({
       chatId: Type3.Optional(Type3.String()),
       to: Type3.Optional(Type3.String({ minLength: 1, maxLength: 80 })),
@@ -5355,7 +6450,7 @@ var definitions = {
 };
 
 // src/server/service/bot/roster.ts
-function botRows(chats, viewerId, entries) {
+function botRows(chats, viewerId, entries, environment) {
   const rows2 = entries.map((entry) => {
     const running = entry.status.status === "running";
     const visible = [];
@@ -5368,30 +6463,194 @@ 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 } : {},
       ...hidden ? { otherChats: hidden } : {},
-      ...entry.errorCode ? { error: entry.errorCode } : {}
+      ...entry.errorCode ? { error: entry.errorCode } : {},
+      ...environment ? { environment: environment(entry.id) } : {}
     } };
   });
   rows2.sort((a, b) => Number(b.self) - Number(a.self) || a.row.name.localeCompare(b.row.name));
   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 { environment, ...settings } = args;
+        const bot = await this.ops.create({ ...settings, ...environment ? { environment: environment === "sandbox" ? "computer" : "host" } : {} });
+        return { name: bot.name, model: bot.connectionId ? this.ops.modelLabel(bot) : null, thinking: bot.thinkingLevel, environment: this.ops.environment(bot.id) === "computer" ? "sandbox" : "host" };
+      }
+      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 Environment = Type4.Union([Type4.Literal("sandbox"), Type4.Literal("host")], {
+  description: "Where its file and command tools run by default: sandbox, a Linux container that Jarvy makes and only it uses (the default when Docker is available), or host, the owner's computer, where you work too"
+});
+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, environment: Type4.Optional(Environment) }, { 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 +6664,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);
@@ -5425,7 +6686,16 @@ var Tools = class {
           case "members.list":
             return this.tools.membersList();
           case "bots.list":
-            return botRows(this.scope.chats, this.scope.botId, this.scope.roster());
+            return botRows(
+              this.scope.chats,
+              this.scope.botId,
+              this.scope.roster(),
+              args.environments ? (id) => this.scope.places.summary(id) : void 0
+            );
+          case "environments.list":
+            return this.scope.places.list();
+          case "environments.switch":
+            return this.scope.places.switch(args.id);
           case "chats.create":
             return this.tools.create(args);
           case "chats.update":
@@ -5459,6 +6729,16 @@ var Tools = class {
           }
           case "messages.read":
             return this.tools.read(args, signal);
+          case "files.get": {
+            const { id, path } = args;
+            const { file, data } = this.scope.files.open(this.scope.botId, id);
+            signal?.throwIfAborted();
+            return { path: await this.scope.workspace.put(file.name, id, data, path), name: file.name, type: file.mimeType, size: byteSize(file.size) };
+          }
+          case "files.view": {
+            const { file, data } = this.scope.files.open(this.scope.botId, args.id);
+            return viewFile(file, data);
+          }
           case "messages.search":
             return this.tools.search(args);
           case "messages.send": {
@@ -5504,13 +6784,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);
           }
         }
       }
@@ -5519,10 +6793,13 @@ var Tools = class {
 };
 
 // src/server/service/bot/inbox.ts
-import { join as join5, dirname as dirname4 } from "node:path";
+import { join as join7, dirname as dirname6 } 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
-import { isAbsolute } from "node:path";
 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");
@@ -5537,23 +6814,29 @@ function remember(map, id, definition) {
   if (old !== void 0 && old !== definition) throw new Error("Conflicting source metadata");
   map.set(id, definition);
 }
+var environmentLine = (place) => place ? `<environment${attribute("name", place.name)}${attribute("directory", place.directory)}/>` : "";
 var iso2 = (time) => new Date(time).toISOString().replace(".000Z", "Z");
-function encodeNoticeBatch(botId, notices) {
+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, environment) {
   if (!notices.length) throw new Error("Empty notice batch");
   const chats = /* @__PURE__ */ new Map(), members = /* @__PURE__ */ new Map();
   const list = noticeTail(notices, chats, members);
-  return `<notice_batch${attribute("bot", botId)}>${[...chats.values()].join("")}${[...members.values()].join("")}${list}</notice_batch>`;
+  return `<notice_batch${attribute("bot", botId)}>${[...chats.values()].join("")}${[...members.values()].join("")}${list}${environmentLine(environment)}</notice_batch>`;
 }
 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 changed = notices.filter((notice) => notice.kind === "change");
+  const changes = changed.map((notice) => `<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 byAgent = changed.some((notice) => notice.actor.kind === "bot"), byOwner = changed.some((notice) => notice.actor.kind === "user");
+  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("")}` + (byAgent ? "<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>" : "") + (byOwner ? "<note>Your owner changed where you work, and it already applies: environment is where your file and command tools run now, and access is what environments.switch can take you to. If you were in the middle of something, carry on where you are now.</note>" : "") + "</changes>" : "") + onboard.join("");
 }
 function encodeChatBatch(botId, messages, digest, notices) {
   if (!messages.length) throw new Error("Empty chat batch");
@@ -5564,32 +6847,33 @@ function encodeChatBatch(botId, messages, digest, notices) {
     const { chat } = message;
     remember(chats, chat.id, `<chat${attribute("id", chat.id)}${attribute("type", chat.type)}${chat.title ? attribute("title", chat.title) : ""}${chat.section ? attribute("section", chat.section) : ""}${chat.parent ? attribute("parent", chat.parent) : ""}${chat.root ? attribute("root", chat.root) : ""}${chat.status ? attribute("status", chat.status) : ""}/>`);
     remember(members, message.sender.id, `<member${attribute("id", message.sender.id)}${attribute("name", message.sender.name)}${attribute("kind", message.sender.kind)}/>`);
-    const at = new Date(message.createdAt).toISOString().replace(".000Z", "Z");
-    const attributes = attribute("id", message.id) + attribute("chat", message.chat.id) + attribute("from", message.sender.id) + attribute("at", at);
+    const at2 = new Date(message.createdAt).toISOString().replace(".000Z", "Z");
+    const attributes = attribute("id", message.id) + attribute("chat", message.chat.id) + attribute("from", message.sender.id) + attribute("at", at2);
     const reply = message.replyTo;
     if (reply) remember(members, reply.sender.id, `<member${attribute("id", reply.sender.id)}${attribute("name", reply.sender.name)}${attribute("kind", reply.sender.kind)}/>`);
     const quote = reply ? `<reply_to${attribute("message", reply.id)}${attribute("from", reply.sender.id)}>${escape(reply.text)}</reply_to>` : "";
-    const files = message.attachments.map((file) => {
-      if (!isAbsolute(file.path)) throw new Error("Attachment path must be absolute");
-      return `<file${attribute("path", file.path)}${attribute("name", file.name)}/>`;
-    }).join("");
+    const files = message.attachments.map((file) => `<file${attribute("id", file.id)}${attribute("name", file.name)}${attribute("type", file.type)}${attribute("size", file.size)}/>`).join("");
     return `<message${attributes}>${quote}${message.content ? `<text>${escape(message.content)}</text>` : ""}${files}</message>`;
   });
   const ref = (key, item) => attribute(key, item.chatId) + (chats.has(item.chatId) ? "" : attribute("title", item.title) + attribute("type", item.type));
   let tail = notices?.length ? noticeTail(notices, chats, members) : "";
   if (digest?.unread.length) tail += `<unread${attribute("total", String(digest.unread.reduce((sum, item) => sum + item.count, 0)))}>${digest.unread.map((item) => `<chat${ref("id", item)}${attribute("count", String(item.count))}/>`).join("")}</unread>`;
+  tail += environmentLine(digest?.environment);
   return `<chat_batch${attribute("bot", botId)}>${[...chats.values()].join("")}${[...members.values()].join("")}${encoded.join("")}${tail}</chat_batch>`;
 }
 
 // src/server/service/bot/inbox.ts
 var BotInbox = class {
-  constructor(botId, repository, chats, files) {
+  /** `where` is the work environment the Bot is in now, named at the end of each batch (A50). */
+  constructor(botId, repository, chats, files, where2) {
     this.botId = botId;
     this.repository = repository;
     this.chats = chats;
     this.files = files;
+    this.where = where2;
   }
-  /** 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,11 +6881,11 @@ 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.");
-    return this.repository.ensureSession(this.botId, join5(dirname4(workspace), "agent", "pi", "sessions", `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.jsonl`));
+    return this.repository.ensureSession(this.botId, join7(dirname6(workspace), "agent", "pi", "sessions", `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.jsonl`));
   }
   /** XML for the claimed messages plus the tail (other deliveries not told yet, unread); `notices` are told once
    * the batch is submitted. */
@@ -5612,7 +6896,7 @@ var BotInbox = class {
     }
     const inputs = await this.files.envelope(this.botId, batch.inputs.map((input) => input.messageId));
     for (const input of batch.inputs) if (!this.chats.get(this.botId, input.chatId)) throw new RuntimeFault("chat_access_changed", "Chat access has changed.");
-    const digest = this.chats.channels.digest(this.botId);
+    const digest = { ...this.chats.channels.digest(this.botId), ...this.where ? { environment: this.where() } : {} };
     const pending = this.envelope(this.chats.notices(this.botId));
     return { xml: encodeChatBatch(this.botId, inputs, digest, pending.length ? pending : void 0), notices: pending.map((notice) => notice.id) };
   }
@@ -5621,6 +6905,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 };
@@ -5634,7 +6923,7 @@ var BotInbox = class {
   notices() {
     const pending = this.chats.notices(this.botId);
     if (!pending.length) return null;
-    return { xml: encodeNoticeBatch(this.botId, this.envelope(pending)), ids: pending.map((notice) => notice.id) };
+    return { xml: encodeNoticeBatch(this.botId, this.envelope(pending), this.where?.()), ids: pending.map((notice) => notice.id) };
   }
   /** These notices reached the model. */
   tell(ids) {
@@ -5667,8 +6956,8 @@ var AgentRuntime = class {
     return this.runId;
   }
   update(patch) {
-    const context = this.session?.context;
-    this.status = { ...this.status, ...patch, context: context ? { tokens: context.tokens, limit: context.contextWindow } : null };
+    const context2 = this.session?.context;
+    this.status = { ...this.status, ...patch, context: context2 ? { tokens: context2.tokens, limit: context2.contextWindow } : null };
     this.setup?.onStatus(this.status);
   }
   activity(phase) {
@@ -5679,9 +6968,9 @@ var AgentRuntime = class {
     if (this.prompting) this.update({ status: "running", activity: on ? "asking" : "tool_calling" });
   }
   fail(error) {
-    const fault = publicFault(error);
-    this.update({ status: this.session ? "idle" : "stop", activity: null, error: { code: fault.code, message: fault.message, ...fault.params ? { params: fault.params } : {} } });
-    console.error("[bot] execution failed", { botId: this.inbox.botId, runId: this.runId, code: fault.code, ...error instanceof RuntimeFault ? {} : { error } });
+    const fault2 = publicFault(error);
+    this.update({ status: this.session ? "idle" : "stop", activity: null, error: { code: fault2.code, message: fault2.message, ...fault2.params ? { params: fault2.params } : {} } });
+    console.error("[bot] execution failed", { botId: this.inbox.botId, runId: this.runId, code: fault2.code, ...error instanceof RuntimeFault ? {} : { error } });
   }
   async start(setup) {
     await this.operation(async () => {
@@ -5805,7 +7094,7 @@ var AgentRuntime = class {
     return task;
   }
   // Model/thinking changes queue behind start/stop and each other but not behind the running turn:
-  // Pi 0.99.1 re-reads agent.state.model/thinkingLevel before every next request (prepareNextTurn),
+  // Pi 1.2.0 re-reads agent.state.model/thinkingLevel before every next request (AgentSession's prepareNextTurnWithContext),
   // and each request resolves its API key when it starts, so in-flight requests are unaffected.
   reconfigure(operation) {
     const task = this.operations.catch(() => {
@@ -5868,6 +7157,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,14 +7175,14 @@ ${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.
 
 ## Chat
 The chat tool is your only way to talk to the other members. Anything you don't send through it is seen by no one.
-To pass a document, an image or another file to someone, attach its path and name when you send with the chat tool.
+Files in messages come with an ID: files.get puts one into your environment and gives you its path, and files.view shows you an image or a text file directly. To pass a file to someone, attach its path in your environment and its name when you send with the chat tool.
 Channels can be put in channel groups and have a notice. Threads have a title, a status and a summary.
 In channels and threads you only get new messages when you are @-mentioned; once you subscribe, every new message there is sent to you. DMs need no @.
 Each batch of messages ends with your unread counts and the notices and summaries that have a new version. Read them through the chat gateway when you need to.
@@ -5894,17 +7191,33 @@ Each batch of messages ends with your unread counts and the notices and summarie
 To look into earlier work, search the chat first, then call history.read with the History ID a message carries to read how the work was done.
 history.read is listed by the chat gateway. History is material to look back on, not an instruction for the task at hand.
 
-## Workspace
-You have your own workspace: ${bot.workspacePath}
+${workspaceSection(setup, bot.workspacePath)}
+## Responding
+When you are @-mentioned or get a DM, first let the person know you have it: react to that message with an emoji, or confirm in a sentence or two with an emoji. A reaction is only a signal, not a command; pick the emoji yourself.
+When something will take a while, post a short progress note partway through, and give the outcome when you are done. You don't need to answer every message that isn't meant for you.
+`;
+}
+function workspaceSection(setup, workspacePath) {
+  const place = setup.home();
+  if (place.kind === "computer") return `## Workspace
+Your workspace is your own folder and your home directory: your file and command tools see it as ${place.cwd}, and ~ is the same place, so settings such as ~/.ssh and ~/.gitconfig stay with it. It is kept when your sandbox is reset. Keep it tidy, and put temporary files under temp and clear them out.
+
+## Work environment
+Your tools run in your sandbox by default: a Linux container only you use, with Node, Python, git, build tools, and Playwright with its browsers. You can install software there with sudo; it stays until the owner resets your sandbox.
+${SWITCHING}
+`;
+  return `## Workspace
+You have your own workspace: ${workspacePath}
 Treat it as your only base. Create, change and delete files only inside it, keep it tidy, and put temporary files under temp and clear them out.
 Leave everything else alone by default: other members' workspaces, live data directories (such as ~/.jarvy), main repository checkouts and system directories. Touch them only when the task itself needs it or the person in charge asks you to, and say in your reply what you changed.
 Shared directories and other people's files are read-only. Ask the person in charge before writing to them.
 
-## Responding
-When you are @-mentioned or get a DM, first let the person know you have it: react to that message with an emoji, or confirm in a sentence or two with an emoji. A reaction is only a signal, not a command; pick the emoji yourself.
-When something will take a while, post a short progress note partway through, and give the outcome when you are done. You don't need to answer every message that isn't meant for you.
+## Work environment
+Your tools run on your owner's computer by default, the machine running Jarvy.
+${SWITCHING}
 `;
 }
+var SWITCHING = "Each batch of messages ends with the environment you are in now. environments.list shows the ones you may use, and environments.switch moves your tools to another, like cd, until you switch back.";
 
 // src/server/shared/live.ts
 var LIVE_STEPS = 300;
@@ -5918,9 +7231,9 @@ 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 : {};
+var record2 = (value2) => value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : {};
 function liveInput(tool, args, chat) {
-  const values = record(args);
+  const values = record2(args);
   switch (tool) {
     case "bash":
       return { command: field(values.command) };
@@ -5944,15 +7257,15 @@ function liveInput(tool, args, chat) {
 }
 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) };
+  const inner = record2(values.args), where2 = target(inner, chat);
+  if (action === "messages.send") return { action, chat: where2, text: field(inner.message, LIVE_MESSAGE) };
   if (action === "messages.ask") return {
     action,
-    chat: where,
+    chat: where2,
     text: field(inner.question, LIVE_MESSAGE),
-    options: Array.isArray(inner.options) ? inner.options.map((option2) => field(record(option2).label) ?? "").filter(Boolean) : void 0
+    options: Array.isArray(inner.options) ? inner.options.map((option2) => field(record2(option2).label) ?? "").filter(Boolean) : void 0
   };
-  return where ? { action, chat: where } : { action };
+  return where2 ? { action, chat: where2 } : { action };
 }
 function target(inner, chat) {
   if (typeof inner.to === "string") return { id: null, type: "dm", title: clip(inner.to, 80) };
@@ -6158,25 +7471,156 @@ 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((record3) => same2(name2, record3.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 } };
+  }
+  /** Where a Bot works now: computer or host (A50). */
+  environment(botId) {
+    return this.bots.describe(botId).environment.home;
+  }
+  /** "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, input.environment);
+    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);
+    this.computers = new Computers({ store: deps.store, changed: () => this.listChanged() });
+    this.environments = new BotEnvironments(deps.store, this.computers);
   }
   bots = /* @__PURE__ */ new Map();
   lives = /* @__PURE__ */ new Map();
+  computers;
+  environments;
   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);
-    if (!record2) throw new RuntimeFault("bot_missing", "Bot not found", 404);
+    const record3 = this.deps.store.getBot(id);
+    if (!record3) 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, live = this.live(id);
-    const runtime = new AgentRuntime(new BotInbox(id, store.runtime, chats, files), (setup, model, reference, activity) => (this.deps.factory ?? PiSession.create)({
+    const here = () => {
+      const place = this.environments.here(id, record3.workspacePath);
+      return { name: place.name, directory: place.directory };
+    };
+    const runtime = new AgentRuntime(new BotInbox(id, store.runtime, chats, files, here), (setup, model, reference, activity) => (this.deps.factory ?? PiSession.create)({
       store,
-      bot: record2,
+      bot: record3,
       selection: model.selection,
       reference,
       credentials,
@@ -6184,20 +7628,38 @@ var BotService = class {
       systemPrompt: () => botPrompt(setup),
       onHistory: setup.onHistory,
       activity,
-      live: (event) => live.event(event)
+      live: (event) => live.event(event),
+      environment: () => this.environments.current(id, record3.workspacePath)
     }));
-    const workspace = new Workspace(record2.workspacePath);
-    const memory = new Memory(join6(dirname5(record2.workspacePath), "history.db"));
+    const workspace = new Workspace(record3.workspacePath, () => this.environments.current(id, record3.workspacePath), () => {
+      const place = this.environments.home(id, record3.workspacePath);
+      return { kind: place.kind === "sandbox" ? "computer" : "host", cwd: place.directory };
+    });
+    const memory = new Memory(join8(dirname7(record3.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(),
+        places: {
+          list: () => this.environments.list(id, record3.workspacePath),
+          switch: (environmentId) => this.environments.switch(id, environmentId, record3.workspacePath),
+          summary: (botId) => this.environments.summary(botId)
+        },
+        ...id === AGENT_BOT_ID ? { agent: this.agent } : {}
+      }),
       agentRuntime: runtime,
       state: new BotState(() => this.deps.changed(id))
     }, { deliver: async (message) => {
-      const outgoing = await files.readOutgoing(record2.workspacePath, message.attachments ?? [], message.signal);
+      const outgoing = await workspace.readOutgoing(message.attachments ?? [], message.signal);
       message.signal?.throwIfAborted();
       return chats.deliver(id, message.chatId, {
         content: message.content,
@@ -6213,9 +7675,14 @@ var BotService = class {
     this.bots.set(id, bot);
     return bot;
   }
-  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 };
+  details(record3) {
+    const model = record3.connectionId ? this.deps.store.getModelConnection(record3.connectionId)?.models.find((model2) => model2.id === record3.modelId) : void 0;
+    return {
+      ...record3,
+      effectiveThinkingLevel: model ? resolveThinking(model, record3.thinkingLevel) : null,
+      agent: record3.id === AGENT_BOT_ID,
+      environment: this.environments.placement(record3.id)
+    };
   }
   owns(id) {
     return this.deps.store.getBot(id) !== null;
@@ -6238,15 +7705,58 @@ var BotService = class {
     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((record2) => this.details(record2));
-  }
-  create(name2) {
-    return this.details(this.deps.store.createBot(name2));
+    return this.deps.store.listBots().map((record3) => this.details(record3));
+  }
+  /** A new Bot works in its sandbox when this machine has Docker, unless asked for the owner's computer (A50). */
+  create(name2, environment) {
+    const kind = environment ?? (this.computers.available ? "computer" : "host");
+    if (kind === "computer" && !this.computers.available) throw new RuntimeFault("docker_unavailable", "Docker is not available on this machine.", 409);
+    const record3 = this.deps.store.createBot(name2);
+    this.environments.setHome(record3.id, kind, record3.workspacePath);
+    return this.details(record3);
+  }
+  /** The owner moves a Bot to its sandbox or to their computer, as its default; the next tool call runs there. */
+  setHome(id, kind) {
+    const moved = this.environments.setHome(id, kind, this.record(id).workspacePath);
+    if (moved) this.tellOwner(id, [{ what: "environment", value: where(moved) }], true);
+    return this.describe(id);
+  }
+  /** The owner lets a Bot use their computer, or takes it back; taking it back while the Bot is there sends it home. */
+  grantHost(id, granted) {
+    const { changed, moved } = this.environments.grantHost(id, granted, this.deps.store.userMemberId(), this.record(id).workspacePath);
+    const changes = changed ? [{ what: "access", value: `your owner's computer: ${granted ? "you may switch to it" : "taken back"}` }] : [];
+    if (moved) changes.push({ what: "environment", value: where(moved) });
+    if (changes.length) this.tellOwner(id, changes, !!moved);
+    return this.describe(id);
+  }
+  /** Tells a Bot what its owner changed about where it works (A41, A50). A move interrupts a running turn, as an
+   * @-mention does, so the Bot doesn't go on in the old place; a Bot not running, or a change of access alone, is
+   * told with its next batch (fish m1012–m1015). */
+  tellOwner(id, changes, move) {
+    if (!this.record(id).connectionId) return;
+    const owner = this.deps.store.userMemberId(), chatId = this.deps.chats.openDirect(owner, id).id;
+    const urgency = move && this.bots.get(id)?.status().status === "running" ? urgencyOf("change", "owner") : "digest";
+    for (const change of changes) this.deps.store.agent.notify({ botId: id, kind: "change", reason: "owner", urgency, chatId, actorId: owner, detail: JSON.stringify(change) });
+    if (urgency === "interrupt") this.deliver(id, urgency);
+  }
+  record(id) {
+    const record3 = this.deps.store.getBot(id);
+    if (!record3) throw new RuntimeFault("bot_missing", "Bot not found", 404);
+    return record3;
+  }
+  /** Starting (or resetting, which starts afresh) returns at once: the Bot's state follows as it changes. */
+  async computer(id, action) {
+    this.describe(id);
+    if (action === "stop") await this.computers.stop(id);
+    else {
+      if (action === "reset") await this.computers.reset(id);
+      void this.computers.ensure(id).catch(() => {
+      });
+    }
+    return this.describe(id);
   }
   describe(id) {
-    const record2 = this.deps.store.getBot(id);
-    if (!record2) throw new RuntimeFault("bot_missing", "Bot not found", 404);
-    return this.details(record2);
+    return this.details(this.record(id));
   }
   runs(id) {
     this.describe(id);
@@ -6273,9 +7783,9 @@ var BotService = class {
     if (this.closed || !this.deps.store.getBot(id)) return;
     const bot = this.get(id);
     void bot.deliver(urgency).catch((error) => {
-      const fault = publicFault(error);
-      bot.state.update({ ...bot.status(), error: { code: fault.code, message: fault.message, ...fault.params ? { params: fault.params } : {} } });
-      console.error("[bot] delivery failed", { botId: id, code: fault.code });
+      const fault2 = publicFault(error);
+      bot.state.update({ ...bot.status(), error: { code: fault2.code, message: fault2.message, ...fault2.params ? { params: fault2.params } : {} } });
+      console.error("[bot] delivery failed", { botId: id, code: fault2.code });
     });
   }
   /** Picks up what is still waiting for a Bot (after a failure, a new model, or a restart), if anything. */
@@ -6289,20 +7799,22 @@ var BotService = class {
   start() {
     if (this.started) return;
     this.started = true;
+    void this.computers.start();
     for (const { botId, urgency } of this.deps.store.runtime.waitingBots(this.deps.store.userMemberId())) this.deliver(botId, urgency);
   }
   /** 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((record2) => {
-      const bot = this.bots.get(record2.id), runId = bot?.agentRuntime.activeRunId ?? null;
+    return store.listBots().map((record3) => {
+      const bot = this.bots.get(record3.id), runId = bot?.agentRuntime.activeRunId ?? null;
       const status = bot?.status() ?? { status: "stop", activity: null, context: null, error: null };
       return {
-        id: record2.id,
-        name: record2.name,
+        id: record3.id,
+        name: record3.name,
+        agent: record3.id === AGENT_BOT_ID,
         status,
         runChatIds: status.status === "running" && runId ? store.runtime.inputs(runId).map((input) => input.chatId) : [],
-        errorCode: store.runtime.latestErrorCode(record2.id)
+        errorCode: store.runtime.latestErrorCode(record3.id)
       };
     });
   }
@@ -6311,18 +7823,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,21 +7846,25 @@ 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);
+    await this.environments.release(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 });
+    if (!keepFiles) await rm3(dirname7(workspacePath), { recursive: true, force: true });
   }
   async close() {
     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();
+    await this.environments.close();
   }
 };
+var where = (moved) => `${moved.to.name}, in ${moved.to.directory}`;
 
 // src/server/application.ts
 var Application = class _Application {
@@ -6366,7 +7886,7 @@ var Application = class _Application {
       (id) => this.events.publish({ kind: "chat", id }),
       () => this.events.publish({ kind: "inbox", memberId: this.user.id })
     );
-    this.files = new ChatFiles(dataDir, this.chats);
+    this.files = new ChatFiles(this.chats);
     store.runtime.recover();
     this.bots = new BotService({
       store,
@@ -6374,11 +7894,12 @@ 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));
-    this.account = new AccountService(store, createHash4("sha256").update(dataDir).digest("hex").slice(0, 10));
-    this.models = new ModelService(store, this.credentials, this.auth, (id) => this.bots.connectionChanged(id));
+    this.account = new AccountService(store, createHash6("sha256").update(dataDir).digest("hex").slice(0, 10));
+    this.models = new ModelService(store, this.credentials, this.auth, (id) => this.bots.connectionChanged(id), new ModelCatalog(dataDir));
   }
   events = new Changes();
   credentials = new CredentialCoordinator();
@@ -6391,8 +7912,8 @@ var Application = class _Application {
   models;
   closing;
   static async open(dataDir, options = {}) {
-    await mkdir4(resolve4(dataDir), { recursive: true, mode: 448 });
-    const root = await realpath2(resolve4(dataDir));
+    await mkdir5(resolve3(dataDir), { recursive: true, mode: 448 });
+    const root = await realpath(resolve3(dataDir));
     let app;
     let release;
     try {
@@ -6400,7 +7921,7 @@ var Application = class _Application {
         retries: 0,
         stale: 3e4,
         update: 1e4,
-        lockfilePath: join7(root, ".runtime.lock"),
+        lockfilePath: join9(root, ".runtime.lock"),
         onCompromised: () => {
           console.error("[runtime] data lock compromised");
           options.onCompromised?.();
@@ -6423,6 +7944,7 @@ var Application = class _Application {
   }
   start() {
     this.bots.start();
+    this.models.refreshCatalog();
   }
   close() {
     if (!this.closing) this.closing = (async () => {
@@ -6438,14 +7960,14 @@ var Application = class _Application {
 };
 
 // src/server/daemon.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 import { closeSync, mkdirSync as mkdirSync3, openSync, readFileSync as readFileSync2, rmSync, writeFileSync } from "node:fs";
-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");
+import { join as join10, resolve as resolve4 } from "node:path";
+var pidPath = (dir) => join10(resolve4(dir), "jarvy.pid");
+var logPath = (dir) => join10(resolve4(dir), "jarvy.log");
 function writePidFile(dir, url) {
-  const record2 = { pid: process.pid, startToken: startToken(process.pid), url, startedAt: Date.now() };
-  writeFileSync(pidPath(dir), JSON.stringify(record2), { mode: 384 });
+  const record3 = { pid: process.pid, startToken: startToken(process.pid), url, startedAt: Date.now() };
+  writeFileSync(pidPath(dir), JSON.stringify(record3), { mode: 384 });
 }
 function removePidFile(dir) {
   if (readRecord(dir)?.pid === process.pid) rmSync(pidPath(dir), { force: true });
@@ -6473,19 +7995,19 @@ function alive(pid) {
   }
 }
 function runningServer(dir) {
-  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) {
+  const record3 = readRecord(dir);
+  if (!record3) return null;
+  const token = alive(record3.pid) ? startToken(record3.pid) : null;
+  if (token === null || token && record3.startToken && token !== record3.startToken) {
     rmSync(pidPath(dir), { force: true });
     return null;
   }
-  return record2;
+  return record3;
 }
 function startBackground(script, runArgs, dir) {
-  mkdirSync3(resolve5(dir), { recursive: true, mode: 448 });
+  mkdirSync3(resolve4(dir), { recursive: true, mode: 448 });
   const log = openSync(logPath(dir), "a", 384);
-  const child = spawn(process.execPath, [...process.execArgv, script, "run", ...runArgs], { detached: true, stdio: ["ignore", log, log, "ipc"] });
+  const child = spawn2(process.execPath, [...process.execArgv, script, "run", ...runArgs], { detached: true, stdio: ["ignore", log, log, "ipc"] });
   closeSync(log);
   return new Promise((resolvePromise, reject) => {
     child.once("error", reject);
@@ -6513,11 +8035,11 @@ function signalReady(url) {
   process.disconnect();
 }
 async function stopServer(dir, waitMs = 3e4) {
-  const record2 = runningServer(dir);
-  if (!record2) return "not_running";
-  process.kill(record2.pid, "SIGTERM");
+  const record3 = runningServer(dir);
+  if (!record3) return "not_running";
+  process.kill(record3.pid, "SIGTERM");
   for (const deadline = Date.now() + waitMs; Date.now() < deadline; ) {
-    if (!alive(record2.pid)) {
+    if (!alive(record3.pid)) {
       rmSync(pidPath(dir), { force: true });
       return "stopped";
     }
@@ -6536,7 +8058,7 @@ function option(args, flag, fallback) {
 function secretPrompt(label) {
   if (!process.stdin.isTTY || !process.stdin.setRawMode) throw new Error("Account setup requires an interactive terminal");
   process.stdout.write(label);
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve5, reject) => {
     let value2 = "";
     const done = (result, error) => {
       process.stdin.off("data", onData);
@@ -6544,7 +8066,7 @@ function secretPrompt(label) {
       process.stdin.pause();
       process.stdout.write("\n");
       if (error) reject(error);
-      else resolve6(result ?? "");
+      else resolve5(result ?? "");
     };
     const onData = (buffer) => {
       for (const char of buffer.toString("utf8")) {
@@ -6661,18 +8183,18 @@ async function main() {
   try {
     if (!store.isInitialized()) await initialize(store);
     const { host, port, url } = listenOptions(args);
-    const webRoot = join9(dirname6(fileURLToPath(import.meta.url)), "../web");
-    if (!existsSync2(join9(webRoot, "index.html"))) throw new Error("Web build missing. Run npm run build first");
+    const webRoot = join11(dirname8(fileURLToPath(import.meta.url)), "../web");
+    if (!existsSync2(join11(webRoot, "index.html"))) throw new Error("Web build missing. Run npm run build first");
     const server = createJarvyServer(app, webRoot);
     closeHttp = () => {
       server.close();
       server.closeAllConnections();
     };
-    await new Promise((resolve6, reject) => {
+    await new Promise((resolve5, reject) => {
       server.once("error", reject);
       server.listen(port, host, () => {
         server.off("error", reject);
-        resolve6();
+        resolve5();
       });
     });
     app.start();