@goodfish/jarvy 0.7.0 → 0.9.0

package/dist/server/cli.js

@@ -3,7 +3,7 @@
 // src/server/cli.ts
 import { existsSync as existsSync5 } from "node:fs";
 import { createInterface } from "node:readline/promises";
-import { dirname as dirname9, join as join14 } from "node:path";
+import { dirname as dirname10, join as join16 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/server/api/server.ts
@@ -14,8 +14,8 @@ import { networkInterfaces } from "node:os";
 import { getRequestListener } from "@hono/node-server";
 
 // src/server/api/app.ts
-import { Hono as Hono12 } from "hono";
-import { HTTPException as HTTPException12 } from "hono/http-exception";
+import { Hono as Hono14 } from "hono";
+import { HTTPException as HTTPException13 } from "hono/http-exception";
 import { serveStatic } from "@hono/node-server/serve-static";
 
 // src/server/api/middleware/security.ts
@@ -214,15 +214,15 @@ var MARK = /\[\[q(\d+)\]\]/g;
 function quoteMarks(content2) {
   return [...content2.matchAll(MARK)].map((match) => Number(match[1]));
 }
-function clipQuote(text3) {
-  const chars = [...text3];
-  return chars.length > 200 ? `${chars.slice(0, 120).join("")}\u2026\u2026${chars.slice(-60).join("")}` : text3;
+function clipQuote(text4) {
+  const chars = [...text4];
+  return chars.length > 200 ? `${chars.slice(0, 120).join("")}\u2026\u2026${chars.slice(-60).join("")}` : text4;
 }
 function previewQuotes(content2, quotes) {
   if (!quotes.length) return content2;
   return content2.replace(MARK, (mark, n) => {
-    const quote = quotes[Number(n) - 1];
-    return quote ? `"${clipQuote(quote.text).replace(/\s+/g, " ").trim()}"` : mark;
+    const quote2 = quotes[Number(n) - 1];
+    return quote2 ? `"${clipQuote(quote2.text).replace(/\s+/g, " ").trim()}"` : mark;
   });
 }
 function clipMarked(content2, length) {
@@ -234,16 +234,16 @@ function replyExcerpt(reply) {
 function expandQuotes(content2, quotes, name3) {
   if (!quotes.length) return content2;
   return content2.replace(/[ \t]*\[\[q(\d+)\]\][ \t]*/g, (mark, n, offset, whole) => {
-    const quote = quotes[Number(n) - 1];
-    if (!quote) return mark;
-    const head = `${name3(quote.senderId)}${quote.messageId ? ` (${quote.messageId})` : ""}: `;
-    const block = `${head}${clipQuote(quote.text).trim()}`.split("\n").map((line) => `> ${line}`).join("\n");
+    const quote2 = quotes[Number(n) - 1];
+    if (!quote2) return mark;
+    const head = `${name3(quote2.senderId)}${quote2.messageId ? ` (${quote2.messageId})` : ""}: `;
+    const block = `${head}${clipQuote(quote2.text).trim()}`.split("\n").map((line) => `> ${line}`).join("\n");
     const end = offset + mark.length;
     return `${offset > 0 && whole[offset - 1] !== "\n" ? "\n" : ""}${block}${end < whole.length && whole[end] !== "\n" ? "\n" : ""}`;
   });
 }
-function quoteComparable(text3) {
-  return text3.replace(MARK, "").replace(/!\[[^\]]*\]\([^)]*\)/g, "").replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/<(https?:\/\/[^>\s]+)>/g, "$1").replace(/^[ \t|:*_=-]*$/gm, (line) => /[-*_=]{3}/.test(line) ? "" : line).replace(/^[ \t]*(?:>[ \t>]*|#{1,6}[ \t]+|(?:[-*+]|\d+[.)])[ \t]+|```.*|~~~.*)/gm, "").replace(/\\([\\`*_{}[\]()#+\-.!|~>])/g, "$1").replace(/[*_~`|]/g, "").replace(/\s+/g, "");
+function quoteComparable(text4) {
+  return text4.replace(MARK, "").replace(/!\[[^\]]*\]\([^)]*\)/g, "").replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/<(https?:\/\/[^>\s]+)>/g, "$1").replace(/^[ \t|:*_=-]*$/gm, (line) => /[-*_=]{3}/.test(line) ? "" : line).replace(/^[ \t]*(?:>[ \t>]*|#{1,6}[ \t]+|(?:[-*+]|\d+[.)])[ \t]+|```.*|~~~.*)/gm, "").replace(/\\([\\`*_{}[\]()#+\-.!|~>])/g, "$1").replace(/[*_~`|]/g, "").replace(/\s+/g, "");
 }
 
 // src/server/api/views/chat.ts
@@ -301,7 +301,8 @@ function messageView(message) {
     echoOf: message.echoOf,
     replyTo: message.replyTo,
     reactions: message.reactions,
-    quotes: message.quotes
+    quotes: message.quotes,
+    folded: message.folded
   };
 }
 
@@ -387,6 +388,10 @@ function botRoutes(bots) {
   });
   routes.put("/:id/environment", jsonBody, async (c) => {
     const input = await readJson(c), id = c.req.param("id");
+    if (input.machineId !== void 0) {
+      if (typeof input.machineId !== "string" || typeof input.granted !== "boolean") throw new HTTPException7(400, { message: "machineId and granted (true or false) are needed" });
+      return c.json(bots.grantMachine(id, input.machineId, input.granted));
+    }
     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));
@@ -676,6 +681,7 @@ function channelRoutes({ chats }) {
     const input = await readJson(c);
     return c.json(messageView(chats.react(c.get("actorId"), c.req.param("id"), input.emoji, input.on ?? true)));
   });
+  routes.put("/messages/:id/fold", jsonBody, async (c) => c.json(messageView(chats.fold(c.get("actorId"), c.req.param("id"), (await readJson(c)).folded))));
   routes.put("/chats/:id/mute", jsonBody, async (c) => c.json(chat(c.get("actorId"), chats.mute(c.get("actorId"), c.req.param("id"), (await readJson(c)).muted).id)));
   routes.put("/chats/:id/pin", jsonBody, async (c) => c.json(chat(c.get("actorId"), chats.pin(c.get("actorId"), c.req.param("id"), (await readJson(c)).pinned).id)));
   routes.get("/members/:id/dms", (c) => c.json({ chats: chats.botDirects(c.get("actorId"), c.req.param("id")).map((item) => chatView(item, (id) => chats.member(id))) }));
@@ -843,15 +849,100 @@ function secretRoutes(secrets) {
   return routes;
 }
 
+// src/server/api/routes/environments.ts
+import { Hono as Hono12 } from "hono";
+import { HTTPException as HTTPException12 } from "hono/http-exception";
+function environmentRoutes(bots) {
+  const routes = new Hono12(), machines = bots.machines;
+  routes.get("/", (c) => c.json({ machines: machines.list() }));
+  routes.post("/scan", jsonBody, async (c) => {
+    const input = await readJson(c);
+    return c.json(await machines.scan({ host: input.host, port: input.port, user: input.user }));
+  });
+  routes.post("/keys", async (c) => c.json(await machines.prepareKey(), 201));
+  routes.post("/", jsonBody, async (c) => {
+    const input = await readJson(c);
+    return c.json(await machines.add({
+      name: input.name,
+      host: input.host,
+      port: input.port,
+      user: input.user,
+      directory: input.directory,
+      password: input.password,
+      ...input.keyId !== void 0 ? { keyId: input.keyId } : {},
+      hostKeys: hostKeys(input.hostKeys)
+    }), 201);
+  });
+  routes.put("/:id/password", jsonBody, async (c) => {
+    const input = await readJson(c);
+    return c.json(await machines.setPassword(c.req.param("id"), input.password));
+  });
+  routes.put("/:id", jsonBody, async (c) => {
+    const input = await readJson(c);
+    return c.json(machines.update(c.req.param("id"), { name: input.name, directory: input.directory }));
+  });
+  routes.post("/:id/check", async (c) => c.json(await machines.check(c.req.param("id"))));
+  routes.post("/:id/trust", jsonBody, async (c) => {
+    const input = await readJson(c);
+    return c.json(await machines.trust(c.req.param("id"), input.fingerprints));
+  });
+  routes.delete("/:id", async (c) => {
+    await bots.removeMachine(c.req.param("id"), c.req.query("force") === "1");
+    return c.json({ ok: true });
+  });
+  routes.put("/:id/grants/:botId", jsonBody, async (c) => {
+    const input = await readJson(c);
+    if (typeof input.granted !== "boolean") throw new HTTPException12(400, { message: "granted must be true or false" });
+    bots.grantMachine(c.req.param("botId"), c.req.param("id"), input.granted);
+    return c.json(machines.get(c.req.param("id")));
+  });
+  routes.post("/requests/:chatId/:messageId", jsonBody, async (c) => {
+    const input = await readJson(c);
+    return c.json(messageView(await machines.fulfil(
+      c.get("actorId"),
+      c.req.param("chatId"),
+      c.req.param("messageId"),
+      { password: input.password, ...input.keyId !== void 0 ? { keyId: input.keyId } : {} }
+    )));
+  });
+  return routes;
+}
+function hostKeys(value2) {
+  const keys = value2;
+  const strings = (list) => Array.isArray(list) && list.length > 0 && list.length <= 20 && list.every((item) => typeof item === "string" && item.length <= 2e3);
+  if (!keys || !strings(keys.keys) || !strings(keys.fingerprints)) throw new HTTPException12(400, { message: "hostKeys must be what the scan returned" });
+  return { keys: keys.keys, fingerprints: keys.fingerprints };
+}
+
+// src/server/api/routes/tasks.ts
+import { Hono as Hono13 } from "hono";
+function taskRoutes(services) {
+  const routes = new Hono13();
+  const bot = (id) => {
+    services.bots.describe(id);
+    return id;
+  };
+  routes.get("/bots/:id/tasks", (c) => c.json({ tasks: services.tasks.list(bot(c.req.param("id"))) }));
+  routes.post("/bots/:id/tasks", jsonBody, async (c) => c.json(services.tasks.create(bot(c.req.param("id")), await readJson(c)), 201));
+  routes.put("/bots/:id/tasks/:taskId", jsonBody, async (c) => c.json(services.tasks.update(bot(c.req.param("id")), c.req.param("taskId"), await readJson(c))));
+  routes.post("/bots/:id/tasks/:taskId/:action{pause|resume}", (c) => c.json(services.tasks.setState(bot(c.req.param("id")), c.req.param("taskId"), c.req.param("action") === "pause" ? "paused" : "active")));
+  routes.delete("/bots/:id/tasks/:taskId", (c) => {
+    services.tasks.remove(bot(c.req.param("id")), c.req.param("taskId"));
+    return c.json({ ok: true });
+  });
+  return routes;
+}
+
 // src/server/api/app.ts
 function createHttpApp(services, webRoot) {
-  const app = new Hono12();
+  const app = new Hono14();
   app.use("*", headers);
   app.onError(handleError);
-  const api = new Hono12();
+  const api = new Hono14();
   api.use("*", apiSecurity);
   api.route("/", rootCertificateRoute(services.connection));
   installAuthentication(api, services.account);
+  api.route("/", taskRoutes(services));
   api.route("/bots", botRoutes(services.bots));
   api.route("/", channelRoutes(services));
   api.route("/chats", chatRoutes(services));
@@ -861,8 +952,9 @@ function createHttpApp(services, webRoot) {
   api.route("/", liveRoutes(services));
   api.route("/", connectionRoutes(services.connection));
   api.route("/secrets", secretRoutes(services.secrets));
+  api.route("/environments", environmentRoutes(services.bots));
   api.all("*", () => {
-    throw new HTTPException12(404, { message: "API route not found" });
+    throw new HTTPException13(404, { message: "API route not found" });
   });
   app.route("/api", api);
   app.get("*", serveStatic({ root: webRoot, onFound: (path, c) => {
@@ -872,16 +964,16 @@ function createHttpApp(services, webRoot) {
     c.header("Cache-Control", "no-store");
   } }));
   app.all("*", (c) => {
-    if (c.req.method !== "GET" && c.req.method !== "HEAD") throw new HTTPException12(405, { message: "Method not allowed" });
-    throw new HTTPException12(404, { message: "Web assets missing; run npm run build" });
+    if (c.req.method !== "GET" && c.req.method !== "HEAD") throw new HTTPException13(405, { message: "Method not allowed" });
+    throw new HTTPException13(404, { message: "Web assets missing; run npm run build" });
   });
   return app;
 }
 
 // src/server/api/server.ts
 var own = { at: 0, addresses: /* @__PURE__ */ new Set() };
-function fromThisMachine(address = "") {
-  const plain2 = address.replace(/^::ffff:/, "");
+function fromThisMachine(address2 = "") {
+  const plain2 = address2.replace(/^::ffff:/, "");
   if (/^127\./.test(plain2) || plain2 === "::1") return true;
   if (Date.now() - own.at > 6e4) own = { at: Date.now(), addresses: new Set(Object.values(networkInterfaces()).flatMap((list) => (list ?? []).map((item) => item.address))) };
   return own.addresses.has(plain2);
@@ -945,7 +1037,7 @@ 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 as randomBytes3, randomInt as randomInt3, randomUUID as randomUUID9, scryptSync, timingSafeEqual } from "node:crypto";
+import { createHash, randomBytes as randomBytes3, randomInt as randomInt3, randomUUID as randomUUID10, scryptSync, timingSafeEqual } from "node:crypto";
 import { chmodSync as chmodSync2, mkdirSync as mkdirSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { dirname as dirname2, join as join3, resolve } from "node:path";
@@ -1301,8 +1393,8 @@ var Cipher = class _Cipher {
   location() {
     return this.master.location;
   }
-  static sealed(text3) {
-    return text3.startsWith(PREFIX);
+  static sealed(text4) {
+    return text4.startsWith(PREFIX);
   }
   seal(plain2, context2) {
     const iv = randomBytes(12), cipher = createCipheriv("aes-256-gcm", this.master.key, iv);
@@ -1362,6 +1454,106 @@ function migrateSecrets(db, cipher) {
   }
 }
 
+// src/server/infra/storage/migrations/ssh-schema.ts
+function migrateSsh(db) {
+  const version = db.prepare("PRAGMA user_version").get().user_version;
+  if (version >= 22) return;
+  db.exec("PRAGMA foreign_keys=OFF; BEGIN IMMEDIATE");
+  try {
+    db.exec(`
+      CREATE TABLE environments_next(id TEXT PRIMARY KEY, owner_id TEXT NOT NULL REFERENCES members(id),
+        kind TEXT NOT NULL CHECK(kind IN ('host','computer','ssh')), name TEXT NOT NULL DEFAULT '',
+        connection TEXT NOT NULL DEFAULT '{}', directory TEXT, bot_id TEXT REFERENCES bots(id),
+        key TEXT, host_keys TEXT, created_at INTEGER NOT NULL, deleted_at INTEGER);
+      INSERT INTO environments_next(id,owner_id,kind,name,connection,directory,bot_id,created_at,deleted_at)
+        SELECT id,owner_id,kind,name,connection,directory,bot_id,created_at,deleted_at FROM environments;
+      DROP TABLE environments;
+      ALTER TABLE environments_next RENAME TO environments;
+      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;
+      PRAGMA user_version=22;
+    `);
+    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/task-schema.ts
+function migrateTasks(db) {
+  const version = db.prepare("PRAGMA user_version").get().user_version;
+  if (version >= 23) 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 tasks(id TEXT PRIMARY KEY, bot_id TEXT NOT NULL REFERENCES bots(id) ON DELETE CASCADE,
+        name TEXT NOT NULL, instruction TEXT NOT NULL,
+        schedule_kind TEXT NOT NULL CHECK(schedule_kind IN ('once','every','daily','weekly')),
+        schedule_at INTEGER, schedule_minutes INTEGER, schedule_hour INTEGER, schedule_minute INTEGER, schedule_weekday INTEGER,
+        state TEXT NOT NULL CHECK(state IN ('active','paused','done')),
+        next_run_at INTEGER, last_run_at INTEGER, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL, deleted_at INTEGER);
+      CREATE INDEX tasks_due ON tasks(state, next_run_at) WHERE deleted_at IS NULL;
+      CREATE INDEX tasks_bot ON tasks(bot_id) WHERE deleted_at IS 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','task')), 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.exec("PRAGMA user_version=23");
+    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/ssh-login-schema.ts
+function migrateSshLogin(db) {
+  const version = db.prepare("PRAGMA user_version").get().user_version;
+  if (version >= 24) return;
+  db.exec("BEGIN IMMEDIATE");
+  try {
+    db.exec("ALTER TABLE environments ADD COLUMN password TEXT; PRAGMA user_version=24");
+    db.exec("COMMIT");
+  } catch (error) {
+    db.exec("ROLLBACK");
+    throw error;
+  }
+}
+
+// src/server/infra/storage/migrations/fold-schema.ts
+function migrateFolds(db) {
+  const version = db.prepare("PRAGMA user_version").get().user_version;
+  if (version >= 25) return;
+  db.exec("BEGIN IMMEDIATE");
+  try {
+    db.exec("ALTER TABLE messages ADD COLUMN folded_at INTEGER; PRAGMA user_version=25;");
+    db.exec("COMMIT");
+  } catch (error) {
+    db.exec("ROLLBACK");
+    throw error;
+  }
+}
+
 // src/server/infra/storage/migrations/schema.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 
@@ -1484,7 +1676,7 @@ function migrateRuntime(db) {
 // src/server/infra/storage/migrations/schema.ts
 function migrateDatabase(db, cipher) {
   const version = db.prepare("PRAGMA user_version").get().user_version;
-  if (version > 21) throw new Error(`Unsupported database version: ${version}`);
+  if (version > 25) throw new Error(`Unsupported database version: ${version}`);
   migratePrototype(db);
   if (version >= 5) {
     migrateRuntime(db);
@@ -1503,6 +1695,10 @@ function migrateDatabase(db, cipher) {
     migrateAgent(db);
     migrateEnvironments(db);
     migrateSecrets(db, cipher);
+    migrateSsh(db);
+    migrateTasks(db);
+    migrateSshLogin(db);
+    migrateFolds(db);
     return;
   }
   db.exec("PRAGMA foreign_keys=OFF; BEGIN IMMEDIATE");
@@ -1579,6 +1775,10 @@ function migrateDatabase(db, cipher) {
   migrateAgent(db);
   migrateEnvironments(db);
   migrateSecrets(db, cipher);
+  migrateSsh(db);
+  migrateTasks(db);
+  migrateSshLogin(db);
+  migrateFolds(db);
 }
 
 // src/server/infra/storage/chat-repository.ts
@@ -1691,14 +1891,14 @@ var ChannelRepository = class {
   }
   /** Channel notice / thread summary: any member who can write there, people and Bots alike. The routed
    * deliveries (A41) are written with the new version; `detail` is that version. */
-  setNote(actorId, chatId, text3, deliveries = []) {
+  setNote(actorId, chatId, text4, deliveries = []) {
     this.chats.assertAccess(actorId, chatId, true);
     const type = this.db.prepare("SELECT type FROM chats WHERE id=?").get(chatId).type;
     if (type === "dm") throw new ChatError(400, "Direct messages have no notice");
     const now = Date.now();
     inTransaction(this.db, () => {
       this.db.prepare(`INSERT INTO chat_notes(chat_id,text,updated_by,updated_at,version) VALUES(?,?,?,?,1)
-        ON CONFLICT(chat_id) DO UPDATE SET text=excluded.text,updated_by=excluded.updated_by,updated_at=excluded.updated_at,version=version+1`).run(chatId, text3, actorId, now);
+        ON CONFLICT(chat_id) DO UPDATE SET text=excluded.text,updated_by=excluded.updated_by,updated_at=excluded.updated_at,version=version+1`).run(chatId, text4, actorId, now);
       this.db.prepare("UPDATE chats SET updated_at=? WHERE id=?").run(now, chatId);
       this.markNoteSeen(actorId, chatId);
       const version = String(this.db.prepare("SELECT version FROM chat_notes WHERE chat_id=?").get(chatId).version);
@@ -1904,7 +2104,7 @@ var InteractionRepository = class {
   notices(botId) {
     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) }));
+    return rows2.filter((row) => this.chats.canAccess(botId, row.chatId)).map(({ actorId, ...row }) => ({ ...row, actor: actorId ? this.chats.member(actorId) : null }));
   }
   /** These notices reached the Bot (steered into its run, or in a batch it was given). */
   tell(botId, ids) {
@@ -1940,6 +2140,10 @@ var InteractionRepository = class {
     return this.db.prepare(`SELECT DISTINCT member_id AS id FROM chat_states WHERE muted=1 AND chat_id IN
       (SELECT id FROM chats WHERE id=? UNION SELECT parent_id FROM chats WHERE id=? AND parent_id IS NOT NULL)`).all(chatId, chatId).map((row) => row.id);
   }
+  /** Folds a message to one line in the interface, or unfolds it (A60); its content and everything else stay. */
+  setFolded(messageId, folded) {
+    this.db.prepare("UPDATE messages SET folded_at=? WHERE id=?").run(folded ? Date.now() : null, messageId);
+  }
   setPinned(memberId, chatId, pinned) {
     this.chats.assertAccess(memberId, chatId);
     this.db.prepare(`INSERT INTO chat_states(chat_id,member_id,pinned) VALUES(?,?,?)
@@ -1954,7 +2158,7 @@ var QuoteRepository = class {
   }
   /** Inside the caller's transaction. */
   insert(messageId, quotes) {
-    quotes.forEach((quote, index) => this.db.prepare("INSERT INTO message_quotes(message_id,position,source_id,source_sender_id,text) VALUES(?,?,?,?,?)").run(messageId, index + 1, quote.messageId, quote.senderId, quote.text));
+    quotes.forEach((quote2, index) => this.db.prepare("INSERT INTO message_quotes(message_id,position,source_id,source_sender_id,text) VALUES(?,?,?,?,?)").run(messageId, index + 1, quote2.messageId, quote2.senderId, quote2.text));
   }
   of(messageId) {
     return this.db.prepare("SELECT source_id AS messageId,source_sender_id AS senderId,text FROM message_quotes WHERE message_id=? ORDER BY position").all(messageId);
@@ -1962,7 +2166,7 @@ var QuoteRepository = class {
 };
 
 // src/server/infra/storage/chat-repository.ts
-var MESSAGE_COLUMNS = "id,chat_id AS chatId,sequence,sender_id AS senderId,content,created_at AS createdAt,history_id AS historyId,tool_call_id AS toolCallId,question,echo_of AS echoOf,reply_to AS replyTo";
+var MESSAGE_COLUMNS = "id,chat_id AS chatId,sequence,sender_id AS senderId,content,created_at AS createdAt,history_id AS historyId,tool_call_id AS toolCallId,question,echo_of AS echoOf,reply_to AS replyTo,folded_at AS foldedAt";
 var CHAT_COLUMNS = `c.id,c.type,c.title,c.owner_id AS ownerId,c.created_at AS createdAt,c.updated_at AS updatedAt,
   c.section_id AS sectionId,c.topic,c.parent_id AS parentId,c.root_message_id AS rootMessageId,c.status,
   (SELECT content FROM messages WHERE chat_id=c.id ORDER BY sequence DESC LIMIT 1) AS lastMessage,
@@ -2117,12 +2321,12 @@ var ChatRepository = class {
     return rows2.map((row) => this.messageFromRow(row));
   }
   /** Search every chat the member can read: its DMs and channels and their threads (newest first). `within` keeps
-   * one chat, a channel with its threads. */
-  searchAll(actorId, query, limit, within) {
-    const scope = within ? "AND (c.id=? OR c.parent_id=?)" : "";
+   * one chat, a channel with its threads; `sender` keeps one member's messages. */
+  searchAll(actorId, query, limit, within, sender) {
+    const scope = (within ? "AND (c.id=? OR c.parent_id=?) " : "") + (sender ? "AND m.sender_id=?" : "");
     const rows2 = this.db.prepare(`SELECT ${MESSAGE_COLUMNS.split(",").map((column) => `m.${column}`).join(",")} FROM messages m JOIN chats c ON c.id=m.chat_id
       JOIN chat_members cm ON cm.chat_id=COALESCE(c.parent_id,c.id) AND cm.member_id=? AND cm.can_read=1
-      WHERE instr(lower(m.content),lower(?))>0 ${scope} ORDER BY m.position DESC LIMIT ?`).all(actorId, query, ...within ? [within, within] : [], limit);
+      WHERE instr(lower(m.content),lower(?))>0 ${scope} ORDER BY m.position DESC LIMIT ?`).all(actorId, query, ...within ? [within, within] : [], ...sender ? [sender] : [], limit);
     return rows2.map((row) => this.messageFromRow(row));
   }
   /** Channels and threads the member can read whose title, topic or notice / summary contains the query (newest first). */
@@ -2141,9 +2345,10 @@ var ChatRepository = class {
     const row = this.db.prepare(`SELECT ${MESSAGE_COLUMNS} FROM messages WHERE id=?`).get(id);
     return row && this.canAccess(actorId, row.chatId) ? this.messageFromRow(row) : null;
   }
-  search(actorId, chatId, query, limit) {
+  search(actorId, chatId, query, limit, sender) {
     this.assertAccess(actorId, chatId);
-    const rows2 = this.db.prepare(`SELECT ${MESSAGE_COLUMNS} FROM messages WHERE chat_id=? AND instr(lower(content),lower(?))>0 ORDER BY sequence DESC LIMIT ?`).all(chatId, query, limit);
+    const rows2 = this.db.prepare(`SELECT ${MESSAGE_COLUMNS} FROM messages WHERE chat_id=? AND instr(lower(content),lower(?))>0 ${sender ? "AND sender_id=?" : ""}
+      ORDER BY sequence DESC LIMIT ?`).all(chatId, query, ...sender ? [sender] : [], limit);
     return rows2.map((row) => this.messageFromRow(row));
   }
   sentActivity(actorId, senderId, before, limit) {
@@ -2174,7 +2379,8 @@ var ChatRepository = class {
       echoOf: row.echoOf === null ? null : { id: row.echoOf, title: this.db.prepare("SELECT title FROM chats WHERE id=?").get(row.echoOf).title },
       replyTo: row.replyTo === null ? null : this.quote(row.replyTo),
       reactions: this.interactions.reactions(row.id),
-      quotes: this.quotes.of(row.id)
+      quotes: this.quotes.of(row.id),
+      folded: row.foldedAt !== null
     };
   }
   /** What a reply shows of the message it answers: who wrote it and the start of its content, with its quotes ("" is attachments only). */
@@ -2236,14 +2442,15 @@ var ChatRepository = class {
             toolCallId: draft.source?.toolCallId ?? null,
             question: null,
             echoOf: chatId,
-            replyTo: null
+            replyTo: null,
+            foldedAt: null
           });
         }
       }
       const file = this.db.prepare("SELECT name FROM attachments WHERE message_id=? ORDER BY created_at,rowid LIMIT 1").get(id);
       const title = draft.content ? previewQuotes(draft.content, draft.quotes ?? []).slice(0, 46).replace(/\s+/g, " ") : file?.name.slice(0, 46) ?? "";
       this.db.prepare("UPDATE chats SET title=CASE WHEN title='' AND ?=1 THEN ? ELSE title END,updated_at=? WHERE id=?").run(sequence, title, createdAt, chatId);
-      const message = this.messageFromRow({ id, chatId, sequence, senderId: actorId, content: draft.content, createdAt, historyId: draft.source?.historyId ?? null, toolCallId: draft.source?.toolCallId ?? null, question, echoOf: null, replyTo: draft.replyTo ?? null });
+      const message = this.messageFromRow({ id, chatId, sequence, senderId: actorId, content: draft.content, createdAt, historyId: draft.source?.historyId ?? null, toolCallId: draft.source?.toolCallId ?? null, question, echoOf: null, replyTo: draft.replyTo ?? null, foldedAt: null });
       this.db.exec("COMMIT");
       return { message, duplicate: false, ...echo ? { echo } : {} };
     } catch (error) {
@@ -2633,11 +2840,21 @@ var AgentRepository = class {
 
 // 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 FIELDS = (table) => ["id", "owner_id AS ownerId", "kind", "bot_id AS botId", "name", "directory", "connection"].map((column) => `${table}${column}`).join(", ");
+var COLUMNS = FIELDS("");
+var record = (row) => ({
+  id: row.id,
+  ownerId: row.ownerId,
+  kind: row.kind,
+  botId: row.botId,
+  name: row.name,
+  directory: row.directory,
+  spec: JSON.parse(row.connection)
+});
 var EnvironmentRepository = class {
-  constructor(db, ownerId) {
+  constructor(db, cipher, ownerId) {
     this.db = db;
+    this.cipher = cipher;
     this.ownerId = ownerId;
   }
   get(id) {
@@ -2659,7 +2876,7 @@ var EnvironmentRepository = class {
   }
   /** 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
+    return this.db.prepare(`SELECT ${FIELDS("e.")} 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. */
@@ -2703,7 +2920,7 @@ var EnvironmentRepository = class {
   }
   /** 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
+    return this.db.prepare(`SELECT ${FIELDS("e.")} 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. */
@@ -2713,6 +2930,68 @@ var EnvironmentRepository = class {
   revoke(environmentId, botId) {
     return Number(this.db.prepare("DELETE FROM environment_grants WHERE environment_id=? AND bot_id=?").run(environmentId, botId).changes) > 0;
   }
+  /** The SSH machines, oldest first. */
+  sshMachines() {
+    return this.db.prepare(`SELECT ${COLUMNS} FROM environments WHERE kind='ssh' AND deleted_at IS NULL ORDER BY created_at, id`).all().map(record);
+  }
+  addSsh(input, id = randomUUID7()) {
+    const { host, port, user, home, platform } = input;
+    this.db.prepare("INSERT INTO environments(id,owner_id,kind,name,connection,directory,key,host_keys,password,created_at) VALUES(?,?,'ssh',?,?,?,?,?,?,?)").run(
+      id,
+      this.ownerId(),
+      input.name,
+      JSON.stringify({ host, port: String(port), user, home, platform }),
+      input.directory,
+      this.cipher.seal(input.privateKey, `environment:${id}`),
+      JSON.stringify(input.hostKeys),
+      input.password ? this.cipher.seal(input.password, `environment-password:${id}`) : null,
+      Date.now()
+    );
+    return this.get(id);
+  }
+  /** `password`: a new one for a machine reached with its password; null goes back to the key (A59). */
+  updateSsh(id, input) {
+    if (input.password !== void 0) this.db.prepare("UPDATE environments SET password=? WHERE id=? AND kind='ssh'").run(input.password === null ? null : this.cipher.seal(input.password, `environment-password:${id}`), id);
+    if (input.name !== void 0) this.db.prepare("UPDATE environments SET name=? WHERE id=? AND kind='ssh'").run(input.name, id);
+    if (input.directory !== void 0) this.db.prepare("UPDATE environments SET directory=? WHERE id=? AND kind='ssh'").run(input.directory, id);
+    if (input.hostKeys !== void 0) this.db.prepare("UPDATE environments SET host_keys=? WHERE id=? AND kind='ssh'").run(JSON.stringify(input.hostKeys), id);
+  }
+  /** The machine's private key (null when it doesn't open under this installation's key), its password when it is
+   * reached with one (A59; `passwordUnreadable` when it is kept but doesn't open) and the accepted host keys. */
+  sshSecrets(id) {
+    const row = this.db.prepare("SELECT key, password, host_keys AS hostKeys FROM environments WHERE id=? AND kind='ssh' AND deleted_at IS NULL").get(id);
+    if (!row) return null;
+    const password = row.password ? this.cipher.open(row.password, `environment-password:${id}`) : null;
+    return {
+      privateKey: row.key ? this.cipher.open(row.key, `environment:${id}`) : null,
+      password,
+      passwordUnreadable: !!row.password && password === null,
+      hostKeys: row.hostKeys ? JSON.parse(row.hostKeys) : { keys: [], fingerprints: [] }
+    };
+  }
+  /** Whether a machine is reached with its password rather than the key (A59). */
+  usesPassword(id) {
+    return !!this.db.prepare("SELECT password FROM environments WHERE id=? AND kind='ssh'").get(id)?.password;
+  }
+  /** The Bots that may use an environment. */
+  grantees(environmentId) {
+    return this.db.prepare("SELECT g.bot_id AS botId FROM environment_grants g JOIN bots b ON b.id=g.bot_id WHERE g.environment_id=? AND b.deleted_at IS NULL ORDER BY g.granted_at").all(environmentId).map((row) => row.botId);
+  }
+  /** Deletes an SSH machine with its key: Bots working there are back in their default. Returns those Bots. */
+  dropSsh(id) {
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const moved = this.db.prepare("SELECT id FROM bots WHERE current_environment_id=?").all(id).map((row) => row.id);
+      this.db.prepare("UPDATE bots SET current_environment_id=home_environment_id WHERE current_environment_id=?").run(id);
+      this.db.prepare("DELETE FROM environment_grants WHERE environment_id=?").run(id);
+      this.db.prepare("UPDATE environments SET deleted_at=?, key=NULL, password=NULL WHERE id=? AND kind='ssh'").run(Date.now(), id);
+      this.db.exec("COMMIT");
+      return moved;
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
 };
 
 // src/server/infra/storage/settings-repository.ts
@@ -2834,6 +3113,193 @@ var SecretRepository = class {
   }
 };
 
+// src/server/infra/storage/task-repository.ts
+import { randomUUID as randomUUID9 } from "node:crypto";
+
+// src/server/shared/task.ts
+var TASK_MINUTES_MIN = 5;
+function localAt(day, hour, minute, addDays) {
+  const at2 = new Date(day.getFullYear(), day.getMonth(), day.getDate() + addDays, hour, minute, 0, 0);
+  return at2.getTime();
+}
+function nextAfter(schedule, from) {
+  if (schedule.kind === "once") return schedule.at > from ? schedule.at : null;
+  if (schedule.kind === "every") {
+    const step = schedule.minutes * 6e4;
+    return schedule.since + Math.max(1, Math.floor((from - schedule.since) / step) + 1) * step;
+  }
+  const day = new Date(from);
+  if (schedule.kind === "daily") {
+    const today = localAt(day, schedule.hour, schedule.minute, 0);
+    return today > from ? today : localAt(day, schedule.hour, schedule.minute, 1);
+  }
+  const ahead = (schedule.weekday - day.getDay() + 7) % 7;
+  const candidate = localAt(day, schedule.hour, schedule.minute, ahead);
+  return candidate > from ? candidate : localAt(day, schedule.hour, schedule.minute, ahead + 7);
+}
+function describeSchedule(schedule) {
+  const clock = (hour, minute) => `${String(hour).padStart(2, "0")}:${String(minute).padStart(2, "0")}`;
+  if (schedule.kind === "once") return `once at ${localIso(schedule.at)}`;
+  if (schedule.kind === "every") return schedule.minutes % 60 === 0 && schedule.minutes >= 120 ? `every ${schedule.minutes / 60} hours` : `every ${schedule.minutes} minutes`;
+  if (schedule.kind === "daily") return `daily at ${clock(schedule.hour, schedule.minute)}`;
+  const days = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+  return `every ${days[schedule.weekday]} at ${clock(schedule.hour, schedule.minute)}`;
+}
+function localIso(time2) {
+  const at2 = new Date(time2), offset = -at2.getTimezoneOffset(), sign2 = offset >= 0 ? "+" : "-", abs = Math.abs(offset);
+  const pad = (value2) => String(value2).padStart(2, "0");
+  return `${at2.getFullYear()}-${pad(at2.getMonth() + 1)}-${pad(at2.getDate())}T${pad(at2.getHours())}:${pad(at2.getMinutes())}:${pad(at2.getSeconds())}${sign2}${pad(Math.floor(abs / 60))}:${pad(abs % 60)}`;
+}
+
+// src/server/infra/storage/task-repository.ts
+var COLUMNS3 = `id,bot_id,name,instruction,schedule_kind,schedule_at,schedule_minutes,schedule_hour,schedule_minute,schedule_weekday,
+  state,next_run_at,last_run_at,created_at,updated_at`;
+var LIMIT = 200;
+function scheduleOf(row) {
+  switch (row.schedule_kind) {
+    case "once":
+      return { kind: "once", at: row.schedule_at };
+    case "every":
+      return { kind: "every", minutes: row.schedule_minutes, since: row.schedule_at };
+    case "daily":
+      return { kind: "daily", hour: row.schedule_hour, minute: row.schedule_minute };
+    case "weekly":
+      return { kind: "weekly", weekday: row.schedule_weekday, hour: row.schedule_hour, minute: row.schedule_minute };
+  }
+}
+function toTask(row) {
+  return {
+    id: row.id,
+    botId: row.bot_id,
+    name: row.name,
+    instruction: row.instruction,
+    schedule: scheduleOf(row),
+    state: row.state,
+    nextRunAt: row.next_run_at,
+    lastRunAt: row.last_run_at,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function scheduleColumns(schedule) {
+  return {
+    kind: schedule.kind,
+    at: schedule.kind === "once" ? schedule.at : schedule.kind === "every" ? schedule.since : null,
+    minutes: schedule.kind === "every" ? schedule.minutes : null,
+    hour: schedule.kind === "daily" || schedule.kind === "weekly" ? schedule.hour : null,
+    minute: schedule.kind === "daily" || schedule.kind === "weekly" ? schedule.minute : null,
+    weekday: schedule.kind === "weekly" ? schedule.weekday : null
+  };
+}
+var TaskRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /** A Bot's tasks: active ones first, soonest first; then paused and done ones. */
+  list(botId) {
+    const rows2 = this.db.prepare(`SELECT ${COLUMNS3} FROM tasks WHERE bot_id=? AND deleted_at IS NULL
+      ORDER BY state='active' DESC, COALESCE(next_run_at,0), created_at LIMIT ${LIMIT}`).all(botId);
+    return rows2.map(toTask);
+  }
+  get(botId, id) {
+    const row = this.db.prepare(`SELECT ${COLUMNS3} FROM tasks WHERE id=? AND bot_id=? AND deleted_at IS NULL`).get(id, botId);
+    return row ? toTask(row) : null;
+  }
+  create(input) {
+    const now = Date.now(), at2 = nextAfter(input.schedule, now);
+    if (at2 === null) throw new ValidationError("A one-off task has to be in the future", "task_time_past");
+    const id = randomUUID9(), columns = scheduleColumns(input.schedule);
+    this.db.prepare(`INSERT INTO tasks(id,bot_id,name,instruction,schedule_kind,schedule_at,schedule_minutes,schedule_hour,schedule_minute,schedule_weekday,
+      state,next_run_at,last_run_at,created_at,updated_at) VALUES(?,?,?,?,?,?,?,?,?,?,'active',?,NULL,?,?)`).run(id, input.botId, input.name, input.instruction, columns.kind, columns.at, columns.minutes, columns.hour, columns.minute, columns.weekday, at2, now, now);
+    return this.get(input.botId, id);
+  }
+  /** Replaces what is given; a new schedule recomputes the next run from now, and turns a one-off that already ran back on. */
+  update(botId, id, input) {
+    const task = this.get(botId, id);
+    if (!task) return null;
+    const now = Date.now(), schedule = input.schedule ?? task.schedule, columns = scheduleColumns(schedule);
+    if (input.schedule && nextAfter(schedule, now) === null) throw new ValidationError("A one-off task has to be in the future", "task_time_past");
+    const state = input.schedule && task.state === "done" ? "active" : task.state;
+    const next = state !== "active" ? null : input.schedule ? nextAfter(schedule, now) : task.nextRunAt;
+    this.db.prepare(`UPDATE tasks SET name=?,instruction=?,schedule_kind=?,schedule_at=?,schedule_minutes=?,schedule_hour=?,schedule_minute=?,
+      schedule_weekday=?,state=?,next_run_at=?,updated_at=? WHERE id=? AND bot_id=?`).run(
+      input.name ?? task.name,
+      input.instruction ?? task.instruction,
+      columns.kind,
+      columns.at,
+      columns.minutes,
+      columns.hour,
+      columns.minute,
+      columns.weekday,
+      state,
+      next,
+      now,
+      id,
+      botId
+    );
+    return this.get(botId, id);
+  }
+  /** Pauses or resumes it; resuming a one-off already past fails, as making one in the past does. */
+  setState(botId, id, state) {
+    const task = this.get(botId, id);
+    if (!task) return null;
+    const now = Date.now(), next = state === "active" ? nextAfter(task.schedule, now) : null;
+    if (state === "active" && next === null) throw new ValidationError("A one-off task has to be in the future", "task_time_past");
+    this.db.prepare("UPDATE tasks SET state=?,next_run_at=?,updated_at=? WHERE id=? AND bot_id=?").run(state, next, now, id, botId);
+    return this.get(botId, id);
+  }
+  /** Gone from the lists and from the scheduler; the row stays for the record. */
+  remove(botId, id) {
+    const now = Date.now();
+    return Number(this.db.prepare("UPDATE tasks SET deleted_at=?,next_run_at=NULL,updated_at=? WHERE id=? AND bot_id=? AND deleted_at IS NULL").run(now, now, id, botId).changes) > 0;
+  }
+  /** The soonest time any task runs; the scheduler sleeps until then. Null when nothing is scheduled. */
+  soonest() {
+    const row = this.db.prepare("SELECT min(next_run_at) AS at FROM tasks WHERE deleted_at IS NULL AND state='active' AND next_run_at IS NOT NULL").get();
+    return row?.at ?? null;
+  }
+  due(now) {
+    return this.db.prepare(`SELECT ${COLUMNS3.replace(/(\w+)/g, "t.$1")} FROM tasks t JOIN bots b ON b.id=t.bot_id
+      WHERE t.deleted_at IS NULL AND t.state='active' AND t.next_run_at<=? AND b.deleted_at IS NULL ORDER BY t.next_run_at`).all(now);
+  }
+  /** The Bots with a task due now, so the caller can find each one's DM before `fire`. */
+  dueBots(now = Date.now()) {
+    return [...new Set(this.due(now).map((row) => row.bot_id))];
+  }
+  /** The tasks that are due, oldest first, each already moved on: its inbox row (in `dms`, the Bot's DM with its owner)
+   * is written and its next run set in one transaction, so a crash can neither lose nor repeat a run. A Bot missing
+   * from `dms` keeps its task due for the next pass. `at` is when it was due. */
+  fire(dms, now = Date.now()) {
+    const due = this.due(now).filter((row) => dms.has(row.bot_id));
+    if (!due.length) return [];
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const fired = [];
+      for (const row of due) {
+        const at2 = row.next_run_at, next = nextAfter(scheduleOf(row), now);
+        this.db.prepare("UPDATE tasks SET last_run_at=?,next_run_at=?,state=?,updated_at=? WHERE id=?").run(at2, next, next === null ? "done" : "active", now, row.id);
+        this.db.prepare(`INSERT INTO inbox(member_id,kind,reason,urgency,chat_id,actor_id,detail,created_at) VALUES(?,'task','schedule','queue',?,NULL,?,?)`).run(row.bot_id, dms.get(row.bot_id), JSON.stringify({ task: row.id, due: at2 }), now);
+        fired.push({ taskId: row.id, botId: row.bot_id, chatId: dms.get(row.bot_id), at: at2 });
+      }
+      this.db.exec("COMMIT");
+      return fired;
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  /** At start: tasks whose time passed while the server was not running move on to their next time; a one-off already
+   * past is done without running. Returns how many were skipped. */
+  skipOverdue(now = Date.now()) {
+    const rows2 = this.db.prepare(`SELECT ${COLUMNS3} FROM tasks WHERE deleted_at IS NULL AND state='active' AND next_run_at<=?`).all(now);
+    for (const row of rows2) {
+      const next = nextAfter(scheduleOf(row), now);
+      this.db.prepare("UPDATE tasks SET next_run_at=?,state=?,updated_at=? WHERE id=?").run(next, next === null ? "done" : "active", now, row.id);
+    }
+    return rows2.length;
+  }
+};
+
 // src/server/infra/vault/master-key.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
@@ -2937,6 +3403,8 @@ var Store = class {
   agent;
   environments;
   settings;
+  /** Scheduled tasks (A58). */
+  tasks;
   secrets;
   /** Seals secrets and model credentials under the master key (A52). */
   cipher;
@@ -2958,8 +3426,9 @@ var Store = class {
     this.runtime = new RuntimeRepository(this.db);
     this.credentials = new CredentialRepository(this.db, this.cipher);
     this.agent = new AgentRepository(this.db, () => this.userMemberId());
-    this.environments = new EnvironmentRepository(this.db, () => this.userMemberId());
+    this.environments = new EnvironmentRepository(this.db, this.cipher, () => this.userMemberId());
     this.settings = new SettingsRepository(this.db);
+    this.tasks = new TaskRepository(this.db);
     this.secrets = new SecretRepository(this.db, this.cipher, () => this.userMemberId());
     this.agent.ensure();
   }
@@ -2970,7 +3439,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 = randomUUID9();
+    const id = randomUUID10();
     this.db.prepare("INSERT INTO installation(id,device_id) VALUES(1,?)").run(id);
     return id;
   }
@@ -3042,7 +3511,7 @@ var Store = class {
     if (!this.getBot(id)) return false;
     this.db.exec("BEGIN IMMEDIATE");
     try {
-      this.db.prepare("UPDATE bots SET deleted_at=? WHERE id=?").run(Date.now(), id);
+      this.db.prepare("UPDATE bots SET deleted_at=?, connection_id=NULL WHERE id=?").run(Date.now(), id);
       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);
@@ -3064,7 +3533,7 @@ var Store = class {
   /** The caller names the Bot (A45: the interface picks a free default in its own language). */
   createBot(name3) {
     const clean = this.botName(name3);
-    const id = randomUUID9(), createdAt = Date.now();
+    const id = randomUUID10(), createdAt = Date.now();
     this.db.exec("BEGIN IMMEDIATE");
     try {
       this.db.prepare("INSERT INTO members VALUES(?,'bot')").run(id);
@@ -3136,7 +3605,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 = randomUUID9(), now = Date.now();
+    const id = randomUUID10(), 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());
@@ -3168,10 +3637,21 @@ var Store = class {
     this.db.prepare("UPDATE provider_connections SET display_name=?,base_url=?,api=?,updated_at=?,provider_name=? WHERE id=?").run(name3, baseUrl, api, Date.now(), providerName, id);
     return this.getModelConnection(id);
   }
+  /** Deleted Bots keep their row (deleteBot) but use nothing: their link to the connection is cleared with it. */
   deleteModelConnection(id) {
     if (!this.getModelConnection(id)) return false;
-    if (this.db.prepare("SELECT 1 FROM bots WHERE connection_id=? LIMIT 1").get(id)) throw new ConflictError("A Bot is using this connection");
-    return Number(this.db.prepare("DELETE FROM provider_connections WHERE id=?").run(id).changes) > 0;
+    const users = this.db.prepare("SELECT name FROM bots WHERE connection_id=? AND deleted_at IS NULL ORDER BY name").all(id).map((row) => row.name);
+    if (users.length) throw new ConflictError(`In use by ${users.join(", ")}`, "connection_in_use", { bots: users.join(", "), count: users.length });
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      this.db.prepare("UPDATE bots SET connection_id=NULL WHERE connection_id=? AND deleted_at IS NOT NULL").run(id);
+      const deleted = Number(this.db.prepare("DELETE FROM provider_connections WHERE id=?").run(id).changes) > 0;
+      this.db.exec("COMMIT");
+      return deleted;
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
   }
   saveModelCredential(id, input) {
     const connection = this.getModelConnection(id);
@@ -3261,10 +3741,10 @@ var set = (...items) => tlv(49, Buffer.concat(items));
 var integer2 = (bytes) => tlv(2, bytes[0] & 128 ? Buffer.concat([Buffer.from([0]), bytes]) : bytes);
 var bits = (bytes, unused = 0) => tlv(3, Buffer.concat([Buffer.from([unused]), bytes]));
 var octets = (bytes) => tlv(4, bytes);
-var utf8 = (text3) => tlv(12, Buffer.from(text3, "utf8"));
+var utf8 = (text4) => tlv(12, Buffer.from(text4, "utf8"));
 var TRUE = tlv(1, Buffer.from([255]));
-function oid(text3) {
-  const [a, b, ...rest] = text3.split(".").map(Number);
+function oid(text4) {
+  const [a, b, ...rest] = text4.split(".").map(Number);
   const out = [a * 40 + b];
   for (const value2 of rest) {
     const chunk = [value2 & 127];
@@ -3281,10 +3761,10 @@ var ECDSA_SHA256 = seq(oid("1.2.840.10045.4.3.2"));
 var name = (common) => seq(set(seq(oid("2.5.4.10"), utf8("Jarvy"))), set(seq(oid("2.5.4.3"), utf8(common))));
 var extension = (id, value2, critical = false) => seq(oid(id), ...critical ? [TRUE] : [], octets(value2));
 var keyId = (key) => createHash2("sha1").update(key.export({ type: "spki", format: "der" })).digest();
-function ipBytes(address) {
-  if (isIPv4(address)) return Buffer.from(address.split(".").map(Number));
-  if (!isIPv6(address) || address.includes(".")) return null;
-  const [head, tail] = address.split("::");
+function ipBytes(address2) {
+  if (isIPv4(address2)) return Buffer.from(address2.split(".").map(Number));
+  if (!isIPv6(address2) || address2.includes(".")) return null;
+  const [head, tail] = address2.split("::");
   const groups = (part) => part ? part.split(":") : [];
   const left = groups(head), right = groups(tail);
   const all = tail === void 0 ? left : [...left, ...Array(8 - left.length - right.length).fill("0"), ...right];
@@ -3366,8 +3846,8 @@ function read2(dir, file) {
   const path = join4(dir, file);
   return existsSync2(path) ? readFileSync2(path, "utf8") : null;
 }
-function write(dir, file, text3, secret) {
-  writeFileSync2(join4(dir, file), text3, { mode: secret ? 384 : 420 });
+function write(dir, file, text4, secret) {
+  writeFileSync2(join4(dir, file), text4, { mode: secret ? 384 : 420 });
 }
 function readKey(dir, name3, cipher, log) {
   const plain2 = read2(dir, `${name3}.pem`);
@@ -3415,7 +3895,7 @@ function certificates(dataDir, host, cipher, log = console.log) {
     log(`[tls] signed a server certificate for ${names.join(", ")}`);
   }
   const parsedRoot = new X509Certificate2(root.certPem);
-  return { key: server.keyPem, cert: server.certPem, rootDer: parsedRoot.raw, fingerprint: parsedRoot.fingerprint256, names };
+  return { key: server.keyPem, cert: server.certPem, rootDer: parsedRoot.raw, fingerprint: parsedRoot.fingerprint256, fingerprintSha1: parsedRoot.fingerprint, names };
 }
 
 // src/server/service/account/service.ts
@@ -3847,13 +4327,13 @@ var ModelService = class {
   }
   /** 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);
+    const text4 = (value2) => typeof value2 === "string" && value2.trim() && value2.length <= 200 ? value2.trim() : null;
+    const modelId = text4(input.modelId), api = text4(input.api);
     if (!modelId || !api) throw new RuntimeFault("autoconfig_model", "Enter the model ID.", 400);
     let choice;
     if (input.choice !== void 0) {
       const raw = input.choice;
-      const provider = text3(raw?.provider), chosen = text3(raw?.modelId);
+      const provider = text4(raw?.provider), chosen = text4(raw?.modelId);
       if (!provider || !chosen) throw new RuntimeFault("autoconfig_source", "The setup source isn't valid.", 400);
       choice = { provider, modelId: chosen };
     }
@@ -3884,7 +4364,7 @@ var ModelService = class {
 };
 
 // src/server/infra/pi/auth.ts
-import { randomUUID as randomUUID10 } from "node:crypto";
+import { randomUUID as randomUUID11 } from "node:crypto";
 import { ModelRuntime as ModelRuntime2 } from "@earendil-works/pi-coding-agent";
 var CredentialLogins = class {
   constructor(store, credentials, changed) {
@@ -3932,7 +4412,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 = randomUUID10();
+    const id = randomUUID11();
     flow.state.prompt = {
       id,
       type: prompt.type,
@@ -4018,21 +4498,21 @@ var User = class extends Member {
 
 // src/server/application.ts
 import { createHash as createHash7 } from "node:crypto";
-import { mkdir as mkdir6, realpath } from "node:fs/promises";
-import { join as join12, resolve as resolve3 } from "node:path";
+import { mkdir as mkdir7, realpath } from "node:fs/promises";
+import { join as join14, resolve as resolve3 } from "node:path";
 import lockfile from "proper-lockfile";
 
 // src/server/service/chat/mentions.ts
 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 = [];
+  const text4 = source2.replace(/```[\s\S]*?```|`[^`\n]*`/g, (code) => " ".repeat(code.length));
+  const lower = text4.toLowerCase(), sorted = [...candidates2].sort((a, b) => b.name.length - a.name.length), found = [];
   for (let at2 = lower.indexOf("@"); at2 >= 0; at2 = lower.indexOf("@", at2 + 1)) {
-    if (at2 > 0 && WORD.test(text3[at2 - 1])) continue;
+    if (at2 > 0 && WORD.test(text4[at2 - 1])) continue;
     const match = sorted.find((candidate) => {
       const name3 = candidate.name.toLowerCase();
       if (!name3 || !lower.startsWith(name3, at2 + 1)) return false;
-      const next = text3[at2 + 1 + name3.length];
+      const next = text4[at2 + 1 + name3.length];
       return !(next && WORD.test(next) && WORD.test(name3.at(-1)));
     });
     if (match && !found.includes(match)) found.push(match);
@@ -4045,14 +4525,14 @@ function messageTargets({ dm, sender, members, mentioned, replied, subscribers }
   if (dm) return members.filter((member) => member.id !== sender.id).map((member) => ({ member, reason: "dm" }));
   const targets = mentioned.filter((member) => member.id !== sender.id).map((member) => ({ member, reason: "mention" }));
   const add = (member, reason) => {
-    if (member.id !== sender.id && !targets.some((target2) => target2.member.id === member.id)) targets.push({ member, reason });
+    if (member.id !== sender.id && !targets.some((target3) => target3.member.id === member.id)) targets.push({ member, reason });
   };
   if (replied && members.some((member) => member.id === replied.id)) add(replied, "reply");
   for (const member of members) if (subscribers.includes(member.id)) add(member, "subscription");
   return targets;
 }
 function echoTargets({ sender, members, subscribers, reached }) {
-  return members.filter((member) => member.id !== sender.id && subscribers.includes(member.id) && !reached.some((target2) => target2.member.id === member.id)).map((member) => ({ member, reason: "subscription" }));
+  return members.filter((member) => member.id !== sender.id && subscribers.includes(member.id) && !reached.some((target3) => target3.member.id === member.id)).map((member) => ({ member, reason: "subscription" }));
 }
 function reactionTargets({ actorId, author }) {
   return author && author.id !== actorId ? [{ member: author, reason: "author" }] : [];
@@ -4074,7 +4554,10 @@ var POLICY = {
   // 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.
-  change: { agent: "digest", owner: "interrupt" }
+  change: { agent: "digest", owner: "interrupt" },
+  // A task that is due wakes its Bot but never interrupts it, and is not steered into a running turn: it waits for
+  // the turn to end (A58).
+  task: { schedule: "queue" }
 };
 function urgencyOf(kind, reason) {
   return POLICY[kind][reason];
@@ -4085,9 +4568,9 @@ function mutedUrgency(reason, urgency) {
 
 // src/server/service/delivery/delivery.ts
 function plan(kind, targets, muted = []) {
-  return targets.flatMap((target2) => {
-    const urgency = urgencyOf(kind, target2.reason);
-    return urgency ? [{ ...target2, kind, urgency: muted.includes(target2.member.id) ? mutedUrgency(target2.reason, urgency) : urgency }] : [];
+  return targets.flatMap((target3) => {
+    const urgency = urgencyOf(kind, target3.reason);
+    return urgency ? [{ ...target3, kind, urgency: muted.includes(target3.member.id) ? mutedUrgency(target3.reason, urgency) : urgency }] : [];
   });
 }
 var Dispatcher = class {
@@ -4270,7 +4753,8 @@ function questionSpec(input) {
     options: parsed,
     multiple: input.multiple === true,
     allowCustom: input.allowCustom === true,
-    ...input.secret === void 0 ? {} : { secret: secretAsk(input.secret) }
+    ...input.secret === void 0 ? {} : { secret: secretAsk(input.secret) },
+    ...input.machine === void 0 ? {} : { machine: machineAsk(input.machine) }
   };
 }
 function secretAsk(value2) {
@@ -4278,6 +4762,22 @@ function secretAsk(value2) {
   if (!ask || typeof ask !== "object" || typeof ask.name !== "string" || !/^[A-Z][A-Z0-9_]{0,63}$/.test(ask.name) || !text(ask.purpose, 300) || typeof ask.exists !== "boolean" || typeof ask.needsValue !== "boolean") throw new ChatError(400, "Invalid secret request");
   return { name: ask.name, purpose: ask.purpose.trim(), exists: ask.exists, needsValue: ask.needsValue };
 }
+function machineAsk(value2) {
+  const ask = value2, keys = ask?.hostKeys;
+  const strings = (list) => Array.isArray(list) && list.length <= 20 && list.every((item) => text(item, 2e3));
+  if (!ask || typeof ask !== "object" || !text(ask.name, 40) || !text(ask.host, 253) || !text(ask.user, 64) || !Number.isInteger(ask.port) || !text(ask.purpose, 300) || ask.directory !== null && !text(ask.directory, 1e3) || !keys || !strings(keys.keys) || !strings(keys.fingerprints)) throw new ChatError(400, "Invalid machine request");
+  const existing = ask.existing;
+  return {
+    name: ask.name,
+    host: ask.host,
+    port: ask.port,
+    user: ask.user,
+    directory: ask.directory,
+    purpose: ask.purpose.trim(),
+    hostKeys: { keys: keys.keys, fingerprints: keys.fingerprints },
+    existing: existing && typeof existing.id === "string" && typeof existing.name === "string" ? { id: existing.id, name: existing.name } : null
+  };
+}
 function answerOf(question, input) {
   const selected = input.selected ?? [], custom = input.custom === void 0 || input.custom === null || input.custom === "" ? null : input.custom;
   if (!Array.isArray(selected) || new Set(selected).size !== selected.length || !selected.every((index) => Number.isInteger(index) && index >= 0 && index < question.options.length)) throw new ChatError(400, "Invalid selection");
@@ -4619,9 +5119,9 @@ var ChatService = class {
   /** A DM with another member of the actor's space (a Bot DMs its owner or another Bot); one per pair. */
   openDirect(actorId, targetId) {
     const owner = this.repository.channels.ownerOf(actorId), directory = this.repository.channels.directory(owner);
-    const actor = directory.find((member) => member.id === actorId), target2 = directory.find((member) => member.id === targetId);
-    if (!actor || !target2) throw new ChatError(404, "Member not found");
-    const chat = this.repository.openDirect(actorId, targetId, owner, `${actor.name} \xB7 ${target2.name}`);
+    const actor = directory.find((member) => member.id === actorId), target3 = directory.find((member) => member.id === targetId);
+    if (!actor || !target3) throw new ChatError(404, "Member not found");
+    const chat = this.repository.openDirect(actorId, targetId, owner, `${actor.name} \xB7 ${target3.name}`);
     this.notifySaved(chat.id);
     return chat;
   }
@@ -4668,6 +5168,15 @@ var ChatService = class {
     if (added) this.dispatcher.dispatch(deliveries);
     return this.repository.message(actorId, messageId);
   }
+  /** Folds a message to one line in the owner's interface, or unfolds it (A60). Nobody is told: a Bot reads it as before. */
+  fold(actorId, messageId, folded) {
+    if (typeof folded !== "boolean") throw new ChatError(400, "Invalid folded state");
+    const message = this.repository.message(actorId, messageId);
+    if (!message) throw new ChatError(404, "Message not found");
+    this.repository.interactions.setFolded(messageId, folded);
+    this.notifySaved(message.chatId);
+    return this.repository.message(actorId, messageId);
+  }
   mute(actorId, chatId, muted) {
     if (typeof muted !== "boolean") throw new ChatError(400, "Invalid muted");
     this.repository.interactions.setMuted(actorId, chatId, muted);
@@ -4692,10 +5201,11 @@ var ChatService = class {
   unreadMessages(actorId, chatId, limit) {
     return this.repository.unreadMessages(actorId, chatId, limit);
   }
-  searchAll(actorId, query, limit = 30, within) {
+  /** `sender`: only that member's messages (a Bot looking for what it sent itself). */
+  searchAll(actorId, query, limit = 30, within, sender) {
     if (!query.trim() || query.length > 500 || !Number.isInteger(limit) || limit < 1 || limit > 100) throw new ChatError(400, "Invalid search query or limit");
     if (within) this.repository.assertAccess(actorId, within);
-    return this.repository.searchAll(actorId, query.trim(), limit, within);
+    return this.repository.searchAll(actorId, query.trim(), limit, within, sender);
   }
   /** The search box: channels and threads by title, topic or notice / summary, and messages by text, with the chat
    * each message is in. `within` searches one chat (a channel with its threads) and returns no chats. */
@@ -4766,9 +5276,9 @@ var ChatService = class {
   message(actorId, id) {
     return this.repository.message(actorId, id);
   }
-  search(actorId, chatId, query, limit = 30) {
+  search(actorId, chatId, query, limit = 30, sender) {
     if (!query.trim() || query.length > 500 || !Number.isInteger(limit) || limit < 1 || limit > 100) throw new ChatError(400, "Invalid search query or limit");
-    return this.repository.search(actorId, chatId, query, limit);
+    return this.repository.search(actorId, chatId, query, limit, sender);
   }
   notifySaved(chatId) {
     try {
@@ -4889,8 +5399,8 @@ function activityPage(messages, history, limit) {
 }
 
 // src/server/service/bot/service.ts
-import { dirname as dirname8, join as join11 } from "node:path";
-import { rm as rm3 } from "node:fs/promises";
+import { dirname as dirname9, join as join13 } from "node:path";
+import { rm as rm4 } from "node:fs/promises";
 
 // src/server/infra/pi/history.ts
 var value = (input) => JSON.parse(JSON.stringify(input));
@@ -4954,9 +5464,9 @@ var PiHistoryAdapter = class {
       if (m.role === "system") {
         if (m.sections) {
           const sections = {};
-          for (const [name3, text3] of Object.entries(m.sections)) {
-            sections[name3] = text3 === null ? null : message.content.length;
-            if (text3 !== null) message.content.push({ type: "text", text: text3 });
+          for (const [name3, text4] of Object.entries(m.sections)) {
+            sections[name3] = text4 === null ? null : message.content.length;
+            if (text4 !== null) message.content.push({ type: "text", text: text4 });
           }
           pi.sections = sections;
         }
@@ -5029,6 +5539,99 @@ function reportedContext(branch) {
   return { tokens: null, stale: false };
 }
 
+// src/server/shared/prompt.ts
+var joinPrompt = (parts) => parts.map((part) => part.text).join("");
+
+// src/server/infra/pi/prompt-change.ts
+var CHANGE_LINES = 40;
+var CONTEXT_LINES = 2;
+var TEXT_LIMIT = 8e3;
+var DIFF_LIMIT = 1500;
+function lineDiff(before, after2) {
+  const rows2 = before.length, columns = after2.length;
+  const lcs = Array.from({ length: rows2 + 1 }, () => new Uint32Array(columns + 1));
+  for (let i2 = rows2 - 1; i2 >= 0; i2--) for (let j2 = columns - 1; j2 >= 0; j2--)
+    lcs[i2][j2] = before[i2] === after2[j2] ? lcs[i2 + 1][j2 + 1] + 1 : Math.max(lcs[i2 + 1][j2], lcs[i2][j2 + 1]);
+  const out = [];
+  let i = 0, j = 0;
+  while (i < rows2 && j < columns) {
+    if (before[i] === after2[j]) {
+      out.push({ kind: " ", text: after2[j] });
+      i++;
+      j++;
+    } else if (lcs[i + 1][j] >= lcs[i][j + 1]) out.push({ kind: "-", text: before[i++] });
+    else out.push({ kind: "+", text: after2[j++] });
+  }
+  while (i < rows2) out.push({ kind: "-", text: before[i++] });
+  while (j < columns) out.push({ kind: "+", text: after2[j++] });
+  return out;
+}
+function hunks(lines) {
+  const keep = /* @__PURE__ */ new Set();
+  lines.forEach((line, index) => {
+    if (line.kind === " ") return;
+    for (let at2 = Math.max(0, index - CONTEXT_LINES); at2 <= Math.min(lines.length - 1, index + CONTEXT_LINES); at2++) keep.add(at2);
+  });
+  const out = [];
+  let last = -1;
+  for (const index of [...keep].sort((a, b) => a - b)) {
+    if (last >= 0 && index > last + 1) out.push("\u2026");
+    const line = lines[index];
+    out.push(`${line.kind}${line.text}`);
+    last = index;
+  }
+  return out;
+}
+function promptChange(before, after2) {
+  if (joinPrompt(before) === joinPrompt(after2)) return null;
+  const next = after2;
+  const old = new Map(before.map((part) => [part.name, part.text]));
+  const changed = after2.filter((part) => (old.get(part.name) ?? "") !== part.text);
+  const gone = before.filter((part) => !after2.some((next2) => next2.name === part.name));
+  const parts = [...changed.map((part) => part.name), ...gone.map((part) => part.name)];
+  const lines = [];
+  let tooLong = false;
+  for (const name3 of parts) {
+    const from = (old.get(name3) ?? "").split("\n"), to = (after2.find((part) => part.name === name3)?.text ?? "").split("\n");
+    if (from.length > DIFF_LIMIT || to.length > DIFF_LIMIT) {
+      tooLong = true;
+      break;
+    }
+    lines.push(`@@ ${name3}`, ...hunks(lineDiff(from, to)));
+    if (lines.length > CHANGE_LINES) {
+      tooLong = true;
+      break;
+    }
+  }
+  const cut = (text4) => text4.length > TEXT_LIMIT ? `${text4.slice(0, TEXT_LIMIT)}\u2026` : text4;
+  if (!tooLong) return { parts, diff: cut(lines.join("\n")), whole: false, next };
+  return { parts, diff: cut(changed.map((part) => `@@ ${part.name}
+${part.text.trim()}`).join("\n\n")), whole: true, next };
+}
+var PromptLog = class {
+  adopted;
+  told;
+  constructor(now) {
+    this.adopted = this.told = now();
+  }
+  /** The prompt every request goes out with, until a change is taken up. */
+  get current() {
+    return joinPrompt(this.adopted);
+  }
+  /** What to tell the model with the next batch: how the live prompt differs from the newest one it knows. */
+  pending(now) {
+    return promptChange(this.told, now());
+  }
+  /** The model was told: the next change is measured from here. */
+  sent(change) {
+    this.told = change.next;
+  }
+  /** A new model or a compaction: the live prompt goes out from now on, with nothing left to tell. */
+  take(now) {
+    this.adopted = this.told = now();
+  }
+};
+
 // src/server/infra/pi/http.ts
 import { EventEmitter } from "node:events";
 import * as undici from "undici";
@@ -5128,7 +5731,7 @@ import { StringDecoder } from "node:string_decoder";
 var placeholder = (name3) => `{{secret:${name3}}}`;
 var MIN_MASKED = 4;
 var MIN_FRAGMENT = 8;
-var xml = (text3) => text3.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+var xml = (text4) => text4.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
 function base64Fragments(value2) {
   const bytes = Buffer.from(value2, "utf8"), found = [];
   for (const offset of [0, 1, 2]) {
@@ -5157,8 +5760,8 @@ var Masker = class {
   get empty() {
     return this.pairs.length === 0;
   }
-  mask(text3) {
-    let result = text3;
+  mask(text4) {
+    let result = text4;
     for (const { form, name: name3 } of this.pairs) if (result.includes(form)) result = result.split(form).join(placeholder(name3));
     return result;
   }
@@ -5240,9 +5843,9 @@ 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;
+function ascii(bytes, offset, text4) {
+  if (bytes.length < offset + text4.length) return false;
+  for (let index = 0; index < text4.length; index++) if (bytes[offset + index] !== text4.charCodeAt(index)) return false;
   return true;
 }
 
@@ -5364,7 +5967,7 @@ function environmentTools(lookup, secrets) {
   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), writeFile5 = (path, content2) => current().writeFile(path, content2);
+  const readFile4 = (path) => current().readFile(path), writeFile5 = (path, content2) => current().writeFile(path, content2);
   const cwd = current().cwd;
   const definitions2 = [
     relocated(createBashToolDefinition(cwd, { operations: {
@@ -5387,9 +5990,9 @@ function environmentTools(lookup, secrets) {
       }
     } }), 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)) } }),
+    createReadToolDefinition(cwd, { operations: { readFile: readFile4, access, detectImageMimeType: async (path) => imageKind(await current().head(path, IMAGE_SNIFF_BYTES)) } }),
     createWriteToolDefinition(cwd, { operations: { writeFile: writeFile5, mkdir: (path) => current().mkdir(path) } }),
-    createEditToolDefinition(cwd, { operations: { readFile: readFile3, writeFile: writeFile5, access } })
+    createEditToolDefinition(cwd, { operations: { readFile: readFile4, writeFile: writeFile5, access } })
   ];
   return definitions2.map((definition) => inside(definition, lookup, pinned));
 }
@@ -5397,7 +6000,7 @@ 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) });
+    if (ctx && typeof ctx === "object") args[4] = new Proxy(ctx, { get: (target3, key) => key === "cwd" ? env.cwd : Reflect.get(target3, key, target3) });
     return pinned.run({ env, toolCallId: typeof args[0] === "string" ? args[0] : null }, () => execute(...args));
   }) };
 }
@@ -5417,12 +6020,12 @@ function relocated(definition, current) {
     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);
+      const target3 = await moveOut(path, env), swap = (text4) => text4?.replaceAll(path, target3);
       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 } } : {}
+        details: { ...result.details, fullOutputPath: target3 },
+        ...result.structuredContent?.full_output_path ? { structuredContent: { ...result.structuredContent, full_output_path: target3 } } : {}
       };
     } catch (error) {
       const path = error instanceof Error ? /Full output: (\S+?)\]/.exec(error.message)?.[1] : void 0;
@@ -5432,10 +6035,10 @@ function relocated(definition, current) {
   }) };
 }
 async function moveOut(path, env) {
-  const target2 = `${env.cwd}/temp/${basename(path)}`;
-  await env.writeFile(target2, await readLocal(path));
+  const target3 = `${env.temp ?? `${env.cwd}/temp`}/${basename(path)}`;
+  await env.writeFile(target3, await readLocal(path));
   await rm(path, { force: true });
-  return target2;
+  return target3;
 }
 function defined(vars) {
   return Object.fromEntries(Object.entries(vars).filter((entry) => entry[1] !== void 0));
@@ -5466,6 +6069,7 @@ var PiSession = class _PiSession {
   result = { outcome: "completed" };
   signature = "";
   translator = new LiveTranslator();
+  prompts;
   get context() {
     const usage = this.session.getContextUsage();
     if (!usage) return void 0;
@@ -5489,7 +6093,7 @@ var PiSession = class _PiSession {
     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 = existsSync3(reference.file);
-    if (!exists && (reference.persisted || store.runtime.runs(bot.id).some((run) => run.state === "unknown")))
+    if (!exists && (reference.persisted || store.runtime.runs(bot.id).some((run2) => run2.state === "unknown")))
       throw new RuntimeFault("session_missing", "The session file is missing; check the run records before recovering.");
     if (exists) {
       let header;
@@ -5512,6 +6116,7 @@ var PiSession = class _PiSession {
     const model = installModel(models, connection, configured2, store.modelHeaders(connection.id, configured2.id));
     const sessionManager = SessionManager.open(reference.file, sessionsDir, bot.workspacePath);
     const adapter = new _PiSession(options, models, credentials);
+    adapter.prompts = new PromptLog(options.systemPrompt);
     configureHttp(HTTP_IDLE_TIMEOUT_MS);
     const settingsManager = SettingsManager.inMemory({
       httpIdleTimeoutMs: HTTP_IDLE_TIMEOUT_MS,
@@ -5526,7 +6131,7 @@ var PiSession = class _PiSession {
       noSkills: true,
       noPromptTemplates: true,
       noContextFiles: true,
-      systemPromptOverride: options.systemPrompt,
+      systemPromptOverride: () => adapter.prompts.current,
       appendSystemPromptOverride: () => [],
       extensionFactories: [createCodemodeExtension(), (api) => {
         for (const tool of options.tools) api.registerTool({
@@ -5544,17 +6149,17 @@ var PiSession = class _PiSession {
             return { content: [{ type: "text", text: typeof output === "string" ? output : JSON.stringify(output) }], details: {} };
           }
         });
-        api.on("before_agent_start", () => ({ systemPrompt: options.systemPrompt() }));
+        api.on("before_agent_start", () => ({ systemPrompt: adapter.prompts.current }));
         api.on("tool_result", (event) => {
           const masker = options.secrets?.masker();
           if (!masker || masker.empty) return void 0;
           let changed = false;
           const content2 = event.content.map((part) => {
             if (part.type !== "text") return part;
-            const text3 = masker.mask(part.text);
-            if (text3 === part.text) return part;
+            const text4 = masker.mask(part.text);
+            if (text4 === part.text) return part;
             changed = true;
-            return { ...part, text: text3 };
+            return { ...part, text: text4 };
           });
           if (!changed) return void 0;
           return { content: content2, ...event.structuredContent !== void 0 ? { structuredContent: masker.maskDeep(event.structuredContent) } : {} };
@@ -5624,6 +6229,7 @@ var PiSession = class _PiSession {
       this.options.activity("compacting");
       console.log("[pi] compaction started", { botId: this.options.bot.id, reason: event.reason });
     }
+    if (event.type === "compaction_end" && event.result && !event.aborted && !event.errorMessage) this.prompts.take(this.options.systemPrompt);
     if (event.type === "compaction_end") console.log(
       event.errorMessage ? "[pi] compaction failed" : "[pi] compaction finished",
       {
@@ -5718,12 +6324,19 @@ var PiSession = class _PiSession {
       this.settings.applyOverrides({ compaction: { reserveTokens: compactionReserve(model.contextWindow) } });
       this.session.setThinkingLevel(resolveThinking(model, selection.thinkingLevel), { persist: false });
       this.signature = signature;
+      this.prompts.take(this.options.systemPrompt);
       return this.session.thinkingLevel;
     } catch {
       this.credentials.current = previous;
       throw new RuntimeFault("model_switch_uncertain", "The model switch didn't finish. Pick the model again.", 409);
     }
   }
+  promptChange() {
+    return this.prompts.pending(this.options.systemPrompt);
+  }
+  promptTold(change) {
+    this.prompts.sent(change);
+  }
   async dispose() {
     this.requestAbort();
     await this.abortTask;
@@ -5771,12 +6384,13 @@ function overDurable(id, kind, env, options) {
     id,
     kind,
     cwd: env.cwd,
+    ...options.temp ? { temp: options.temp } : {},
     async exec(command, exec) {
       const result = await env.exec(command, {
         cwd: exec.cwd,
         ...options.passEnv && exec.env ? { env: { ...exec.env, ...exec.secrets }, inheritEnv: false } : { ...exec.secrets ? { env: exec.secrets } : {}, inheritEnv: true },
         ...exec.timeout ? { timeout: exec.timeout } : {},
-        onOutput: (text3) => exec.onData(Buffer.from(text3))
+        onOutput: (text4) => exec.onData(Buffer.from(text4))
       }, context(exec.signal));
       if (result.ok) return { exitCode: result.value.exitCode };
       if (result.error.code === "aborted") throw new Error("aborted");
@@ -5950,16 +6564,16 @@ async function removeContainer(name3) {
 async function syncDaemon(dir) {
   const arch = process.arch === "arm64" ? "arm64" : "x64";
   const wanted = await readFile2(packagedDaemon({ platform: "linux", arch }));
-  const target2 = join6(dir, "pi-env");
-  const current = await readFile2(target2).catch(() => null);
+  const target3 = join6(dir, "pi-env");
+  const current = await readFile2(target3).catch(() => null);
   if (current?.equals(wanted)) return;
   await mkdir3(dir, { recursive: true, mode: 448 });
-  const temp = `${target2}.${process.pid}.tmp`;
+  const temp = `${target3}.${process.pid}.tmp`;
   await writeFile2(temp, wanted, { mode: 493 });
-  await rename2(temp, target2);
+  await rename2(temp, target3);
 }
 function containerEnvironment(id, container, log) {
-  const connection = new Connection({ command: ["docker", "exec", "-i", container, `${DAEMON_DIR}/pi-env`], onLog: (text3) => log(text3.trim()) });
+  const connection = new Connection({ command: ["docker", "exec", "-i", container, `${DAEMON_DIR}/pi-env`], onLog: (text4) => log(text4.trim()) });
   return overDurable(id, "computer", new RemoteExecutionEnv({ connection, id, cwd: COMPUTER_CWD }), { passEnv: false, close: () => connection.close() });
 }
 
@@ -5972,32 +6586,35 @@ function hostEnvironment(cwd) {
 // 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."
+  host: "The machine where this chat platform's server runs. 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) {
+  constructor(store, computers, machines) {
     this.store = store;
     this.computers = computers;
+    this.machines = machines;
   }
   open = /* @__PURE__ */ new Map();
   current(botId, workspacePath) {
-    const target2 = this.store.environments.placement(botId).current;
+    const target3 = this.store.environments.placement(botId).current, signature = this.signature(target3);
     const open = this.open.get(botId);
-    if (open?.id === target2.id) return open.view;
+    if (open?.id === signature) 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));
+    const opened = this.track(signature, target3.kind === "computer" ? this.computers.environment(target3.botId ?? botId, target3) : target3.kind === "ssh" ? this.machines.environment(target3, botId) : 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;
+    const hostId = environments.host().id, granted = new Set(environments.grants(botId).map((grant) => grant.id));
     return {
-      home: home.kind,
+      home: home.kind === "computer" ? "computer" : "host",
       current: current.kind,
+      ...current.kind === "ssh" ? { currentName: current.name } : {},
       computer: this.computers.status(botId),
       docker: this.computers.available,
-      hostGranted: environments.grants(botId).some((grant) => grant.id === hostId)
+      hostGranted: granted.has(hostId),
+      machines: environments.sshMachines().map((machine) => ({ id: machine.id, name: machine.name, granted: granted.has(machine.id) }))
     };
   }
   /** The environments the Bot may be in: its sandbox, its default, and the ones its owner granted it. */
@@ -6008,11 +6625,12 @@ var BotEnvironments = class {
   }
   place(botId, record3, workspacePath) {
     if (record3.kind === "host") return { id: record3.id, kind: "host", name: "your owner's computer", directory: workspacePath };
+    if (record3.kind === "ssh") return { id: record3.id, kind: "ssh", name: record3.name, directory: record3.directory ?? record3.spec.home ?? "/" };
     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 name3 = (record3) => record3.kind === "host" ? "owner's computer" : record3.botId === botId ? "own sandbox" : "another Bot's sandbox";
+    const name3 = (record3) => record3.kind === "host" ? "owner's computer" : record3.kind === "ssh" ? record3.name : record3.botId === botId ? "own sandbox" : "another Bot's sandbox";
     const { home, current } = this.store.environments.placement(botId);
     return { default: name3(home), current: name3(current), usable: this.usable(botId).map(name3) };
   }
@@ -6030,18 +6648,37 @@ var BotEnvironments = class {
     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" } : {}
+      ...record3.kind === "computer" ? { state: this.computers.status(record3.botId ?? botId)?.state ?? "stopped" } : {},
+      ...record3.kind === "ssh" ? { address: this.machines.address(record3) } : {}
     })) };
   }
-  /** 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. */
+  /** environments.switch: the Bot moves itself, like cd, until it switches back. A sandbox is started first, an SSH
+   * machine connected first; if that fails, 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." } : {} };
+    const target3 = this.usable(botId).find((record3) => record3.id === environmentId);
+    if (!target3) throw new ChatError(404, "No work environment with this id that you may use; see environments.list");
+    const previous = this.store.environments.placement(botId).current, already = previous.id === target3.id;
+    if (target3.kind === "computer") await this.computers.ensure(target3.botId ?? botId);
+    this.store.environments.setCurrent(botId, target3.id);
+    if (target3.kind === "ssh" && !already) {
+      const place = this.place(botId, target3, workspacePath);
+      try {
+        if (!await this.current(botId, workspacePath).exists(place.directory)) throw new Error(`${place.directory} doesn't exist there; ask your owner to change the machine's directory, or switch back`);
+      } catch (error) {
+        const opened = this.open.get(botId);
+        if (opened) {
+          this.open.delete(botId);
+          this.retire(opened);
+        }
+        this.store.environments.setCurrent(botId, previous.id);
+        throw new ChatError(409, `Couldn't connect to ${target3.name}, so you stay where you were: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    return {
+      ...this.place(botId, target3, workspacePath),
+      about: target3.kind === "ssh" ? this.machines.about(target3, botId) : ABOUT[target3.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) {
@@ -6058,15 +6695,18 @@ var BotEnvironments = class {
     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 };
+  /** The owner grants or takes back their computer (A50) or an SSH machine (A57); taking it back while the Bot works
+   * there sends it home. */
+  grant(botId, environmentId, granted, by, workspacePath) {
+    const environments = this.store.environments, target3 = environmentId === "host" ? environments.host() : environments.get(environmentId);
+    if (!target3 || target3.kind === "computer") throw new ChatError(404, "No such environment");
+    const name3 = this.place(botId, target3, workspacePath).name;
+    if (granted) return { changed: environments.grant(target3.id, botId, by), moved: null, name: name3 };
+    const changed = environments.revoke(target3.id, botId), { home, current } = environments.placement(botId);
+    if (current.id !== target3.id || home.id === target3.id) return { changed, moved: null, name: name3 };
     const from = this.here(botId, workspacePath);
     environments.setCurrent(botId, home.id);
-    return { changed, moved: { from, to: this.here(botId, workspacePath) } };
+    return { changed, moved: { from, to: this.here(botId, workspacePath) }, name: name3 };
   }
   async release(botId) {
     const open = this.open.get(botId);
@@ -6080,6 +6720,10 @@ var BotEnvironments = class {
     await Promise.all(all.map((open) => open.env.close()));
     await this.computers.close();
   }
+  /** What an open environment is for: changing a machine's directory reopens it where the owner put it. */
+  signature(record3) {
+    return record3.kind === "ssh" ? `${record3.id}@${record3.directory ?? ""}` : record3.id;
+  }
   retire(open) {
     open.retired = true;
     if (!open.busy) void open.env.close();
@@ -6087,7 +6731,7 @@ var BotEnvironments = class {
   /** 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) => {
+    const run2 = async (work) => {
       opened.busy++;
       try {
         return await work();
@@ -6099,13 +6743,14 @@ var BotEnvironments = class {
       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)),
+      ...env.temp ? { temp: env.temp } : {},
+      exec: (command, options) => run2(() => env.exec(command, options)),
+      readFile: (path) => run2(() => env.readFile(path)),
+      head: (path, bytes) => run2(() => env.head(path, bytes)),
+      writeFile: (path, content2) => run2(() => env.writeFile(path, content2)),
+      mkdir: (path) => run2(() => env.mkdir(path)),
+      exists: (path) => run2(() => env.exists(path)),
+      fileSize: (path) => run2(() => env.fileSize(path)),
       close: () => env.close()
     };
     return opened;
@@ -6174,7 +6819,7 @@ var Computers = class {
   }
   /** 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) => {
+    const run2 = async (op) => {
       try {
         return await op(await this.connect(botId, record3));
       } catch (error) {
@@ -6188,13 +6833,13 @@ var Computers = class {
       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)),
+      exec: (command, options) => run2((env) => env.exec(command, options)),
+      readFile: (path) => run2((env) => env.readFile(path)),
+      head: (path, bytes) => run2((env) => env.head(path, bytes)),
+      writeFile: (path, content2) => run2((env) => env.writeFile(path, content2)),
+      mkdir: (path) => run2((env) => env.mkdir(path)),
+      exists: (path) => run2((env) => env.exists(path)),
+      fileSize: (path) => run2((env) => env.fileSize(path)),
       close: () => this.disconnect(botId)
     };
   }
@@ -6208,7 +6853,7 @@ var Computers = class {
     await home;
     let env = this.connections.get(botId);
     if (!env) {
-      env = containerEnvironment(record3.id, container, (text3) => this.log(`[${botId.slice(0, 8)}] ${text3}`));
+      env = containerEnvironment(record3.id, container, (text4) => this.log(`[${botId.slice(0, 8)}] ${text4}`));
       this.connections.set(botId, env);
     }
     return env;
@@ -6336,15 +6981,502 @@ var Computers = class {
       this.set(botId, { state: "running" });
     }
   }
-  log(text3) {
-    (this.deps.log ?? console.log)(`[computers] ${text3}`);
+  log(text4) {
+    (this.deps.log ?? console.log)(`[computers] ${text4}`);
   }
 };
 
+// src/server/service/bot/machines.ts
+import { randomUUID as randomUUID12 } from "node:crypto";
+import { dirname as dirname5, join as join9, posix } from "node:path";
+
+// src/server/infra/env/ssh.ts
+import { spawn as spawn2 } from "node:child_process";
+import { mkdirSync as mkdirSync4, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { mkdir as mkdir4, mkdtemp as mkdtemp2, readFile as readFile3, rm as rm3 } from "node:fs/promises";
+import { join as join8 } from "node:path";
+import { HostKeyChangedError, HostKeyUnknownError, RemoteExecutionEnv as RemoteExecutionEnv2, detectPlatform, scanHostKey, sshArguments, sshConnection } from "@earendil-works/pi-env";
+var SshFault = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+var SCAN_ALIAS = "jarvy-scan";
+var TIMEOUT_MS2 = 3e4;
+async function scanHost(address2, runtime) {
+  await mkdir4(runtime, { recursive: true, mode: 448 });
+  try {
+    const scanned = await scanHostKey({ ...target(address2, SCAN_ALIAS), knownHostsFile: join8(runtime, "none") });
+    return {
+      keys: scanned.lines.map((line) => line.trim().split(/\s+/).slice(1, 3).join(" ")),
+      fingerprints: scanned.fingerprints.map((line) => line.replace(` ${SCAN_ALIAS} `, " ").replace(/^\d+\s+/, ""))
+    };
+  } catch (error) {
+    throw classify(error, address2);
+  }
+}
+async function generateKey(runtime, comment) {
+  await mkdir4(runtime, { recursive: true, mode: 448 });
+  const directory = await mkdtemp2(join8(runtime, "keygen-"));
+  try {
+    await run("ssh-keygen", ["-q", "-t", "ed25519", "-N", "", "-C", comment, "-f", join8(directory, "key")]);
+    return { privateKey: await readFile3(join8(directory, "key"), "utf8"), publicKey: (await readFile3(join8(directory, "key.pub"), "utf8")).trim() };
+  } finally {
+    await rm3(directory, { recursive: true, force: true });
+  }
+}
+function publicKeyOf(privateKey, comment) {
+  try {
+    const body = Buffer.from(privateKey.replace(/-----[^-]+-----/g, "").replace(/\s+/g, ""), "base64"), magic = "openssh-key-v1\0";
+    if (body.subarray(0, magic.length).toString("latin1") !== magic) return null;
+    let at2 = magic.length;
+    const field2 = () => {
+      const size = body.readUInt32BE(at2);
+      const value2 = body.subarray(at2 + 4, at2 + 4 + size);
+      at2 += 4 + size;
+      return value2;
+    };
+    field2();
+    field2();
+    field2();
+    if (body.readUInt32BE(at2) !== 1) return null;
+    at2 += 4;
+    const blob = field2(), type = blob.subarray(4, 4 + blob.readUInt32BE(0)).toString("latin1");
+    return `${type} ${blob.toString("base64")} ${comment}`;
+  } catch {
+    return null;
+  }
+}
+async function installKey(address2, runtime, hostKeys2, password, publicKey) {
+  const access = { ...address2, runtime, alias: SCAN_ALIAS, hostKeys: hostKeys2, privateKey: "", password };
+  await withFiles(access, async (files) => {
+    const script = [
+      "umask 077",
+      'mkdir -p "$HOME/.ssh"',
+      'f="$HOME/.ssh/authorized_keys"',
+      'touch "$f"',
+      "IFS= read -r key",
+      `grep -qxF "$key" "$f" || printf '%s\\n' "$key" >> "$f"`
+    ].join("\n");
+    await runSsh(access, files, `sh -c ${quote(script)}`, `${publicKey}
+`, "password");
+  });
+}
+async function probeHost(access) {
+  return withFiles(access, async (files) => {
+    try {
+      const remote = await detectPlatform({ ...target(access, access.alias), ...files });
+      if (remote.platform !== "linux" && remote.platform !== "darwin") throw new SshFault("ssh_unsupported", `Unsupported system: ${remote.platform}`);
+      return { platform: remote.platform, home: remote.home };
+    } catch (error) {
+      throw classify(error, access, access.password ? "password" : "key");
+    }
+  });
+}
+async function removeKey(access, comment) {
+  await withFiles(access, async (files) => {
+    const script = [
+      "umask 077",
+      'f="$HOME/.ssh/authorized_keys"',
+      '[ -f "$f" ] || exit 0',
+      `awk ${quote(`$NF != "${comment}"`)} "$f" > "$f.jarvy" && cat "$f.jarvy" > "$f"`,
+      "s=$?",
+      'rm -f "$f.jarvy"',
+      "exit $s"
+    ].join("\n");
+    await runSsh(access, files, `sh -c ${quote(script)}`, "", access.password ? "password" : "key");
+  });
+}
+function sshEnvironment(id, access, directory, temp, onLog) {
+  mkdirSync4(access.runtime, { recursive: true, mode: 448 });
+  const folder = join8(access.runtime, `open-${id}-${process.pid}-${Date.now().toString(36)}`);
+  const files = writeFilesSync(folder, access);
+  const { connection } = sshConnection({ ...target(access, access.alias), ...files, ...onLog ? { onLog } : {} });
+  return overDurable(id, "ssh", new RemoteExecutionEnv2({ connection, id: `ssh:${id}`, cwd: directory }), {
+    passEnv: false,
+    temp,
+    close: () => {
+      connection.close();
+      rmSync2(folder, { recursive: true, force: true });
+    }
+  });
+}
+function clearRuntime(runtime) {
+  rmSync2(runtime, { recursive: true, force: true });
+}
+function target(address2, alias2) {
+  return { host: address2.host, port: address2.port, user: address2.user, hostKeyAlias: alias2, configFile: "/dev/null" };
+}
+async function withFiles(access, work) {
+  await mkdir4(access.runtime, { recursive: true, mode: 448 });
+  const directory = await mkdtemp2(join8(access.runtime, "use-"));
+  try {
+    return await work(writeFilesSync(directory, access));
+  } finally {
+    await rm3(directory, { recursive: true, force: true });
+  }
+}
+function writeFilesSync(directory, access) {
+  mkdirSync4(directory, { recursive: true, mode: 448 });
+  const knownHostsFile = join8(directory, "known_hosts");
+  writeFileSync3(knownHostsFile, access.hostKeys.map((key) => `${access.alias} ${key}
+`).join(""), { mode: 384 });
+  if (access.password) {
+    const secret = join8(directory, "password"), askpass = join8(directory, "askpass"), ssh = join8(directory, "ssh");
+    writeFileSync3(secret, `${access.password}
+`, { mode: 384 });
+    writeFileSync3(askpass, `#!/bin/sh
+exec cat ${quote(secret)}
+`, { mode: 448 });
+    writeFileSync3(ssh, ["#!/bin/sh", `exec env -u SSH_AUTH_SOCK SSH_ASKPASS=${quote(askpass)} SSH_ASKPASS_REQUIRE=force DISPLAY=none ssh -o BatchMode=no -o PreferredAuthentications=keyboard-interactive,password -o PubkeyAuthentication=no -o NumberOfPasswordPrompts=1 -o ConnectTimeout=15 "$@"`, ""].join("\n"), { mode: 448 });
+    return { knownHostsFile, ssh };
+  }
+  const identityFile = join8(directory, "key");
+  writeFileSync3(identityFile, access.privateKey.endsWith("\n") ? access.privateKey : `${access.privateKey}
+`, { mode: 384 });
+  return { knownHostsFile, identityFile };
+}
+function runSsh(access, files, command, stdin, how) {
+  const { ssh, ...rest } = files;
+  return run(ssh ?? "ssh", [...sshArguments({ ...target(access, access.alias), ...rest }), command], stdin).catch((error) => {
+    throw classify(error, access, how);
+  });
+}
+function run(program, args, stdin = "", env) {
+  return new Promise((resolve5, reject) => {
+    const child = spawn2(program, args, { stdio: ["pipe", "pipe", "pipe"], ...env ? { env } : {}, detached: true });
+    const out = [], err = [];
+    const timer = setTimeout(() => child.kill(), TIMEOUT_MS2);
+    child.stdout.on("data", (chunk) => out.push(chunk));
+    child.stderr.on("data", (chunk) => err.push(chunk));
+    child.stdin.on("error", () => {
+    });
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0) resolve5(Buffer.concat(out).toString("utf8"));
+      else reject(new Error(Buffer.concat(err).toString("utf8").trim() || `${program} exited with ${code ?? "a signal"}`));
+    });
+    child.stdin.end(stdin);
+  });
+}
+function classify(error, address2, how = "key") {
+  if (error instanceof SshFault) return error;
+  const text4 = error instanceof Error ? error.message : String(error), where2 = `${address2.user}@${address2.host}:${address2.port}`;
+  if (error instanceof HostKeyChangedError || /REMOTE HOST IDENTIFICATION HAS CHANGED|Host key verification failed/.test(text4))
+    return new SshFault("ssh_host_key_changed", `The host key of ${where2} is not the one accepted`);
+  if (error instanceof HostKeyUnknownError) return new SshFault("ssh_host_key_changed", `The host key of ${where2} is not the one accepted`);
+  const denied = /Permission denied \(([^)]*)\)/.exec(text4);
+  if (denied || /Permission denied|Too many authentication failures/.test(text4)) {
+    const methods = denied ? denied[1].split(",").map((method) => method.trim()) : [];
+    if (how === "password" && methods.length && !methods.some((method) => method === "password" || method === "keyboard-interactive"))
+      return new SshFault("ssh_password_refused", `${where2} doesn't accept password logins`);
+    if (how === "key") return new SshFault("ssh_key_refused", `${where2} didn't accept Jarvy's key`);
+    return new SshFault("ssh_auth_failed", `${where2} refused the password`);
+  }
+  if (/Connection refused|timed out|No route to host|Could not resolve|Network is unreachable|Connection closed|No host key received/i.test(text4))
+    return new SshFault("ssh_unreachable", `${where2} can't be reached: ${text4.split("\n").pop()}`);
+  return new SshFault("ssh_failed", text4.split("\n").slice(-3).join(" ").slice(0, 300) || `ssh ${where2} failed`);
+}
+var quote = (text4) => `'${text4.replaceAll("'", "'\\''")}'`;
+
+// src/server/service/bot/machines.ts
+var HOST = /^(?!-)[A-Za-z0-9._:-]{1,253}$/;
+var USER = /^(?!-)[A-Za-z0-9._][A-Za-z0-9._-]{0,63}$/;
+var PREPARED_MS = 60 * 6e4;
+var SshMachines = class {
+  /** `changed`: what Bots may use changed, so the owner's page reloads them. */
+  constructor(store, chats, changed = () => {
+  }) {
+    this.store = store;
+    this.chats = chats;
+    this.changed = changed;
+    this.runtime = join9(dirname5(store.path), "ssh");
+    clearRuntime(this.runtime);
+  }
+  runtime;
+  prepared = /* @__PURE__ */ new Map();
+  list() {
+    return this.store.environments.sshMachines().map((record3) => this.view(record3));
+  }
+  get(id) {
+    return this.view(this.need(id));
+  }
+  /** The host keys a machine presents, to show the owner before the password is typed. */
+  async scan(input) {
+    return this.wrap(() => scanHost(address(input), this.runtime));
+  }
+  /** A key for a machine the owner will add its public half to themselves; `keyId` then adds the machine. */
+  async prepareKey() {
+    const now = Date.now();
+    for (const [keyId2, key2] of this.prepared) if (key2.until < now) this.prepared.delete(keyId2);
+    const id = randomUUID12(), key = await this.wrap(() => generateKey(this.runtime, keyComment(id)));
+    this.prepared.set(id, { id, ...key, until: now + PREPARED_MS });
+    return { keyId: id, publicKey: key.publicKey };
+  }
+  /** Adds a machine and saves it once a login works; nothing is saved when a step fails. With `password`, Jarvy makes
+   * a key and installs it with that password; when the machine then refuses the key, the password itself is kept
+   * (sealed) and used to log in (A59), and the key stays installed for when keys are allowed. With `keyId`, the owner
+   * has added that prepared key to the machine, and a login with it is checked. */
+  async add(input, grantTo) {
+    const where2 = address(input), name3 = this.freeName(text3(input.name, 40) || `${where2.user}@${where2.host}`);
+    const password = typeof input.password === "string" && input.password ? input.password : null;
+    const prepared = typeof input.keyId === "string" ? this.prepared.get(input.keyId) : void 0;
+    if (!password && input.keyId === void 0) throw new ChatError(400, "A password is needed to install the key", "ssh_password_missing");
+    if (!password && (!prepared || prepared.until < Date.now())) throw new ChatError(409, "That key is no longer kept; show a new one and add it to the machine", "ssh_key_expired");
+    if (!input.hostKeys.keys.length) throw new ChatError(400, "The host keys are missing; scan the machine first");
+    directoryIn("/", input.directory);
+    const id = prepared && !password ? prepared.id : randomUUID12(), comment = keyComment(id);
+    const record3 = await this.wrap(async () => {
+      const key = prepared && !password ? prepared : await generateKey(this.runtime, comment);
+      const access = { ...where2, runtime: this.runtime, alias: alias(id), hostKeys: input.hostKeys.keys, privateKey: key.privateKey };
+      const save = (remote, kept) => this.store.environments.addSsh({
+        name: name3,
+        ...where2,
+        ...remote,
+        directory: directoryIn(remote.home, input.directory),
+        hostKeys: input.hostKeys,
+        privateKey: key.privateKey,
+        ...kept ? { password: kept } : {}
+      }, id);
+      if (!password) return save(await probeHost(access));
+      await installKey(where2, this.runtime, input.hostKeys.keys, password, key.publicKey);
+      try {
+        try {
+          return save(await probeHost(access));
+        } catch (error) {
+          if (!(error instanceof SshFault) || error.code !== "ssh_key_refused") throw error;
+          return save(await probeHost({ ...access, password }), password);
+        }
+      } catch (error) {
+        await removeKey(password ? { ...access, password } : access, comment).catch(() => {
+        });
+        throw error;
+      }
+    });
+    if (prepared) this.prepared.delete(prepared.id);
+    if (grantTo) this.store.environments.grant(record3.id, grantTo.botId, grantTo.by);
+    this.changed();
+    return this.view(record3);
+  }
+  /** A new password for a machine reached with its password, checked with a login before it is kept. */
+  async setPassword(id, password) {
+    const record3 = this.need(id);
+    if (typeof password !== "string" || !password) throw new ChatError(400, "A password is needed", "ssh_password_missing");
+    if (!this.store.environments.usesPassword(id)) throw new ChatError(409, "This machine is reached with Jarvy's key, not a password");
+    await this.wrap(() => probeHost({ ...this.access(record3), password }));
+    this.store.environments.updateSsh(id, { password });
+    return this.get(id);
+  }
+  update(id, input) {
+    const record3 = this.need(id);
+    const name3 = input.name === void 0 ? void 0 : text3(input.name, 40);
+    if (name3 !== void 0 && !name3) throw new ChatError(400, "A name is needed");
+    if (name3 !== void 0 && name3 !== record3.name) this.freeName(name3);
+    this.store.environments.updateSsh(id, {
+      ...name3 !== void 0 ? { name: name3 } : {},
+      ...input.directory !== void 0 ? { directory: directoryIn(record3.spec.home ?? "/", input.directory) } : {}
+    });
+    this.changed();
+    return this.get(id);
+  }
+  /** Scans the machine again: `changed` when it no longer presents the keys the owner accepted. A machine reached
+   * with its password whose keys are unchanged is tried with Jarvy's key: once that works, the password is dropped
+   * and the key is used from then on (A59). `machine` is how it stands after. */
+  async check(id) {
+    const record3 = this.need(id), accepted = this.store.environments.sshSecrets(id).hostKeys;
+    const hostKeys2 = await this.scan(this.addressOf(record3)), changed = hostKeys2.keys.some((key) => !accepted.keys.includes(key));
+    if (!changed && this.store.environments.usesPassword(id)) {
+      const { password: _password, ...withKey } = this.access(record3);
+      try {
+        await probeHost(withKey);
+        this.store.environments.updateSsh(id, { password: null });
+        this.changed();
+      } catch (error) {
+        if (!(error instanceof SshFault) || error.code !== "ssh_key_refused") throw this.fault(error);
+      }
+    }
+    return { hostKeys: hostKeys2, changed, machine: this.get(id) };
+  }
+  /** The owner accepts the keys the machine presents now (after a reinstall, say). */
+  async trust(id, fingerprints) {
+    const { hostKeys: hostKeys2 } = await this.check(id);
+    if (!Array.isArray(fingerprints) || hostKeys2.fingerprints.join("\n") !== fingerprints.join("\n")) throw new ChatError(409, "The machine now presents other keys; check again", "ssh_host_key_changed");
+    this.store.environments.updateSsh(id, { hostKeys: hostKeys2 });
+    return this.get(id);
+  }
+  /** Removes Jarvy's key from the machine, then forgets it. When the machine can't be reached the key stays
+   * there; `force` forgets it anyway. Returns the Bots that were working there. */
+  async remove(id, force) {
+    const record3 = this.need(id);
+    try {
+      await this.wrap(() => removeKey(this.access(record3), keyComment(id)));
+    } catch (error) {
+      if (!force) throw error;
+    }
+    const moved = this.store.environments.dropSsh(id);
+    this.changed();
+    return moved;
+  }
+  /** The machine as a Bot's environment. Its own files go in ~/.cache/jarvy/<Bot> there. */
+  environment(record3, botId) {
+    const home = record3.spec.home ?? "/tmp";
+    return sshEnvironment(
+      record3.id,
+      this.access(record3),
+      record3.directory ?? home,
+      posix.join(home, ".cache", "jarvy", botId),
+      (text4) => console.error(`[ssh ${record3.name}] ${text4.trim()}`)
+    );
+  }
+  /** What a Bot is told of a machine. */
+  about(record3, botId) {
+    const temp = posix.join(record3.spec.home ?? "~", ".cache", "jarvy", botId);
+    return `A ${record3.spec.platform === "darwin" ? "macOS" : "Linux"} machine your owner added, reached over SSH as ${record3.spec.user}@${record3.spec.host}. Your tools run there as that user and can reach their files: work in your directory, leave other people's files and system directories alone unless the task needs it, and say in your reply what you changed there. Files from the chat and long command outputs go in ${temp}.`;
+  }
+  address(record3) {
+    return `${record3.spec.user}@${record3.spec.host}${record3.spec.port === "22" ? "" : `:${record3.spec.port}`}`;
+  }
+  /** environments.request: a machine the Bot may already use needs no card; one already added needs only a grant;
+   * else the card shows its fingerprints and takes the password. */
+  async prepareRequest(botId, input) {
+    const where2 = address(input);
+    const existing = this.store.environments.sshMachines().find((record3) => record3.spec.host === where2.host && record3.spec.user === where2.user && record3.spec.port === String(where2.port));
+    if (existing && this.store.environments.grantees(existing.id).includes(botId)) return { granted: existing };
+    const hostKeys2 = existing ? this.store.environments.sshSecrets(existing.id).hostKeys : await this.scan(where2);
+    const machine = {
+      name: existing?.name ?? (text3(input.name, 40) || `${where2.user}@${where2.host}`),
+      ...where2,
+      directory: typeof input.directory === "string" && input.directory.trim() ? input.directory.trim() : null,
+      purpose: input.purpose,
+      hostKeys: hostKeys2,
+      existing: existing ? { id: existing.id, name: existing.name } : null
+    };
+    return { question: { question: input.purpose, options: [{ label: "Add", value: "add" }], multiple: false, allowCustom: false, machine } };
+  }
+  /** The owner's answer on a request card: adds the machine with the password or a prepared key (or grants the one
+   * already added) to the Bot that asked, then settles the card. The password never enters the message. */
+  async fulfil(actorId, chatId, messageId, input) {
+    const message = this.chats.message(actorId, messageId), ask = message?.question?.machine;
+    if (!message || message.chatId !== chatId || !ask || message.question?.state !== "pending") throw new ChatError(409, "The question is already settled", "question_closed");
+    if (!this.chats.questions.waitingFor(messageId)) throw new ChatError(409, "The question has expired", "question_expired");
+    const botId = message.sender.id, by = this.store.userMemberId();
+    const existing = ask.existing && this.store.environments.get(ask.existing.id);
+    if (existing) {
+      this.store.environments.grant(existing.id, botId, by);
+      this.changed();
+    } else await this.add({
+      name: ask.name,
+      host: ask.host,
+      port: ask.port,
+      user: ask.user,
+      directory: ask.directory ?? void 0,
+      password: input.password,
+      ...input.keyId !== void 0 ? { keyId: input.keyId } : {},
+      hostKeys: ask.hostKeys
+    }, { botId, by });
+    return this.chats.questions.respond(actorId, chatId, messageId, { action: "answer", selected: [0] });
+  }
+  /** The machine a request card added or granted, by its address. */
+  find(botId, input) {
+    const where2 = address(input);
+    return this.store.environments.grants(botId).find((record3) => record3.kind === "ssh" && record3.spec.host === where2.host && record3.spec.user === where2.user && record3.spec.port === String(where2.port)) ?? null;
+  }
+  view(record3) {
+    const { spec } = record3, secrets = this.store.environments.sshSecrets(record3.id);
+    return {
+      id: record3.id,
+      name: record3.name,
+      host: spec.host ?? "",
+      port: Number(spec.port ?? 22),
+      user: spec.user ?? "",
+      home: spec.home ?? "",
+      directory: record3.directory ?? spec.home ?? "",
+      platform: spec.platform ?? "",
+      fingerprints: secrets?.hostKeys.fingerprints ?? [],
+      botIds: this.store.environments.grantees(record3.id),
+      login: secrets?.password || secrets?.passwordUnreadable ? "password" : "key",
+      publicKey: secrets?.privateKey ? publicKeyOf(secrets.privateKey, keyComment(record3.id)) : null
+    };
+  }
+  need(id) {
+    const record3 = this.store.environments.get(id);
+    if (!record3 || record3.kind !== "ssh") throw new ChatError(404, "No machine with this id", "machine_missing");
+    return record3;
+  }
+  addressOf(record3) {
+    return { host: record3.spec.host, port: Number(record3.spec.port), user: record3.spec.user };
+  }
+  access(record3) {
+    const secrets = this.store.environments.sshSecrets(record3.id);
+    if (!secrets?.privateKey || secrets.passwordUnreadable) throw new ChatError(409, "This machine's key doesn't open under this installation's master key; delete the machine and add it again", "ssh_key_unreadable");
+    return {
+      ...this.addressOf(record3),
+      runtime: this.runtime,
+      alias: alias(record3.id),
+      hostKeys: secrets.hostKeys.keys,
+      privateKey: secrets.privateKey,
+      ...secrets.password ? { password: secrets.password } : {}
+    };
+  }
+  freeName(name3) {
+    if (this.store.environments.sshMachines().some((record3) => record3.name === name3)) throw new ChatError(409, "Another machine has this name", "machine_name_taken");
+    return name3;
+  }
+  /** SSH failures reach people and Bots as chat errors with a code the interface can word. */
+  async wrap(work) {
+    try {
+      return await work();
+    } catch (error) {
+      throw this.fault(error);
+    }
+  }
+  fault(error) {
+    if (!(error instanceof SshFault)) return error;
+    switch (error.code) {
+      case "ssh_auth_failed":
+        return new ChatError(403, error.message, "ssh_auth_failed");
+      case "ssh_password_refused":
+        return new ChatError(403, error.message, "ssh_password_refused");
+      case "ssh_key_refused":
+        return new ChatError(403, error.message, "ssh_key_refused");
+      case "ssh_unreachable":
+        return new ChatError(409, error.message, "ssh_unreachable");
+      case "ssh_host_key_changed":
+        return new ChatError(409, error.message, "ssh_host_key_changed");
+      case "ssh_unsupported":
+        return new ChatError(409, error.message, "ssh_unsupported");
+      default:
+        return new ChatError(409, error.message, "ssh_failed", { detail: error.message });
+    }
+  }
+};
+var alias = (id) => `jarvy-${id}`;
+var keyComment = (id) => `jarvy-${id}`;
+var text3 = (value2, max) => typeof value2 === "string" ? value2.trim().slice(0, max) : "";
+function address(input) {
+  const host = text3(input.host, 253), user = text3(input.user, 64), port = input.port === void 0 || input.port === "" ? 22 : Number(input.port);
+  if (!HOST.test(host)) throw new ChatError(400, "host must be a host name or IP address", "ssh_bad_host");
+  if (!USER.test(user)) throw new ChatError(400, "user must be a user name on that machine", "ssh_bad_user");
+  if (!Number.isInteger(port) || port < 1 || port > 65535) throw new ChatError(400, "port must be 1 to 65535", "ssh_bad_port");
+  return { host, port, user };
+}
+function directoryIn(home, value2) {
+  const raw = text3(value2, 1e3);
+  if (!raw || raw === "~") return home;
+  if (raw.startsWith("~/")) return posix.join(home, raw.slice(2));
+  if (!raw.startsWith("/") || /[\x00-\x1f]/.test(raw)) throw new ChatError(400, "directory must be an absolute path or start with ~/", "ssh_bad_directory");
+  return posix.normalize(raw);
+}
+
 // src/server/infra/storage/history-repository.ts
 import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
-import { chmodSync as chmodSync3, mkdirSync as mkdirSync4 } from "node:fs";
-import { dirname as dirname5 } from "node:path";
+import { chmodSync as chmodSync3, mkdirSync as mkdirSync5 } from "node:fs";
+import { dirname as dirname6 } 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')";
@@ -6356,7 +7488,7 @@ var SUMMARY = `SELECT id,timestamp,role,model,
 var HistoryRepository = class {
   db;
   constructor(path) {
-    mkdirSync4(dirname5(path), { recursive: true, mode: 448 });
+    mkdirSync5(dirname6(path), { recursive: true, mode: 448 });
     this.db = new DatabaseSync2(path);
     chmodSync3(path, 384);
     const version = this.db.prepare("PRAGMA user_version").get().user_version;
@@ -6668,24 +7800,24 @@ var Model = class {
 };
 
 // src/server/service/bot/workspace.ts
-import { posix } from "node:path";
+import { posix as posix2 } from "node:path";
 
 // src/server/infra/files/workspace.ts
-import { mkdir as mkdir4, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join8 } from "node:path";
+import { mkdir as mkdir5, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join10 } from "node:path";
 var LocalWorkspace = class {
   constructor(cwd) {
     this.cwd = cwd;
   }
   get tempDir() {
-    return join8(this.cwd, "temp");
+    return join10(this.cwd, "temp");
   }
   async prepare() {
-    await mkdir4(this.tempDir, { recursive: true, mode: 448 });
+    await mkdir5(this.tempDir, { recursive: true, mode: 448 });
   }
   async writeTempFile(name3, content2, signal) {
     await this.prepare();
-    const path = join8(this.tempDir, name3);
+    const path = join10(this.tempDir, name3);
     await writeFile3(path, content2, { encoding: "utf8", flag: "wx", mode: 384, signal });
     return path;
   }
@@ -6693,8 +7825,8 @@ var LocalWorkspace = class {
 
 // src/server/infra/files/skills.ts
 import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync4 } from "node:fs";
-import { mkdir as mkdir5, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname as dirname6, join as join9 } from "node:path";
+import { mkdir as mkdir6, writeFile as writeFile4 } from "node:fs/promises";
+import { dirname as dirname7, join as join11 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/server/shared/skill.ts
@@ -6707,7 +7839,7 @@ function builtinSkills() {
   const skills = [];
   for (const entry of readdirSync(dir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const file = join9(dir, entry.name, "SKILL.md");
+    const file = join11(dir, entry.name, "SKILL.md");
     if (!existsSync4(file)) continue;
     const skill = parseSkill(entry.name, readFileSync4(file, "utf8"));
     if (skill) skills.push(skill);
@@ -6717,16 +7849,16 @@ function builtinSkills() {
 }
 async function installSkills(workspace, skills) {
   for (const skill of skills) {
-    const file = join9(workspace, skillPath(skill.name));
-    await mkdir5(dirname6(file), { recursive: true });
+    const file = join11(workspace, skillPath(skill.name));
+    await mkdir6(dirname7(file), { recursive: true });
     await writeFile4(file, skill.content, "utf8");
   }
 }
 function skillsDir() {
-  let dir = dirname6(fileURLToPath(import.meta.url));
+  let dir = dirname7(fileURLToPath(import.meta.url));
   for (let depth = 0; depth < 6; depth++) {
-    if (existsSync4(join9(dir, "package.json"))) return existsSync4(join9(dir, "skills")) ? join9(dir, "skills") : null;
-    const parent = dirname6(dir);
+    if (existsSync4(join11(dir, "package.json"))) return existsSync4(join11(dir, "skills")) ? join11(dir, "skills") : null;
+    const parent = dirname7(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -6759,7 +7891,7 @@ var Workspace = class {
   async writeTempFile(name3, content2, signal) {
     const env = this.current();
     if (env.kind === "host") return this.local.writeTempFile(name3, content2, signal);
-    const path = `${env.cwd}/temp/${name3}`;
+    const path = `${tempOf(env)}/${name3}`;
     await env.writeFile(path, content2);
     return path;
   }
@@ -6767,14 +7899,14 @@ var Workspace = class {
    * id when another file has that name). Returns where it went. */
   async put(name3, id, data, path) {
     const env = this.current();
-    let target2 = path ? posix.resolve(env.cwd, path) : `${env.cwd}/temp/files/${plain(name3)}`;
-    if (!path && await env.exists(target2)) {
+    let target3 = path ? posix2.resolve(env.cwd, path) : `${tempOf(env)}/files/${plain(name3)}`;
+    if (!path && await env.exists(target3)) {
       const dot = plain(name3).lastIndexOf("."), stem = dot > 0 ? plain(name3).slice(0, dot) : plain(name3), extension2 = dot > 0 ? plain(name3).slice(dot) : "";
-      target2 = `${env.cwd}/temp/files/${stem}-${id.slice(0, 8)}${extension2}`;
+      target3 = `${tempOf(env)}/files/${stem}-${id.slice(0, 8)}${extension2}`;
     }
-    await env.mkdir(posix.dirname(target2));
-    await env.writeFile(target2, data);
-    return target2;
+    await env.mkdir(posix2.dirname(target3));
+    await env.writeFile(target3, data);
+    return target3;
   }
   /** The files a Bot attaches to a message, read from its environment: paths there, relative to its directory. */
   async readOutgoing(items, signal) {
@@ -6782,7 +7914,7 @@ var Workspace = class {
     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);
+      const path = posix2.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);
@@ -6799,6 +7931,7 @@ function plain(name3) {
   const cleaned = name3.replace(/[/\\\0]/g, "_").trim();
   return cleaned && cleaned !== "." && cleaned !== ".." ? cleaned : "file";
 }
+var tempOf = (env) => env.temp ?? `${env.cwd}/temp`;
 
 // src/server/service/bot/state.ts
 var BotState = class {
@@ -6817,20 +7950,20 @@ var BotState = class {
 };
 
 // src/server/service/bot/tools.ts
-import { Type as Type5 } from "typebox";
-import { Value } from "typebox/value";
+import { Type as Type6 } from "typebox";
+import { Value as Value2 } from "typebox/value";
 
 // src/server/service/bot/history-read.ts
-import { randomUUID as randomUUID11 } from "node:crypto";
+import { randomUUID as randomUUID13 } from "node:crypto";
 import { Type as Type2 } from "typebox";
 
 // src/server/service/bot/history-format.ts
-function fence(text3, language = "text") {
+function fence(text4, language = "text") {
   let length = 3;
-  for (const match of text3.matchAll(/`+/g)) length = Math.max(length, match[0].length + 1);
+  for (const match of text4.matchAll(/`+/g)) length = Math.max(length, match[0].length + 1);
   const marker = "`".repeat(length);
   return `${marker}${language}
-${text3}
+${text4}
 ${marker}`;
 }
 var jsonBlock = (value2) => fence(JSON.stringify(value2, null, 2), "json");
@@ -6901,12 +8034,12 @@ async function readHistory(memory, workspace, input, signal) {
   const rendered = formatHistory(result, format);
   signal?.throwIfAborted();
   if (!input.to_file) return rendered;
-  const name3 = `history-${randomUUID11()}.${format === "json" ? "json" : "md"}`;
+  const name3 = `history-${randomUUID13()}.${format === "json" ? "json" : "md"}`;
   return workspace.writeTempFile(name3, rendered, signal);
 }
 
 // src/server/service/bot/file-view.ts
-var TEXT_LIMIT = 64 * 1024;
+var TEXT_LIMIT2 = 64 * 1024;
 var PICTURE_LIMIT = 4 * 1024 * 1024;
 function viewFile(file, data) {
   const head = `${file.name} (${file.mimeType || "application/octet-stream"}, ${byteSize(file.size)})`;
@@ -6915,10 +8048,10 @@ function viewFile(file, data) {
     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}
+  const text4 = data.length <= TEXT_LIMIT2 ? asText(data) : null;
+  if (text4 !== null) return `${head}
 
-${text3}`;
+${text4}`;
   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) {
@@ -7165,8 +8298,10 @@ var ChatTools = class {
     signal?.throwIfAborted();
     return messages.map((message) => messageRow(this.chats, this.bot, message, listing(message)));
   }
+  /** `mine`: only what this Bot sent; those messages carry the History ID of the turn that sent them (A21). */
   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);
+    const sender = input.mine ? this.bot : void 0;
+    const found = input.chatId === void 0 ? this.chats.searchAll(this.bot, input.query, input.limit ?? 30, void 0, sender) : this.chats.search(this.bot, this.chat(input.chatId).id, input.query, input.limit ?? 30, sender);
     const chats = /* @__PURE__ */ new Map();
     const chatOf = (id) => {
       if (!chats.has(id)) chats.set(id, this.chats.get(this.bot, id));
@@ -7192,7 +8327,7 @@ 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; 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.",
+    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 this chat platform: 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 },
@@ -7255,8 +8390,13 @@ 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. 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 })
+    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. mine=true: only messages you sent; each carries the History ID of the turn that sent it.",
+    schema: Type3.Object({
+      chatId: Type3.Optional(Type3.String()),
+      query: Type3.String({ minLength: 1, maxLength: 500 }),
+      limit: Type3.Optional(Type3.Integer({ minimum: 1, maximum: 100 })),
+      mine: Type3.Optional(Type3.Boolean({ description: "Only messages you sent" }))
+    }, { 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.",
@@ -7267,8 +8407,20 @@ var definitions = {
     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 })
   },
+  "environments.request": {
+    description: `Ask your owner to add a machine you need to work on, reached over SSH, on a card in a chat with them, and wait for the answer, as messages.ask does. The card shows the machine's host key fingerprints for them to check; they let you in there, with its login password or by adding a key made for it to the machine. You never see the password or the key, so never ask for that password in the chat. It returns {status:"added", id, name} or {status:"granted", id, name} when you may already use it, then environments.switch with that id moves your tools there; or {status:"declined"}.`,
+    schema: Type3.Object({
+      chatId: Type3.String(),
+      host: Type3.String({ minLength: 1, maxLength: 253, description: "Host name or IP address" }),
+      user: Type3.String({ minLength: 1, maxLength: 64, description: "The user to log in as" }),
+      port: Type3.Optional(Type3.Integer({ minimum: 1, maximum: 65535, description: "Default 22" })),
+      directory: Type3.Optional(Type3.String({ maxLength: 1e3, description: "Where your tools start there: an absolute path or one under ~/; default the user's home" })),
+      name: Type3.Optional(Type3.String({ maxLength: 40, description: "What to call the machine; default user@host" })),
+      purpose: Type3.String({ minLength: 1, maxLength: 300, description: "What you need it for, in your owner's language; shown on the card" })
+    }, { additionalProperties: false })
+  },
   "secrets.request": {
-    description: 'Ask your owner for a secret you need (a token, password or key) on a card in a chat with them, and wait for the answer, as messages.ask does. They enter the value on the card, which never shows it in the chat, and let you use it until they revoke it or only until this run ends, or decline. It returns {status:"granted", placeholder, until} or {status:"declined"}; if you may already use it, it returns at once. Then write the placeholder in bash.',
+    description: 'Ask your owner for a secret you need (a token, an API key or a password; to work on a machine over SSH, use environments.request) on a card in a chat with them, and wait for the answer, as messages.ask does. They enter the value on the card, which never shows it in the chat, and let you use it until they revoke it or only until this run ends, or decline. It returns {status:"granted", placeholder, until} or {status:"declined"}; if you may already use it, it returns at once. Then write the placeholder in bash.',
     schema: Type3.Object({
       chatId: Type3.String(),
       name: Type3.String({ pattern: "^[A-Z][A-Z0-9_]{0,63}$", description: "Capital letters, digits and underscores, such as GITHUB_TOKEN" }),
@@ -7430,7 +8582,7 @@ var Model2 = Type4.Object({
 }, { 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" }
+  { description: "How much the model thinks; auto lets this chat platform 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" })),
@@ -7439,7 +8591,7 @@ var Settings = {
   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"
+  description: "Where its file and command tools run by default: sandbox, a Linux container that this chat platform 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" }),
@@ -7482,11 +8634,104 @@ var agentDefinitions = {
   }
 };
 
+// src/server/service/bot/tool-errors.ts
+import { Value } from "typebox/value";
+var MAX_PROBLEMS = 5;
+function argumentProblems(schema, args) {
+  const lines = [];
+  for (const error of Value.Errors(schema, args)) {
+    if (error.keyword === "boolean" && error.schemaPath.endsWith("additionalProperties")) continue;
+    const extra = error.keyword === "additionalProperties" ? error.params.additionalProperties : void 0;
+    const at2 = error.instancePath ? error.instancePath.slice(1).replaceAll("/", ".") : "";
+    if (extra?.length) for (const name3 of extra) lines.push(`${at2 ? `${at2}.` : ""}${name3}: not a parameter of this tool`);
+    else lines.push(`${at2 || "args"}: ${error.message}`);
+    if (lines.length >= MAX_PROBLEMS) break;
+  }
+  return [...new Set(lines)].slice(0, MAX_PROBLEMS);
+}
+function invalidArguments(tool, schema, args) {
+  const problems = args === void 0 ? ["args: missing; call takes the tool's arguments in args"] : argumentProblems(schema, args);
+  return [`Invalid arguments for ${tool}:`, ...problems.map((line) => `- ${line}`), `Its parameters: ${JSON.stringify(schema)}`].join("\n");
+}
+function unknownTool(tool, names) {
+  return `${tool ? `Unknown chat tool "${tool}"` : "call and describe need tool"}. The tools: ${names.join(", ")}.`;
+}
+
+// src/server/service/bot/task-tools.ts
+import { Type as Type5 } from "typebox";
+var Clock = { hour: Type5.Integer({ minimum: 0, maximum: 23 }), minute: Type5.Integer({ minimum: 0, maximum: 59 }) };
+var Schedule = Type5.Union([
+  Type5.Object({ kind: Type5.Literal("once"), at: Type5.String({ minLength: 1, maxLength: 40, description: "ISO 8601; local time when it has no offset" }) }, { additionalProperties: false }),
+  Type5.Object({ kind: Type5.Literal("every"), minutes: Type5.Integer({ minimum: TASK_MINUTES_MIN, maximum: 60 * 24 * 30, description: "Counted from when the task is made, or from when the interval changes" }) }, { additionalProperties: false }),
+  Type5.Object({ kind: Type5.Literal("daily"), ...Clock }, { additionalProperties: false }),
+  Type5.Object({ kind: Type5.Literal("weekly"), weekday: Type5.Integer({ minimum: 0, maximum: 6, description: "0 is Sunday" }), ...Clock }, { additionalProperties: false })
+], { description: `When it runs, in this machine's local time: once at a time, every N minutes (${TASK_MINUTES_MIN} at the least), daily at hour:minute, or weekly on a weekday at hour:minute` });
+var Id = Type5.String({ minLength: 1, maxLength: 80, description: "The task's id, from tasks.list or a <task> in your batch" });
+var Fields = {
+  name: Type5.String({ minLength: 1, maxLength: 80, description: "A short name, such as Morning news" }),
+  instruction: Type5.String({ minLength: 1, maxLength: 8e3, description: "What to do each time, in full: you get it back when the task is due, so write it for your future self" })
+};
+var ByID = Type5.Object({ id: Id }, { additionalProperties: false });
+var taskDefinitions = {
+  "tasks.list": {
+    description: "List your scheduled tasks: each one's id, name, schedule, state (active, paused or done), next and last run. Times are this machine's local time, which timeZone names.",
+    schema: Type5.Object({}, { additionalProperties: false })
+  },
+  "tasks.get": { description: "One of your scheduled tasks in full, with its instruction.", schema: ByID },
+  "tasks.create": {
+    description: "Schedule a task for yourself. When it is due you get its instruction in a batch, as a <task>, and do it then; it never interrupts a turn, it waits for it to end. Runs missed while this chat platform was not running are skipped.",
+    schema: Type5.Object({ ...Fields, schedule: Schedule }, { additionalProperties: false })
+  },
+  "tasks.update": {
+    description: "Change one of your tasks; give only what changes. A new schedule counts from now; an interval left as it was keeps its rhythm.",
+    schema: Type5.Object({ id: Id, name: Type5.Optional(Fields.name), instruction: Type5.Optional(Fields.instruction), schedule: Type5.Optional(Schedule) }, { additionalProperties: false })
+  },
+  "tasks.pause": { description: "Stop a task from running until you resume it; it stays in the list.", schema: ByID },
+  "tasks.resume": { description: "Start a paused task again, from its next time after now.", schema: ByID },
+  "tasks.delete": { description: "Delete a task; it is gone for good. To stop it for a while, pause it instead.", schema: ByID }
+};
+function taskRow(task, full = false) {
+  return {
+    id: task.id,
+    name: task.name,
+    schedule: describeSchedule(task.schedule),
+    state: task.state,
+    ...task.nextRunAt !== null ? { next: localIso(task.nextRunAt) } : {},
+    ...task.lastRunAt !== null ? { last: localIso(task.lastRunAt) } : {},
+    ...full ? { instruction: task.instruction } : {}
+  };
+}
+function callTask(tasks, botId, name3, args) {
+  const id = args.id;
+  switch (name3) {
+    case "tasks.list":
+      return { timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone, now: localIso(Date.now()), tasks: tasks.list(botId).map((task) => taskRow(task)) };
+    case "tasks.get": {
+      const task = tasks.get(botId, id);
+      if (!task) throw new ChatError(404, "Task not found; see tasks.list");
+      return taskRow(task, true);
+    }
+    case "tasks.create":
+      return taskRow(tasks.create(botId, args), true);
+    case "tasks.update": {
+      const { id: _id, ...rest } = args;
+      return taskRow(tasks.update(botId, id, rest), true);
+    }
+    case "tasks.pause":
+      return taskRow(tasks.setState(botId, id, "paused"));
+    case "tasks.resume":
+      return taskRow(tasks.setState(botId, id, "active"));
+    case "tasks.delete":
+      tasks.remove(botId, id);
+      return { id, deleted: true };
+  }
+}
+
 // src/server/service/bot/tools.ts
-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()))
+var Gateway = Type6.Object({
+  action: Type6.Union([Type6.Literal("list"), Type6.Literal("describe"), Type6.Literal("call")]),
+  tool: Type6.Optional(Type6.String()),
+  args: Type6.Optional(Type6.Record(Type6.String(), Type6.Unknown()))
 }, { additionalProperties: false });
 var Tools = class {
   constructor(scope) {
@@ -7499,7 +8744,7 @@ var Tools = class {
   /** The agent Bot's own tools (A48); other Bots have none. */
   agent;
   get catalog() {
-    return this.agent ? { ...definitions, ...agentDefinitions } : definitions;
+    return this.agent ? { ...definitions, ...taskDefinitions, ...agentDefinitions } : { ...definitions, ...taskDefinitions };
   }
   /** Posts a card and waits for the person's answer (messages.ask, and the agent's confirmations). */
   async ask(chatId, question, toolCallId, signal) {
@@ -7531,22 +8776,27 @@ var Tools = class {
       description: "Gateway to the chat and to your own History. Use list to see the tools, describe to check a tool's parameters, then call to run it. Only what messages.send or messages.ask sends successfully is visible in the chat.",
       parameters: Gateway,
       execute: async (raw, { toolCallId, signal }) => {
-        if (!Value.Check(Gateway, raw)) throw new ChatError(400, "Invalid chat tool request");
+        if (!Value2.Check(Gateway, raw)) throw new ChatError(400, [
+          "Invalid chat tool request:",
+          ...argumentProblems(Gateway, raw).map((line) => `- ${line}`),
+          'It takes {action: "list" | "describe" | "call", tool, args}: list takes neither, describe takes tool, call takes both.'
+        ].join("\n"));
         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(this.catalog).map(([name4, tool]) => ({ name: name4, description: tool.description }));
         }
-        if (!raw.tool || !Object.hasOwn(this.catalog, raw.tool)) throw new ChatError(400, "Unknown chat tool; use list first");
+        if (!raw.tool || !Object.hasOwn(this.catalog, raw.tool)) throw new ChatError(400, unknownTool(raw.tool, Object.keys(this.catalog)));
         const name3 = raw.tool, definition = this.catalog[name3];
         if (raw.action === "describe") {
           if (raw.args !== void 0) throw new ChatError(400, "describe does not accept args");
           return { name: name3, 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 (!args || !Value2.Check(definition.schema, args)) throw new ChatError(400, invalidArguments(name3, definition.schema, args));
         if (this.agent && Object.hasOwn(agentDefinitions, name3))
           return this.agent.call(name3, args, (chatId, question) => this.ask(chatId, question, toolCallId, signal));
+        if (Object.hasOwn(taskDefinitions, name3)) return callTask(this.scope.tasks, this.scope.botId, name3, args);
         switch (name3) {
           case "history.read":
             return readHistory(this.scope.memory, this.scope.workspace, args, signal);
@@ -7584,6 +8834,16 @@ var Tools = class {
               until: result.selected[0]?.value === "once" ? "this run ends" : "your owner revokes it"
             };
           }
+          case "environments.request": {
+            const parsed = args;
+            if (!this.tools.chat(parsed.chatId).memberIds.some((id) => this.scope.chats.member(id)?.kind === "user")) throw new ChatError(400, "No person in this chat to answer; ask in a chat with your owner");
+            const input = { ...parsed, purpose: parsed.purpose.trim() }, prepared = await this.scope.places.request(input);
+            const added = (record3) => ({ id: record3.id, name: record3.name, note: "environments.switch with this id moves your tools there" });
+            if ("granted" in prepared) return { status: "granted", ...added(prepared.granted), note: "You may already use it; environments.switch with this id moves your tools there" };
+            const result = await this.ask(parsed.chatId, prepared.question, toolCallId, signal), found = this.scope.places.found(input);
+            if (result.status !== "answered" || !found) return { messageId: result.messageId, status: "declined", note: "Your owner declined. Don't ask for its password in the chat; go on without it, or ask what they would like instead." };
+            return { messageId: result.messageId, status: prepared.question.machine?.existing ? "granted" : "added", ...added(found) };
+          }
           case "chats.create":
             return this.tools.create(args);
           case "chats.update":
@@ -7685,7 +8945,7 @@ var Tools = class {
 };
 
 // src/server/service/bot/inbox.ts
-import { join as join10, dirname as dirname7 } from "node:path";
+import { join as join12, dirname as dirname8 } from "node:path";
 
 // src/server/shared/agent.ts
 var WELCOME_LANGUAGES = { en: "English", zh: "Chinese" };
@@ -7708,15 +8968,21 @@ function remember(map, id, definition) {
 }
 var environmentLine = (place) => place ? `<environment${attribute("name", place.name)}${attribute("directory", place.directory)}/>` : "";
 var iso2 = (time2) => new Date(time2).toISOString().replace(".000Z", "Z");
-var welcome = (owner, language) => `${owner} has just set up Jarvy and picked your model. You are their agent Bot. In this DM, welcome them in ${WELCOME_LANGUAGES[language]}, the language of their interface: say in a few sentences what Jarvy is and how you can help, such as building a team of Bots for their work and running Jarvy for them. Then ask what they want to get done: a software project, writing, research or something else.`;
-function encodeNoticeBatch(botId, notices, environment) {
-  if (!notices.length) throw new Error("Empty notice batch");
+var welcome = (owner, language) => `${owner} has just set up this chat platform 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 it is and how you can help, such as building a team of Bots for their work and running the platform for them. Then ask what they want to get done: a software project, writing, research or something else.`;
+function encodeNoticeBatch(botId, notices, environment, prompt) {
+  if (!notices.length && !prompt) 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}${environmentLine(environment)}</notice_batch>`;
+  return `<notice_batch${attribute("bot", botId)}>${[...chats.values()].join("")}${[...members.values()].join("")}${list}${instructionsLine(prompt)}${environmentLine(environment)}</notice_batch>`;
+}
+function instructionsLine(change) {
+  if (!change) return "";
+  const how = change.whole ? "The new text of the changed parts follows." : "Lines starting with - were removed and lines starting with + were added; the others are context.";
+  return `<instructions_changed${attribute("parts", change.parts.join(", "))}>${escape(change.diff)}<note>Your instructions changed. ${how} Follow the new version from now on. Your system prompt is not rewritten yet, so that the conversation stays cached; it will be after the next compaction.</note></instructions_changed>`;
 }
 function noticeTail(notices, chats, members) {
   for (const notice of notices) {
+    if (notice.kind === "task") continue;
     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)}/>`);
   }
@@ -7728,9 +8994,10 @@ function noticeTail(notices, chats, members) {
   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("");
+  const tasks = notices.flatMap((notice) => notice.kind !== "task" ? [] : [`<task${attribute("id", notice.task.id)}${attribute("name", notice.task.name)}${attribute("schedule", notice.task.schedule)}${attribute("due", iso2(notice.due))}>${escape(notice.task.instruction)}</task>`]);
+  return (tasks.length ? `<tasks>${tasks.join("")}<note>These are your scheduled tasks, not messages from anyone. Do what each says, then send what is worth sending, to your owner unless the task says where; if nothing is, do nothing.</note></tasks>` : "") + (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 change to your name, description or persona is a change to your instructions too. 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) {
+function encodeChatBatch(botId, messages, digest, notices, prompt) {
   if (!messages.length) throw new Error("Empty chat batch");
   const chats = /* @__PURE__ */ new Map(), members = /* @__PURE__ */ new Map(), ids = /* @__PURE__ */ new Set();
   const encoded = messages.map((message) => {
@@ -7743,12 +9010,12 @@ function encodeChatBatch(botId, messages, digest, notices) {
     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 quote2 = reply ? `<reply_to${attribute("message", reply.id)}${attribute("from", reply.sender.id)}>${escape(reply.text)}</reply_to>` : "";
     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>`;
+    return `<message${attributes}>${quote2}${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) : "";
+  let tail = (notices?.length ? noticeTail(notices, chats, members) : "") + instructionsLine(prompt);
   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>`;
@@ -7757,11 +9024,12 @@ function encodeChatBatch(botId, messages, digest, notices) {
 // src/server/service/bot/inbox.ts
 var BotInbox = class {
   /** `where` is the work environment the Bot is in now, named at the end of each batch (A50). */
-  constructor(botId, repository, chats, files, where2) {
+  constructor(botId, repository, chats, files, tasks, where2) {
     this.botId = botId;
     this.repository = repository;
     this.chats = chats;
     this.files = files;
+    this.tasks = tasks;
     this.where = where2;
   }
   /** Messages and other deliveries wait in the inbox (A41); either kind is work for the next run. A digest delivery
@@ -7772,50 +9040,61 @@ var BotInbox = class {
   claim(selection) {
     return this.repository.claim(this.botId, selection, this.hasNotices());
   }
+  /** Anything waiting that is not a message (A39, A41, A58): a task that is due also opens a run without messages. */
   hasNotices() {
     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, join10(dirname7(workspace), "agent", "pi", "sessions", `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.jsonl`));
+    return this.repository.ensureSession(this.botId, join12(dirname8(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. */
-  async prepare(batch) {
+  /** XML for the claimed messages plus the tail (other deliveries not told yet, how the instructions changed,
+   * unread); `notices` are told once the batch is submitted. */
+  async prepare(batch, prompt) {
     if (!batch.inputs.length) {
-      const pending2 = this.notices();
+      const pending2 = this.notices(prompt);
       return pending2 && { xml: pending2.xml, notices: pending2.ids };
     }
     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), ...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) };
+    return { xml: encodeChatBatch(this.botId, inputs, digest, pending.length ? pending : void 0, prompt), notices: pending.map((notice) => notice.id) };
   }
   /** Inbox rows as the envelope shape; the steered and the batch tails share it. */
   envelope(notices) {
-    return notices.map((notice) => {
+    return notices.flatMap((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 === "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 === "task") {
+        const fired = JSON.parse(notice.detail), task = this.tasks.get(this.botId, fired.task);
+        return task ? [{ kind: "task", id: notice.id, chat, task: {
+          id: task.id,
+          name: task.name,
+          instruction: task.instruction,
+          schedule: describeSchedule(task.schedule)
+        }, due: fired.due, 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 };
+        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 };
+      const text4 = marked ? previewQuotes(marked.content, marked.quotes).slice(0, 120) : "";
+      return [{ kind: "reaction", id: notice.id, chat, message: { id: notice.messageId ?? "", text: text4 }, actor: notice.actor, emoji: notice.detail, createdAt: notice.createdAt }];
     });
   }
   /** The batch went to the model: each delivery in its tail is told once. */
   acknowledge(notices) {
     if (notices.length) this.tell(notices);
   }
-  /** Notices the Bot has not been told (A39), as the XML that goes into a steered message or a batch tail. */
-  notices() {
-    const pending = this.chats.notices(this.botId);
+  /** Notices the Bot has not been told (A39), as the XML that goes into a steered message or a run of notices alone.
+   * `steer`: what may go into a running turn; a task waits for the turn to end and opens one of its own (A58). */
+  notices(prompt, steer = false) {
+    const pending = this.chats.notices(this.botId).filter((notice) => !steer || notice.kind !== "task");
     if (!pending.length) return null;
-    return { xml: encodeNoticeBatch(this.botId, this.envelope(pending), this.where?.()), ids: pending.map((notice) => notice.id) };
+    return { xml: encodeNoticeBatch(this.botId, this.envelope(pending), this.where?.(), prompt), ids: pending.map((notice) => notice.id) };
   }
   /** These notices reached the model. */
   tell(ids) {
@@ -7910,7 +9189,7 @@ var AgentRuntime = class {
     }
     this.notices = this.notices.catch(() => {
     }).then(async () => {
-      const pending = this.inbox.notices();
+      const pending = this.inbox.notices(null, true);
       if (!pending || this.stopping) return;
       if (this.prompting && this.session?.steer(pending.xml)) this.inbox.tell(pending.ids);
       else this.wake();
@@ -7945,7 +9224,8 @@ var AgentRuntime = class {
       this.update({ error: null });
       let submitted = false;
       try {
-        const prepared = await this.inbox.prepare(batch);
+        const change = session.promptChange();
+        const prepared = await this.inbox.prepare(batch, change);
         if (!prepared) {
           repository.releaseUnsubmitted(batch.run.id);
           continue;
@@ -7959,6 +9239,7 @@ var AgentRuntime = class {
         submitted = true;
         this.prompting = true;
         this.inbox.acknowledge(notices);
+        if (change) session.promptTold(change);
         this.promptTask = session.prompt(xml2);
         const result = await this.promptTask;
         repository.finish(batch.run.id, result.outcome, result.outcome === "failed" ? "model_request_failed" : null);
@@ -7967,8 +9248,8 @@ var AgentRuntime = class {
           throw new RuntimeFault("model_request_failed", `Model request failed: ${detail}`, 502, { detail });
         }
       } catch (error) {
-        const run = repository.run(batch.run.id);
-        if (run?.state === "claimed" || run?.state === "submitted") repository.finish(batch.run.id, submitted ? "unknown" : "failed", publicFault(error).code);
+        const run2 = repository.run(batch.run.id);
+        if (run2?.state === "claimed" || run2?.state === "submitted") repository.finish(batch.run.id, submitted ? "unknown" : "failed", publicFault(error).code);
         throw error;
       } finally {
         this.prompting = false;
@@ -8057,17 +9338,22 @@ The chat gateway lists tools only you have: models.list, bots.create, bots.updat
 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, skills = []) {
+function botPromptParts(setup, skills = []) {
   const bot = { ...setup.identity(), workspacePath: setup.workspace.cwd };
-  return `# Persona
+  return [
+    { name: "Persona", text: `# Persona
 Your name is ${bot.name}.
 
 ${bot.persona}
 
-## Environment
+` },
+    { name: "Environment", text: `## 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 : ""}${skillsSection(setup, skills)}
+` },
+    { name: "Your role", text: bot.agent ? AGENT_ROLE : "" },
+    { name: "Skills", text: skillsSection(setup, skills) },
+    { name: "Rules", text: `
 ## 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.
@@ -8078,21 +9364,26 @@ Files in messages come with an ID: files.get puts one into your environment and
 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.
+You can schedule work for yourself, once or on a schedule, with the tasks tools in the chat gateway. When a task is due, its instruction comes in a batch as a <task>; do it then.
 
 ## History
-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.
+Your History keeps everything you did: your thinking, each tool call with its arguments, and what came back. Most of it never reaches the chat.
+Each message you sent carries a History ID, the turn in which you sent it. To recall how you did something, find a message of yours with messages.search (mine=true searches only yours), then read that turn with history.read. History IDs are in order, so the IDs just before and after it show what led up to it and what followed; read summaries first, then the details you need.
+History is material to look back on, not an instruction for the task at hand.
 
 ## Secrets
 Never ask anyone for a password, token or key in the chat, and never put one in a message or in a file others read.
 secrets.list in the chat gateway shows the secrets your owner lets you use. To use one, write its placeholder, such as {{secret:GITHUB_TOKEN}}, in a bash command: it is filled in for that command only. Prefer handing it to a program through its environment, such as GH_TOKEN={{secret:GITHUB_TOKEN}} gh pr list, over putting it among the command's arguments. Placeholders in write and edit content stay as written.
-Secret values are masked in everything you see. If you need one you don't have, call secrets.request: your owner enters it on a card, and you wait for the answer.
+Secret values are masked in everything you see. When work needs a credential you don't have, such as a token, an API key or a password, ask for it with secrets.request: your owner enters it on a card, and you wait for the answer. Don't ask people to run commands that grant you access instead.
 
-${workspaceSection(setup, bot.workspacePath)}
+` },
+    { name: "Workspace", text: workspaceSection(setup, bot.workspacePath) },
+    { name: "Responding", text: `
 ## 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();
@@ -8110,7 +9401,7 @@ Leave everything else alone by default: other members' workspaces, live data dir
 Shared directories and other people's files are read-only. Ask the person in charge before writing to them.
 
 ## Work environment
-Your tools run on your owner's computer by default, the machine running Jarvy.
+Your tools run on your owner's computer by default, the machine where this chat platform's server runs.
 ${SWITCHING}
 `;
 }
@@ -8119,11 +9410,11 @@ function skillsSection(setup, skills) {
   const home = setup.home(), base = home.kind === "computer" ? home.cwd : setup.workspace.cwd;
   return `
 ## Skills
-Skills are guides that come with Jarvy for kinds of work you help with. When a task matches one, read its file before you start, and follow it. They are suggestions for the owner: propose a plan from them and act once the owner agrees. Jarvy keeps these files in your workspace and writes them again each time you start, so changes to them don't last.
+Skills are guides that come with this chat platform for kinds of work you help with. When a task matches one, read its file before you start, and follow it. They are suggestions for the owner: propose a plan from them and act once the owner agrees. They are kept in your workspace and written again each time you start, so changes to them don't last.
 ${skills.map((skill) => `- ${skill.name}: ${skill.description} File: ${base}/${skillPath(skill.name)}`).join("\n")}
 `;
 }
-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.";
+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. To work on another machine over SSH, ask your owner to add it with environments.request; they type its password on that card, not in the chat.";
 
 // src/server/shared/live.ts
 var LIVE_STEPS = 300;
@@ -8133,8 +9424,8 @@ var LIVE_INPUT = 300;
 var LIVE_MESSAGE = 2e3;
 
 // src/server/service/bot/live-input.ts
-function clip(text3, length) {
-  return text3.length > length ? `${text3.slice(0, length - 1)}\u2026` : text3;
+function clip(text4, length) {
+  return text4.length > length ? `${text4.slice(0, length - 1)}\u2026` : text4;
 }
 var field = (value2, length = LIVE_INPUT) => typeof value2 === "string" ? clip(value2, length) : void 0;
 var record2 = (value2) => value2 && typeof value2 === "object" && !Array.isArray(value2) ? value2 : {};
@@ -8163,7 +9454,7 @@ 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 = record2(values.args), where2 = target(inner, chat);
+  const inner = record2(values.args), where2 = target2(inner, chat);
   if (action === "messages.send") return { action, chat: where2, text: field(inner.message, LIVE_MESSAGE) };
   if (action === "messages.ask") return {
     action,
@@ -8173,7 +9464,7 @@ function gateway(values, chat) {
   };
   return where2 ? { action, chat: where2 } : { action };
 }
-function target(inner, chat) {
+function target2(inner, chat) {
   if (typeof inner.to === "string") return { id: null, type: "dm", title: clip(inner.to, 80) };
   return typeof inner.chatId === "string" ? chat(inner.chatId) ?? void 0 : void 0;
 }
@@ -8188,10 +9479,10 @@ function sentChat(output, chat) {
 
 // src/server/service/bot/live.ts
 var FLUSH_MS = 100;
-function liveOutput(text3) {
-  if (!text3) return null;
-  if (text3.length <= 2 * LIVE_OUTPUT_END) return { head: text3, tail: "", omitted: 0 };
-  return { head: text3.slice(0, LIVE_OUTPUT_END), tail: text3.slice(-LIVE_OUTPUT_END), omitted: text3.length - 2 * LIVE_OUTPUT_END };
+function liveOutput(text4) {
+  if (!text4) return null;
+  if (text4.length <= 2 * LIVE_OUTPUT_END) return { head: text4, tail: "", omitted: 0 };
+  return { head: text4.slice(0, LIVE_OUTPUT_END), tail: text4.slice(-LIVE_OUTPUT_END), omitted: text4.length - 2 * LIVE_OUTPUT_END };
 }
 var LiveTurns = class {
   constructor(chat) {
@@ -8248,8 +9539,8 @@ var LiveTurns = class {
         }
         const step = this.steps.get(id);
         if (!step) return;
-        const text3 = (step.text ?? "") + event.delta, over = Math.max(0, text3.length - LIVE_TEXT);
-        step.text = text3.slice(over);
+        const text4 = (step.text ?? "") + event.delta, over = Math.max(0, text4.length - LIVE_TEXT);
+        step.text = text4.slice(over);
         step.omitted = (step.omitted ?? 0) + over;
         this.queue({ op: "text", id, append: event.delta });
         return;
@@ -8500,12 +9791,15 @@ var BotService = class {
     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);
+    this.machines = new SshMachines(deps.store, deps.chats, () => this.listChanged());
+    this.environments = new BotEnvironments(deps.store, this.computers, this.machines);
   }
   bots = /* @__PURE__ */ new Map();
   lives = /* @__PURE__ */ new Map();
   computers;
   environments;
+  /** The owner's SSH machines (A57). */
+  machines;
   closed = false;
   started = false;
   /** What only the agent Bot does (A48). */
@@ -8526,14 +9820,14 @@ var BotService = class {
       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)({
+    const runtime = new AgentRuntime(new BotInbox(id, store.runtime, chats, files, store.tasks, here), (setup, model, reference, activity) => (this.deps.factory ?? PiSession.create)({
       store,
       bot: record3,
       selection: model.selection,
       reference,
       credentials,
       tools: setup.tools,
-      systemPrompt: () => botPrompt(setup, skills),
+      systemPrompt: () => botPromptParts(setup, skills),
       onHistory: setup.onHistory,
       activity,
       live: (event) => live.event(event),
@@ -8544,7 +9838,7 @@ var BotService = class {
       const place = this.environments.home(id, record3.workspacePath);
       return { kind: place.kind === "sandbox" ? "computer" : "host", cwd: place.directory };
     }, skills);
-    const memory = new Memory(join11(dirname8(record3.workspacePath), "history.db"));
+    const memory = new Memory(join13(dirname9(record3.workspacePath), "history.db"));
     bot = new Bot(id, {
       identity: new Identity(id, store),
       model: new Model(id, store, resolveThinking),
@@ -8561,9 +9855,12 @@ var BotService = class {
         places: {
           list: () => this.environments.list(id, record3.workspacePath),
           switch: (environmentId) => this.environments.switch(id, environmentId, record3.workspacePath),
-          summary: (botId) => this.environments.summary(botId)
+          summary: (botId) => this.environments.summary(botId),
+          request: (input) => this.machines.prepareRequest(id, input),
+          found: (input) => this.machines.find(id, input)
         },
         secrets: { list: () => this.deps.secrets.listFor(id), prepare: (name3, purpose) => this.deps.secrets.prepareRequest(id, name3, purpose) },
+        tasks: this.deps.tasks,
         ...id === AGENT_BOT_ID ? { agent: this.agent } : {}
       }),
       agentRuntime: runtime,
@@ -8633,10 +9930,33 @@ var BotService = class {
   }
   /** 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"}` }] : [];
+    return this.grant(id, "host", granted);
+  }
+  /** The owner lets a Bot use an SSH machine (A57), or takes it back, the same way. */
+  grantMachine(id, machineId, granted) {
+    this.machines.get(machineId);
+    return this.grant(id, machineId, granted);
+  }
+  /** The owner deletes an SSH machine: Bots working there are back in their default, and told. */
+  async removeMachine(machineId, force) {
+    const name3 = this.machines.get(machineId).name, granted = this.machines.get(machineId).botIds;
+    const moved = await this.machines.remove(machineId, force);
+    for (const id of /* @__PURE__ */ new Set([...granted, ...moved])) {
+      if (!this.deps.store.getBot(id)) continue;
+      const changes = [{ what: "access", value: `${name3}: removed` }];
+      if (moved.includes(id)) {
+        const to = this.environments.here(id, this.record(id).workspacePath);
+        changes.push({ what: "environment", value: `${to.name}, in ${to.directory}` });
+      }
+      this.tellOwner(id, changes, moved.includes(id));
+    }
+  }
+  grant(id, environmentId, granted) {
+    const { changed, moved, name: name3 } = this.environments.grant(id, environmentId, granted, this.deps.store.userMemberId(), this.record(id).workspacePath);
+    const changes = changed ? [{ what: "access", value: `${name3}: ${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);
+    if (changed && environmentId !== "host") this.listChanged();
     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
@@ -8764,7 +10084,7 @@ var BotService = class {
     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 rm3(dirname8(workspacePath), { recursive: true, force: true });
+    if (!keepFiles) await rm4(dirname9(workspacePath), { recursive: true, force: true });
   }
   async close() {
     if (this.closed) return;
@@ -8800,8 +10120,8 @@ var ConnectionService = class {
   }
   info() {
     const listening = this.listening, material = this.material;
-    const addresses = listening && material ? lanAddresses(listening.host).map((address) => `https://${address.includes(":") ? `[${address}]` : address}:${listening.port}`) : [];
-    return { https: !!material, allowHttp: this.allowHttp(), addresses, fingerprint: material?.fingerprint ?? null };
+    const addresses = listening && material ? lanAddresses(listening.host).map((address2) => `https://${address2.includes(":") ? `[${address2}]` : address2}:${listening.port}`) : [];
+    return { https: !!material, allowHttp: this.allowHttp(), addresses, fingerprint: material?.fingerprint ?? null, fingerprintSha1: material?.fingerprintSha1 ?? null };
   }
   /** The root certificate (DER) for devices to install, when serving HTTPS. */
   rootCertificate() {
@@ -8922,6 +10242,123 @@ var SecretService = class {
   }
 };
 
+// src/server/service/tasks.ts
+var MAX_WAIT_MS = 6e4;
+var TaskService = class {
+  constructor(store, chats, wake) {
+    this.store = store;
+    this.chats = chats;
+    this.wake = wake;
+  }
+  timer;
+  stopped = false;
+  /** Where a due task is told: the DM between the Bot and its owner, made when first needed. */
+  dm(botId) {
+    const bot = this.store.getBot(botId);
+    if (!bot) throw new ChatError(404, "Bot not found");
+    return this.chats.openDirect(botId, this.store.userMemberId()).id;
+  }
+  /** Checked against what a Bot and its owner can both mean: an existing schedule the Bot can compute. `previous`:
+   * the task's schedule before; an interval left as it was keeps counting from when it was set, a new one from now. */
+  schedule(value2, previous) {
+    if (!value2 || typeof value2 !== "object" || Array.isArray(value2)) throw new ValidationError("A schedule is needed", "task_schedule_invalid");
+    const input = value2;
+    const clock = (hour, minute) => {
+      if (!Number.isInteger(hour) || !Number.isInteger(minute) || hour < 0 || hour > 23 || minute < 0 || minute > 59)
+        throw new ValidationError("Hour is 0-23 and minute 0-59", "task_schedule_invalid");
+      return { hour, minute };
+    };
+    switch (input.kind) {
+      case "once": {
+        const at2 = typeof input.at === "string" ? Date.parse(input.at) : input.at;
+        if (!Number.isSafeInteger(at2)) throw new ValidationError("A one-off task needs a time", "task_schedule_invalid");
+        return { kind: "once", at: at2 };
+      }
+      case "every": {
+        if (!Number.isInteger(input.minutes) || input.minutes < TASK_MINUTES_MIN || input.minutes > 60 * 24 * 30)
+          throw new ValidationError(`Every ${TASK_MINUTES_MIN} minutes at the least, a month at most`, "task_schedule_invalid");
+        const minutes = input.minutes;
+        return { kind: "every", minutes, since: previous?.kind === "every" && previous.minutes === minutes ? previous.since : Date.now() };
+      }
+      case "daily":
+        return { kind: "daily", ...clock(input.hour, input.minute) };
+      case "weekly": {
+        if (!Number.isInteger(input.weekday) || input.weekday < 0 || input.weekday > 6)
+          throw new ValidationError("Weekday is 0 (Sunday) to 6", "task_schedule_invalid");
+        return { kind: "weekly", weekday: input.weekday, ...clock(input.hour, input.minute) };
+      }
+      default:
+        throw new ValidationError("Schedule kind is once, every, daily or weekly", "task_schedule_invalid");
+    }
+  }
+  text(value2, label, max) {
+    if (typeof value2 !== "string" || !value2.trim() || value2.length > max || value2.includes("\0")) throw new ValidationError(`${label} must be 1-${max} characters`, "task_invalid");
+    return value2.trim();
+  }
+  list(botId) {
+    return this.store.tasks.list(botId);
+  }
+  get(botId, id) {
+    return this.store.tasks.get(botId, id);
+  }
+  create(botId, input) {
+    if (!this.store.getBot(botId)) throw new ChatError(404, "Bot not found");
+    const task = this.store.tasks.create({
+      botId,
+      name: this.text(input.name, "A name", 80),
+      instruction: this.text(input.instruction, "An instruction", 8e3),
+      schedule: this.schedule(input.schedule)
+    });
+    this.tick();
+    return task;
+  }
+  update(botId, id, input) {
+    const before = this.store.tasks.get(botId, id);
+    if (!before) throw new ChatError(404, "Task not found");
+    const task = this.store.tasks.update(botId, id, {
+      ...input.name === void 0 ? {} : { name: this.text(input.name, "A name", 80) },
+      ...input.instruction === void 0 ? {} : { instruction: this.text(input.instruction, "An instruction", 8e3) },
+      ...input.schedule === void 0 ? {} : { schedule: this.schedule(input.schedule, before.schedule) }
+    });
+    this.tick();
+    return task;
+  }
+  setState(botId, id, state) {
+    const task = this.store.tasks.setState(botId, id, state);
+    if (!task) throw new ChatError(404, "Task not found");
+    this.tick();
+    return task;
+  }
+  remove(botId, id) {
+    if (!this.store.tasks.remove(botId, id)) throw new ChatError(404, "Task not found");
+    this.tick();
+  }
+  /** Starts the timer. Runs missed while the server was not running are skipped, not made up (A58): each task moves on to
+   * its next time after now, and a one-off already past is done. */
+  start() {
+    this.stopped = false;
+    this.store.tasks.skipOverdue();
+    this.tick();
+  }
+  stop() {
+    this.stopped = true;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = void 0;
+  }
+  /** One pass: fire what is due, then sleep until the next one (or a minute, so a clock change is noticed). */
+  tick() {
+    if (this.stopped) return;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = void 0;
+    const dms = new Map(this.store.tasks.dueBots().map((botId) => [botId, this.dm(botId)]));
+    for (const fired of this.store.tasks.fire(dms)) this.wake(fired.botId);
+    const soonest = this.store.tasks.soonest();
+    const wait = soonest === null ? MAX_WAIT_MS : Math.min(MAX_WAIT_MS, Math.max(1e3, soonest - Date.now()));
+    this.timer = setTimeout(() => this.tick(), wait);
+    this.timer.unref?.();
+  }
+};
+
 // src/server/application.ts
 var Application = class _Application {
   constructor(store, dataDir, release, factory) {
@@ -8945,12 +10382,14 @@ var Application = class _Application {
     this.files = new ChatFiles(this.chats);
     store.runtime.recover();
     this.secrets = new SecretService(store, this.chats);
+    this.tasks = new TaskService(store, this.chats, (botId) => this.bots.deliver(botId, urgencyOf("task", "schedule")));
     this.bots = new BotService({
       store,
       chats: this.chats,
       files: this.files,
       credentials: this.credentials,
       secrets: this.secrets,
+      tasks: this.tasks,
       changed: (id) => this.events.publish({ kind: "bot", id, status: this.bots.status(id) }),
       listChanged: () => this.events.publish({ kind: "bots" }),
       factory
@@ -8971,9 +10410,11 @@ var Application = class _Application {
   models;
   connection;
   secrets;
+  /** Scheduled tasks and their timer (A58). */
+  tasks;
   closing;
   static async open(dataDir, options = {}) {
-    await mkdir6(resolve3(dataDir), { recursive: true, mode: 448 });
+    await mkdir7(resolve3(dataDir), { recursive: true, mode: 448 });
     const root = await realpath(resolve3(dataDir));
     let app;
     let release;
@@ -8982,7 +10423,7 @@ var Application = class _Application {
         retries: 0,
         stale: 3e4,
         update: 1e4,
-        lockfilePath: join12(root, ".runtime.lock"),
+        lockfilePath: join14(root, ".runtime.lock"),
         onCompromised: () => {
           console.error("[runtime] data lock compromised");
           options.onCompromised?.();
@@ -9005,10 +10446,12 @@ var Application = class _Application {
   }
   start() {
     this.bots.start();
+    this.tasks.start();
     this.models.refreshCatalog();
   }
   close() {
     if (!this.closing) this.closing = (async () => {
+      this.tasks.stop();
       await this.auth.close();
       await this.bots.close();
       await this.credentials.close();
@@ -9021,17 +10464,17 @@ var Application = class _Application {
 };
 
 // src/server/daemon.ts
-import { spawn as spawn2 } from "node:child_process";
-import { closeSync, mkdirSync as mkdirSync5, openSync, readFileSync as readFileSync5, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
-import { join as join13, resolve as resolve4 } from "node:path";
-var pidPath = (dir) => join13(resolve4(dir), "jarvy.pid");
-var logPath = (dir) => join13(resolve4(dir), "jarvy.log");
+import { spawn as spawn3 } from "node:child_process";
+import { closeSync, mkdirSync as mkdirSync6, openSync, readFileSync as readFileSync5, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join15, resolve as resolve4 } from "node:path";
+var pidPath = (dir) => join15(resolve4(dir), "jarvy.pid");
+var logPath = (dir) => join15(resolve4(dir), "jarvy.log");
 function writePidFile(dir, url) {
   const record3 = { pid: process.pid, startToken: startToken(process.pid), url, startedAt: Date.now() };
-  writeFileSync3(pidPath(dir), JSON.stringify(record3), { mode: 384 });
+  writeFileSync4(pidPath(dir), JSON.stringify(record3), { mode: 384 });
 }
 function removePidFile(dir) {
-  if (readRecord(dir)?.pid === process.pid) rmSync2(pidPath(dir), { force: true });
+  if (readRecord(dir)?.pid === process.pid) rmSync3(pidPath(dir), { force: true });
 }
 function readRecord(dir) {
   try {
@@ -9060,15 +10503,15 @@ function runningServer(dir) {
   if (!record3) return null;
   const token = alive(record3.pid) ? startToken(record3.pid) : null;
   if (token === null || token && record3.startToken && token !== record3.startToken) {
-    rmSync2(pidPath(dir), { force: true });
+    rmSync3(pidPath(dir), { force: true });
     return null;
   }
   return record3;
 }
 function startBackground(script, runArgs, dir) {
-  mkdirSync5(resolve4(dir), { recursive: true, mode: 448 });
+  mkdirSync6(resolve4(dir), { recursive: true, mode: 448 });
   const log = openSync(logPath(dir), "a", 384);
-  const child = spawn2(process.execPath, [...process.execArgv, script, "run", ...runArgs], { detached: true, stdio: ["ignore", log, log, "ipc"] });
+  const child = spawn3(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);
@@ -9101,7 +10544,7 @@ async function stopServer(dir, waitMs = 3e4) {
   process.kill(record3.pid, "SIGTERM");
   for (const deadline = Date.now() + waitMs; Date.now() < deadline; ) {
     if (!alive(record3.pid)) {
-      rmSync2(pidPath(dir), { force: true });
+      rmSync3(pidPath(dir), { force: true });
       return "stopped";
     }
     await new Promise((done) => setTimeout(done, 200));
@@ -9169,7 +10612,7 @@ async function initialize(store) {
 }
 function reachNotes(host, port, allowHttp) {
   if (isLoopbackHost(host)) return { info: [], warning: null };
-  const info = lanAddresses(host).map((address) => `On your network: https://${address.includes(":") ? `[${address}]` : address}:${port}`);
+  const info = lanAddresses(host).map((address2) => `On your network: https://${address2.includes(":") ? `[${address2}]` : address2}:${port}`);
   info.push("To trust Jarvy on other devices, install its certificate from Settings \u2192 Network.");
   return { info, warning: allowHttp ? "WARNING: HTTP access is allowed in Settings \u2192 Network, so passwords and conversations reach other devices unencrypted." : null };
 }
@@ -9249,8 +10692,8 @@ async function main() {
   try {
     if (!store.isInitialized()) await initialize(store);
     const { host, port, url } = listenOptions(args);
-    const webRoot = join14(dirname9(fileURLToPath2(import.meta.url)), "../web");
-    if (!existsSync5(join14(webRoot, "index.html"))) throw new Error("Web build missing. Run npm run build first");
+    const webRoot = join16(dirname10(fileURLToPath2(import.meta.url)), "../web");
+    if (!existsSync5(join16(webRoot, "index.html"))) throw new Error("Web build missing. Run npm run build first");
     const server = createJarvyServer(app, webRoot, app.connection.prepare(host, port));
     closeHttp = () => server.close();
     await server.listen(port, host);