agent-office-studio 0.9.1 → 0.9.2

package/server/index.js

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import crypto from 'node:crypto';
 import os from 'node:os';
-import { spawn, spawnSync } from 'node:child_process';
+import { spawn, spawnSync, execFile } from 'node:child_process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { WebSocketServer } from 'ws';
 import { summarizeTool, stationFor } from './tools.js';
@@ -26,10 +26,12 @@ import { Guests } from './guests.js';
 import { Visits, visitJob } from './visits.js';
 import { findIcon } from './icons.js';
 import { Journeys } from './journeys.js';
+import { Apps } from './apps.js';
 import * as files from './files.js';
 import { lanAddresses, phoneLinks, qrSvg, qrText } from './phone.js';
 import { Tunnel } from './tunnel.js';
 import { findCloudflared } from './cloudflared.js';
+import { Telegram } from './telegram.js';
 
 const HERE = path.dirname(fileURLToPath(import.meta.url));
 const APP = path.resolve(HERE, '..');
@@ -63,6 +65,32 @@ try { fs.chmodSync(STATE_FILE, 0o600); } catch {}
 if (DATA_IN_ROOT) console.warn(`[office] The office's data (${DATA}) is inside the projects folder (${ROOT}). Job tokens are kept elsewhere and file tools are denied it, but a job there can still read it through the shell. Set OFFICE_DATA to a folder outside ${ROOT}.`);
 const auth = new Auth(DATA);
 const journeys = new Journeys(DATA);
+// The boss's Telegram bot (see the Telegram section below).
+const phoneThreads = new Set(); // office threads the boss has answered from Telegram
+let lastPhoneSpeaker = null; // who the last message to the phone was from
+const telegram = new Telegram({
+  dataDir: DATA,
+  // The tests' stand-in for api.telegram.org.
+  ...(process.env.OFFICE_TELEGRAM_API && { api: process.env.OFFICE_TELEGRAM_API }),
+  onMessage: ({ text, files, replyTo }) => {
+    const root = replyTo && state.chat.find((m) => m.id === replyTo && !m.thread);
+    // Answering from the phone (say, a flag) brings that thread, and the
+    // job's own, to the phone from then on.
+    if (root) for (const id of [root.id, threadJob(root)?.thread]) if (id) phoneThreads.add(id);
+    try { chat({ text, files, thread: root?.id, channel: GENERAL, via: 'telegram' }); } catch (err) { telegram.send(err.message); }
+  },
+  saveUpload: (name, buf) => {
+    if (buf.length > MAX_UPLOAD) return null;
+    name = path.basename(name).replace(/[\x00-\x1f\/\\:*?"<>|]/g, '_').replace(/^\.+/, '').slice(0, 120) || 'file';
+    const id = crypto.randomBytes(6).toString('hex');
+    fs.mkdirSync(uploadDir(id), { recursive: true, mode: 0o700 });
+    fs.writeFileSync(path.join(uploadDir(id), name), buf, { mode: 0o600 });
+    return id;
+  },
+  onNotice: (text) => post('chief', text, { channel: GENERAL, kind: 'telegram' }),
+});
+// The home screen's apps (apps.js). Every open office hears about a change.
+const apps = new Apps(DATA, { repoPath, onChange: (list) => send({ t: 'apps', apps: list }) });
 const board = new Leaderboard(DATA, { onChange: () => send({ t: 'leaderboard', leaderboard: board.status() }) });
 const MAX_UPLOAD = 25 * 1024 * 1024;
 const MAX_LOG = 600;
@@ -70,6 +98,17 @@ const MAX_CHAT = 300;
 // After a turn ends, keep the session open briefly: a message that landed
 // at the last moment starts another turn instead of being lost.
 const GRACE_MS = 2500;
+// How long a session whose input was closed gets to exit by itself.
+const CLOSE_MS = 10000;
+// A session mid-turn that has said nothing for this long is stuck. Waiting on
+// the model, it streams every token, so silence means the request hung (the
+// usual case: Amara's turn after two image reads never got an answer). A tool
+// gets longer, since builds are quiet. STALL_MODEL_MIN / STALL_TOOL_MIN to tune.
+const minutesEnv = (k, d) => (parseFloat(process.env[k]) > 0 ? parseFloat(process.env[k]) : d) * 60000;
+const STALL_MODEL_MS = minutesEnv('STALL_MODEL_MIN', 5);
+const STALL_TOOL_MS = minutesEnv('STALL_TOOL_MIN', 15);
+// A hung request is restarted by the office this many times per job; after that the boss decides.
+const AUTO_RESTARTS = 2;
 
 // The roster. Capacity grows with level, so later names are "hires".
 // Role, personality and background are defaults; the Team tab edits them.
@@ -440,6 +479,7 @@ const snapshot = () => ({
   usage,
   auth: auth.status(),
   leaderboard: board.status(),
+  apps: apps.list(),
   economy: economy.status(),
   links: links.status(),
   visitors: links.visiting(),
@@ -553,6 +593,7 @@ function post(from, text, extra = {}) {
   send({ t: 'chat', msg });
   save();
   voiceNote(msg);
+  relayToTelegram(msg);
   return msg;
 }
 
@@ -774,7 +815,7 @@ const OFFICE_TOOLS = [
   'mcp__office__office_roster', 'mcp__office__message_colleague', 'mcp__office__hand_off', 'mcp__office__flag_for_boss',
   'mcp__office__list_channels', 'mcp__office__create_channel', 'mcp__office__invite_to_channel', 'mcp__office__post_to_channel',
   'mcp__office__restart_office', 'mcp__office__clear_context', 'mcp__office__attach_files',
-  'mcp__office__heavy_work', 'mcp__office__keep_running',
+  'mcp__office__heavy_work', 'mcp__office__keep_running', 'mcp__office__add_app',
   'mcp__office__office_shop', 'mcp__office__buy_item',
   'mcp__office__bets', 'mcp__office__place_bet', 'mcp__office__take_bet', 'mcp__office__cancel_bet',
 ];
@@ -802,6 +843,45 @@ function listRepos() {
     .sort((a, b) => a.localeCompare(b, undefined, { sensitivity: 'base' }));
 }
 
+// Folders that finish a typed path: `/abs/pa`, `~/pa`, or `#project/sub/pa`
+// (a project's own folders). Names only, never files; hidden folders only
+// when asked for with a leading dot.
+function completePaths(q) {
+  if (typeof q !== 'string' || q.length > 400 || q.includes('\0')) return [];
+  let base, head = '', rest = q;
+  const proj = q.match(/^#([\w.-]+)\/(.*)$/s);
+  if (proj) {
+    const name = listRepos().find((r) => r.replace(/\s+/g, '-') === proj[1]);
+    if (!name) return [];
+    base = path.join(ROOT, name); head = `#${proj[1]}/`; rest = proj[2];
+  } else if (q === '~' || q.startsWith('~/')) {
+    base = os.homedir(); head = '~/'; rest = q.slice(2);
+  } else if (q.startsWith('/')) {
+    base = path.sep; head = '/'; rest = q.slice(1);
+  } else return [];
+  const cut = rest.lastIndexOf('/');
+  const dirPart = rest.slice(0, cut + 1), prefix = rest.slice(cut + 1).toLowerCase();
+  const parts = dirPart.split('/').filter(Boolean);
+  if (proj && parts.includes('..')) return [];
+  const dir = path.resolve(base, ...parts);
+  if (proj) {
+    try { const real = fs.realpathSync(dir), top = fs.realpathSync(base); if (real !== top && !real.startsWith(top + path.sep)) return []; } catch { return []; }
+  }
+  let entries;
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return []; }
+  const out = [];
+  for (const e of entries) {
+    if (e.name === 'node_modules' || e.name === '.git') continue;
+    if (e.name.startsWith('.') && !prefix.startsWith('.')) continue;
+    if (!e.name.toLowerCase().startsWith(prefix)) continue;
+    let isDir = e.isDirectory();
+    if (e.isSymbolicLink()) { try { isDir = fs.statSync(path.join(dir, e.name)).isDirectory(); } catch { continue; } }
+    if (isDir) out.push(e.name);
+  }
+  out.sort((a, b) => a.localeCompare(b, undefined, { sensitivity: 'base' }));
+  return out.slice(0, 30).map((name) => ({ name, path: `${head}${dirPart}${name}/` }));
+}
+
 // `extra` tags a job, as a guest's (`from`, `guest`); it must be set before the job can start.
 function createJob({ repo, prompt, mode = 'edit', model = '', auto = false, agentId = '' }, extra = {}) {
   // A project at a host (`away`) isn't on this machine; its name is `web@host`.
@@ -906,7 +986,8 @@ function start(job, agentId) {
   const cwd = job.away ? awayDir(job) : repoPath(job.repo);
   // An away job reads files it doesn't own, so nothing that runs code here:
   // no built-in tools, no settings, hooks or connectors, only the office's.
-  const args = ['-p', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose',
+  // Partial messages are the heartbeat: without them a long answer is as quiet as a hung one.
+  const args = ['-p', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose', '--include-partial-messages',
     ...(job.away ? ['--permission-mode', 'default', '--tools', '', '--setting-sources', '', '--strict-mcp-config', '--settings', JSON.stringify({ autoMemoryEnabled: false })] : MODES[job.mode].args)];
   if (job.model) args.push('--model', job.model);
   if (job.sessionId) args.push('--resume', job.sessionId);
@@ -961,6 +1042,7 @@ function start(job, agentId) {
   }
   const child = spawn(CLAUDE, args, { cwd, env: { CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: String(settings.get('compactPct')), ...(job.guest ? { CLAUDE_CODE_DISABLE_AUTO_MEMORY: '1' } : {}), ...auth.env() }, stdio: ['pipe', 'pipe', 'pipe'] });
   running.set(job.id, child);
+  pulse.set(job.id, { heard: Date.now(), turn: true, tools: new Map() });
   startProcs();
   child.stdin.on('error', () => {});
   write(child, first);
@@ -968,11 +1050,14 @@ function start(job, agentId) {
   let buf = '';
   child.stdout.setEncoding('utf8');
   child.stdout.on('data', (chunk) => {
+    heard(job);
     buf += chunk;
     let i;
     while ((i = buf.indexOf('\n')) >= 0) {
       const line = buf.slice(0, i);
       buf = buf.slice(i + 1);
+      // Token deltas only say the model is answering; the whole message follows.
+      if (line.startsWith('{"type":"stream_event"')) continue;
       if (line.trim()) onLine(job, line);
     }
   });
@@ -984,12 +1069,14 @@ function start(job, agentId) {
     if (job.status !== 'working') return;
     if (job.clearing && !job.stopRequested) return recycle(job);
     if (job.switching && !job.stopRequested) return resume(job);
+    if (job.restarting && !job.stopRequested) return revive(job);
     if (job.stopRequested) finish(job, 'stopped', job.stopWhy || 'Stopped by you.');
     else if (job.lastTurn) finish(job, job.lastTurn.ok ? 'done' : 'failed', job.lastTurn.ok ? null : job.lastTurn.error);
     else finish(job, 'failed', errTail.trim().split('\n').pop() || why);
   };
   const ended = (why) => {
     running.delete(job.id);
+    pulse.delete(job.id);
     fs.rm(mcpFile, { force: true }, () => {});
     if (procs) { delete procs[job.id]; }
     endGrace(job);
@@ -1030,6 +1117,7 @@ function cleanUpAfter(job) {
 // arrived meanwhile are all the new session carries.
 function recycle(job) {
   const note = job.clearNote;
+  const by = job.clearedBy || 'self';
   const carried = job.context;
   const wake = [
     `Your original brief:\n${job.prompt}`,
@@ -1041,7 +1129,7 @@ function recycle(job) {
   Object.assign(job, { sessionId: null, clearNote: null, clearedBy: null, clearing: false, hinted: false, context: null, lastTurn: null, pending: wake,
     status: 'queued', queuedAt: Date.now(), waiting: false, carryOn: true });
   job.clears = (job.clears || 0) + 1;
-  job.lastClear = { note, by: job.clearedBy || 'self', at: Date.now() };
+  job.lastClear = { note, by, at: Date.now() };
   tokens.delete(job.id);
   addLog(job, { kind: 'system', summary: `Cleared context${carried ? ` (${Math.round(carried / 1000)}k tokens)` : ''} and carried on fresh` });
   pushJob(job);
@@ -1062,6 +1150,142 @@ function resume(job) {
   setImmediate(pump);
 }
 
+// ---------- stuck sessions ----------
+
+// Each live session's heartbeat: when it last wrote anything, whether a turn
+// is under way, and the tools it has called that haven't answered yet.
+// jobId -> { heard, turn, tools: Map(toolUseId -> { name, at }) }
+const pulse = new Map();
+const minutes = (ms) => { const m = Math.round(ms / 60000); return m < 1 ? 'under a minute' : `${m} min`; };
+
+function heard(job) {
+  const p = pulse.get(job.id);
+  if (p) p.heard = Date.now();
+  if (job.stuck) {
+    addLog(job, { kind: 'system', summary: `Moving again after ${minutes(Date.now() - job.stuck.since)}.` });
+    job.stuck = null;
+    pushJob(job);
+  }
+}
+
+// A session mid-turn, not waiting on anyone, that has been silent too long.
+// The office's own tools are left out: a wait for the build lock or a
+// colleague is the office's to know about, not a hang.
+function checkStalls() {
+  const now = Date.now();
+  for (const [id, p] of pulse) {
+    const job = state.jobs.find((j) => j.id === id);
+    if (!job || job.status !== 'working' || job.stuck || !p.turn || job.waiting || graces.has(id)) continue;
+    if (job.stopRequested || job.clearing || job.switching || job.restarting) continue;
+    const open = [...p.tools.values()];
+    if (open.some((t) => t.name.startsWith('mcp__office__'))) continue;
+    const tool = open.sort((a, b) => a.at - b.at)[0];
+    const quiet = now - p.heard;
+    if (quiet < (tool ? STALL_TOOL_MS : STALL_MODEL_MS)) continue;
+    flagStuck(job, tool, quiet);
+  }
+}
+setInterval(checkStalls, Math.min(30000, STALL_MODEL_MS / 3)).unref();
+
+function flagStuck(job, tool, quiet) {
+  const last = [...job.log].reverse().find((e) => e.kind === 'tool')?.summary;
+  const what = tool ? `${tool.name} has been running for ${minutes(Date.now() - tool.at)} with no output`
+    : `no answer from the model for ${minutes(quiet)}${last ? ` (last step: ${clip(last, 60)})` : ''}`;
+  job.stuck = { since: Date.now() - quiet, kind: tool ? 'tool' : 'model', tool: tool?.name || null, what };
+  addLog(job, { kind: 'system', summary: `Looks stuck: ${what}.` });
+  pushJob(job);
+  // A hung request is the usual case, and resuming the session fixes it: its
+  // transcript has everything up to the last tool result. A hung tool may be
+  // waiting on something real (a prompt, a lock), so that is the boss's call.
+  if (!tool && (job.autoRestarts || 0) < AUTO_RESTARTS) return restartJob(job, 'office');
+  const who = nameOf(job.agentId);
+  post('chief', `**Stuck?** · ${who} on "${clip(job.title, 80)}": ${what}.${job.autoRestarts ? ` The office already restarted it ${job.autoRestarts === 1 ? 'once' : `${job.autoRestarts} times`}.` : ''} Open the job to restart it or hand it to a free colleague, or tell me "get someone to take over from ${who}".`,
+    { kind: 'stuck', jobId: job.id, thread: null, channel: GENERAL });
+}
+
+// End a live session and start it again on the same transcript. The boss's
+// own restart, or the office's when a request hangs.
+function restartJob(job, by = 'boss') {
+  const child = running.get(job.id);
+  if (job.status !== 'working' || !child) throw new Error('That job isn’t running.');
+  if (job.restarting || job.stopRequested) return;
+  job.restarting = by;
+  if (by === 'office') job.autoRestarts = (job.autoRestarts || 0) + 1;
+  addLog(job, { kind: 'system', summary: by === 'office' ? 'Restarting the session to unstick it; it carries on from its last step.' : 'Boss restarted the session; it carries on from its last step.' });
+  pushJob(job);
+  child.kill('SIGTERM');
+  setTimeout(() => running.get(job.id) === child && child.kill('SIGKILL'), 5000);
+}
+
+// What the boss said after the agent's last sign of life: written to a
+// session that was stuck, so never read, and lost with it unless sent again.
+function unread(job) {
+  const said = [];
+  for (const e of [...job.log].reverse()) {
+    if (e.kind === 'user') said.unshift(e.summary);
+    else if (['text', 'tool', 'result', 'thinking'].includes(e.kind) || /^Clocked in/.test(e.summary)) break;
+  }
+  return said;
+}
+
+function revive(job) {
+  const by = job.restarting;
+  const why = job.stuck?.what || (by === 'office' ? 'it had stopped responding' : 'the boss asked');
+  const missed = unread(job).filter((m) => m !== job.prompt);
+  const note = `Your session was restarted by ${by === 'office' ? 'the office' : 'the boss'}: ${why}. Everything up to your last tool result is still in your history and the project. ` +
+    'Carry on from where you were. If the same step hangs again (a large image, a command that never returns), do it a different way.';
+  Object.assign(job, { restarting: null, stuck: null, lastTurn: null, status: 'queued', queuedAt: Date.now(), waiting: false, carryOn: true,
+    pending: [
+      job.sessionId ? null : `Your brief:\n${job.prompt}`,
+      note,
+      missed.length ? `Sent to you while you were stuck:\n${missed.join('\n\n')}` : null,
+      job.pending,
+    ].filter(Boolean).join('\n\n') });
+  tokens.delete(job.id);
+  pushJob(job);
+  save();
+  setImmediate(pump);
+}
+
+// Hand a job to a free colleague: the stuck session ends, and they get the
+// brief, where it stood and the last steps taken, in the same thread. A
+// stuck session can't read messages, so taking over is the help that lands.
+function rescueJob(job, { agentId = '' } = {}) {
+  if (job.guest || job.away || job.visitor || job.remote) throw new Error("That job belongs to another office.");
+  if (!['working', 'queued', 'failed', 'stopped'].includes(job.status)) throw new Error('That job has finished.');
+  const from = job.agentId;
+  const busy = new Set(state.jobs.filter((j) => j.status === 'working' && j.id !== job.id).map((j) => j.agentId));
+  const free = onFloor().filter((s) => s.id !== from && !busy.has(s.id));
+  let to = agentId;
+  if (to) {
+    if (!hired().some((s) => s.id === to)) throw new Error('Pick someone from the office.');
+    if (to === from) throw new Error(`That's ${nameOf(from)} already. Restart their session instead.`);
+  } else {
+    if (!free.length) throw new Error(`Everyone else is busy. Restart ${nameOf(from)}'s session instead, or pick someone to queue it for.`);
+    to = free[Math.floor(Math.random() * free.length)].id;
+  }
+  const fromName = from ? nameOf(from) : 'Nobody';
+  const steps = job.log.filter((e) => ['tool', 'text', 'error', 'user'].includes(e.kind)).slice(-15)
+    .map((e) => `- ${e.kind === 'user' ? 'Boss: ' : e.kind === 'error' ? 'Error: ' : ''}${clip(String(e.summary).replace(/\s+/g, ' '), 200)}`);
+  const brief = [
+    `${from ? `${fromName} was on this job and got stuck` : 'This job got stuck'}${job.stuck ? ` (${job.stuck.what})` : ''}. The boss has handed it to you to finish.`,
+    `Original brief:\n${job.prompt}`,
+    `Where it stood: ${whereItStood(job)}`,
+    steps.length ? `${fromName}'s last steps, oldest first:\n${steps.join('\n')}` : '',
+    `Their work so far is in the project: check it before redoing anything. If they hung on a step (a large image, a command that never returned), do it a different way.`,
+  ].filter(Boolean).join('\n\n');
+  if (job.status === 'working' || job.status === 'queued') stopJob(job, `Handed to ${nameOf(to)}: it was stuck.`);
+  addLog(job, { kind: 'system', summary: `Handed to ${nameOf(to)} to finish.` });
+  const next = createJob({ repo: job.repo, prompt: brief, mode: job.mode, model: job.model, agentId: to },
+    { title: job.title, thread: job.thread, channel: job.channel, ...(job.via && { via: job.via }), takeoverOf: job.id });
+  job.takenOverBy = next.id;
+  pushJob(job);
+  const line = next.status === 'queued' ? `${nameOf(to)} is busy, so taking over "${clip(job.title, 80)}" from ${fromName} is next on their list.`
+    : `${nameOf(to)} is taking over "${clip(job.title, 80)}" from ${fromName}.`;
+  post('chief', line, { jobId: next.id, channel: job.channel, thread: job.thread || null });
+  return next;
+}
+
 // Set by the boss from the job card. Any job can be switched; one the chief
 // sized stops climbing on its own, since the boss has now chosen.
 function setModel(job, model) {
@@ -1073,13 +1297,36 @@ function setModel(job, model) {
   Object.assign(job, { model, autoModel: false });
   const live = job.status === 'working' && running.get(job.id);
   addLog(job, { kind: 'system', summary: `Boss moved this from ${from} to ${modelName(model)}${live ? '; switching after the current turn' : ''}` });
-  if (live) { job.switching = true; live.stdin.end(); }
+  if (live) { job.switching = true; closeSession(job); }
   pushJob(job);
 }
 
+// End a live session's turn-taking: close its input so it exits, and ended()
+// takes it from there. A session with a background task still running (a
+// build, a watcher) does not exit on that: it stays up to report on the task,
+// and nothing written to it lands, so a clear or a reply sat unread until the
+// task ended. If it is still there after CLOSE_MS, it is ended instead.
+function closeSession(job) {
+  const child = running.get(job.id);
+  if (!child) return;
+  child.stdin.end();
+  setTimeout(() => {
+    if (running.get(job.id) !== child) return;
+    addLog(job, { kind: 'system', summary: 'The session did not close by itself (a background task was likely still running), so the office ended it.' });
+    child.kill('SIGTERM');
+    setTimeout(() => running.get(job.id) === child && child.kill('SIGKILL'), 5000);
+  }, CLOSE_MS);
+}
+
 function write(child, text) {
   if (!child.stdin.writable) return false;
   child.stdin.write(JSON.stringify({ type: 'user', message: { role: 'user', content: text } }) + '\n');
+  // An idle session now has a turn to take, timed from here. One mid-turn
+  // keeps its clock: a nudge to a hung session must not reset it.
+  for (const [id, c] of running) {
+    const p = c === child && pulse.get(id);
+    if (p && !p.turn) Object.assign(p, { turn: true, heard: Date.now() });
+  }
   return true;
 }
 
@@ -1140,6 +1387,8 @@ function onLine(job, line) {
   let e;
   try { e = JSON.parse(line); } catch { return; }
   if (e.type === 'assistant' && graces.has(job.id)) { endGrace(job); job.lastTurn = null; }
+  // Anything but the end of a turn means one is under way (a background task's report starts one by itself).
+  if (e.type !== 'result' && e.type !== 'system' && pulse.has(job.id)) pulse.get(job.id).turn = true;
 
   if (e.type === 'system' && e.subtype === 'init') {
     job.sessionId = e.session_id;
@@ -1171,6 +1420,7 @@ function onLine(job, line) {
         if (c.name === 'Bash') sampleSoon();
         job.tools++;
         job.turnTools++;
+        pulse.get(job.id)?.tools.set(c.id, { name: c.name, at: Date.now() });
         const entry = { kind: 'tool', tool: c.name, summary: summarizeTool(c.name, c.input), station: stationFor(c.name) };
         if (c.name === 'TodoWrite' && Array.isArray(c.input?.todos)) {
           entry.todos = c.input.todos.slice(0, 12).map((t) => ({ text: String(t.content || '').slice(0, 80), done: t.status === 'completed' }));
@@ -1181,12 +1431,15 @@ function onLine(job, line) {
     }
   } else if (e.type === 'user') {
     for (const c of e.message?.content || []) {
+      if (c.type === 'tool_result') pulse.get(job.id)?.tools.delete(c.tool_use_id);
       if (c.type === 'tool_result' && c.is_error) {
         const text = textOf(c.content).trim();
         addLog(job, { kind: 'error', summary: text.slice(0, 400), blocked: /permission|haven't granted/i.test(text) });
       }
     }
   } else if (e.type === 'result') {
+    const p = pulse.get(job.id);
+    if (p) { p.turn = false; p.tools.clear(); }
     job.cost += e.total_cost_usd || 0;
     job.turns++;
     // The result's usage is summed over every API call in the turn, so its cache
@@ -1216,7 +1469,7 @@ function onLine(job, line) {
     // starts the job again without its history.
     if (ok && job.clearNote && running.has(job.id)) {
       job.clearing = true;
-      running.get(job.id).stdin.end();
+      closeSession(job);
       return;
     }
     const pending = waits.get(job.id) || [];
@@ -1230,8 +1483,7 @@ function onLine(job, line) {
     }
     graces.set(job.id, setTimeout(() => {
       graces.delete(job.id);
-      const child = running.get(job.id);
-      if (child) child.stdin.end();
+      if (running.has(job.id)) closeSession(job);
       else finish(job, ok ? 'done' : 'failed', job.lastTurn?.error);
     }, GRACE_MS));
   }
@@ -1307,6 +1559,8 @@ function finish(job, status, error) {
   tokens.delete(job.id);
   guestTurn.delete(job.id);
   job.waiting = false;
+  job.stuck = null;
+  job.restarting = null;
   const before = progress();
   // An agent that ended its turn still needing the boss's input has not
   // finished: it is waiting. Nothing is marked, scored or announced as done.
@@ -1573,7 +1827,7 @@ function clearContext(ids) {
       job.clearedBy = 'boss';
       job.lastClear = { note: job.clearNote, by: 'boss', at: Date.now() };
       // Idle with the session held open: nothing will end the turn, so close it now.
-      if (job.waiting && running.has(job.id)) { job.clearing = true; running.get(job.id).stdin.end(); }
+      if (job.waiting && running.has(job.id)) { job.clearing = true; closeSession(job); }
       cleared.push(s.name);
       continue;
     }
@@ -1632,7 +1886,13 @@ function parseTags(text) {
   return { agent: agents[0], agents: [...new Set(agents)], repo: projects[0], clean: clean || text };
 }
 
-function chiefContext(text, agents, repo, channel = GENERAL) {
+// Where the boss wrote from, in words an agent can act on.
+const SOURCES = { telegram: 'Telegram, on their phone', web: 'the web chat, at the laptop' };
+const sourceNote = (via) => (SOURCES[via] ? `The boss wrote this from ${SOURCES[via]}.` : '');
+// A boss message handed to a job says where it came from, so "send it here" has an answer.
+const withSource = (text, via) => (SOURCES[via] ? `[${sourceNote(via)}]\n${text}` : text);
+
+function chiefContext(text, agents, repo, channel = GENERAL, via = '') {
   const roster = STAFF.slice(0, capacity());
   const lines = ['Staff:'];
   for (const s of roster) {
@@ -1641,7 +1901,7 @@ function chiefContext(text, agents, repo, channel = GENERAL) {
     if (!j && state.dismissed.includes(s.id)) { lines.push(`- ${s.name} (${id}): dismissed, gone home`); continue; }
     if (!j) { lines.push(`- ${s.name} (${id}): free`); continue; }
     const last = [...j.log].reverse().find((e) => e.kind === 'tool' || e.kind === 'text');
-    lines.push(`- ${s.name} (${id}): working on job ${j.id} in ${j.repo}, asked for in #${channelOf(j.channel)}: "${j.title}". Latest: ${last ? last.summary.slice(0, 100).replace(/\n/g, ' ') : 'just starting'}`);
+    lines.push(`- ${s.name} (${id}): working on job ${j.id} in ${j.repo}, asked for in #${channelOf(j.channel)}: "${j.title}". Latest: ${last ? last.summary.slice(0, 100).replace(/\n/g, ' ') : 'just starting'}${j.stuck ? `. LOOKS STUCK: ${j.stuck.what}` : ''}`);
   }
   const queued = state.jobs.filter((j) => j.status === 'queued');
   if (queued.length) {
@@ -1661,6 +1921,7 @@ function chiefContext(text, agents, repo, channel = GENERAL) {
     const reacts = Object.keys(m.reactions || {}).join('');
     lines.push(`${who}: ${m.text.slice(0, 200).replace(/\n/g, ' ')}${reacts ? ` [reactions: ${reacts}]` : ''}`);
   }
+  if (SOURCES[via]) lines.push('', `${sourceNote(via)} "Here", "send it to me" and replies mean that place unless they say otherwise.`);
   lines.push('', `New message from the boss: ${text}`);
   if (agents.length === 1) lines.push(`Tagged agent: ${agents[0].name} (id ${agents[0].id})`);
   if (agents.length > 1) lines.push(`Tagged agents: ${agents.map((a) => `${a.name} (id ${a.id})`).join(', ')}`);
@@ -1668,8 +1929,9 @@ function chiefContext(text, agents, repo, channel = GENERAL) {
   return lines.join('\n');
 }
 
-function hireWork({ repo, brief, agentId, mode, model, auto, say, files, thread, inThread, channel }) {
+function hireWork({ repo, brief, agentId, mode, model, auto, say, files, thread, inThread, channel, via }) {
   const job = createJob({ repo, prompt: withFiles(brief, files), mode, model, auto, agentId: agentId || '' });
+  if (SOURCES[via]) job.via = via;
   job.thread = thread;
   job.channel = channel;
   const who = nameOf(job.agentId);
@@ -1688,7 +1950,7 @@ function hireWork({ repo, brief, agentId, mode, model, auto, say, files, thread,
 
 // `root` is the thread this conversation lives in: the boss's message, or the
 // thread they replied in (`inThread`), where the chief answers too.
-async function dispatch(text, mode, model, files, root, inThread, channel) {
+async function dispatch(text, mode, model, files, root, inThread, channel, via) {
   const { agent, agents, repo, clean } = parseTags(text);
   const say = (line, extra = {}) => post('chief', line, { channel, ...(inThread ? { thread: root } : {}), ...extra });
   const open = state.jobs.filter((j) => j.status === 'working' || j.status === 'queued');
@@ -1696,7 +1958,7 @@ async function dispatch(text, mode, model, files, root, inThread, channel) {
   // A named project with nothing open in it can only be new work. Several
   // tagged agents still go past the chief, who decides how to split it.
   if (repo && agents.length < 2 && !open.some((j) => j.repo === repo)) {
-    return hireWork({ repo, brief: clean, agentId: agent?.id, mode, ...sized(model), files, thread: root, inThread, channel });
+    return hireWork({ repo, brief: clean, agentId: agent?.id, mode, ...sized(model), files, thread: root, inThread, channel, via });
   }
 
   chiefBusy = true;
@@ -1709,7 +1971,7 @@ async function dispatch(text, mode, model, files, root, inThread, channel) {
     const said = files.length
       ? `${text}\n(Attached: ${files.map((f) => f.name).join(', ')}${shown.length ? `. ${shown.length === 1 ? 'The image is' : 'The images are'} attached for you to look at.` : ''})`
       : text;
-    d = await route(chiefContext(said, agents, repo, channel), { bin: CLAUDE, model: settings.get('chiefModel'), images: shown, env: auth.env() });
+    d = await route(chiefContext(said, agents, repo, channel, via), { bin: CLAUDE, model: settings.get('chiefModel'), images: shown, env: auth.env() });
     state.chiefCost += d.cost || 0;
     nudgeUsage();
   } finally {
@@ -1730,7 +1992,8 @@ async function dispatch(text, mode, model, files, root, inThread, channel) {
       const up = d.escalate && job.status !== 'working' ? bump(job) : null;
       if (up) addLog(job, { kind: 'system', summary: `Sent back by the boss; moving up to ${TIER_LABEL[up]}` });
       answered(job);
-      deliver(job, withFiles(clean, files));
+      if (SOURCES[via]) job.via = via;
+      deliver(job, withSource(withFiles(clean, files), via));
       return post('chief', (d.say || `Passed to ${nameOf(job.agentId)}.`) + (up ? ` Running it on ${TIER_LABEL[up]} this time.` : ''), {
         jobId: job.id,
         channel,
@@ -1752,7 +2015,7 @@ async function dispatch(text, mode, model, files, root, inThread, channel) {
     // has. Otherwise each job goes to the chief's pick.
     for (const w of work) w.agentId = (work.length === 1 && agents.length === 1 && agent.id) || (onRoster(w.agentId) ? w.agentId : work.length === 1 ? agent?.id || '' : '');
     for (const w of work) {
-      hireWork({ repo: w.project, brief: (w.brief || '').trim() || clean, agentId: w.agentId, mode, ...sized(model, w.model), say: w.say || (work.length === 1 ? d.say : ''), files, thread: root, inThread, channel });
+      hireWork({ repo: w.project, brief: (w.brief || '').trim() || clean, agentId: w.agentId, mode, ...sized(model, w.model), say: w.say || (work.length === 1 ? d.say : ''), files, thread: root, inThread, channel, via });
     }
     return;
   }
@@ -1765,6 +2028,17 @@ async function dispatch(text, mode, model, files, root, inThread, channel) {
     return say(clearContext(ids.length ? ids : hired().map((x) => x.id)));
   }
   if (d.action === 'standup') return void runStandup(true);
+  if (d.action === 'restart' || d.action === 'takeover') {
+    const job = state.jobs.find((j) => j.id === d.jobId) || (agent && workingJobOf(agent.id));
+    if (!job) return say('Which job? Tag the agent who is stuck.');
+    try {
+      if (d.action === 'takeover') return void rescueJob(job, { agentId: d.agentId && d.agentId !== job.agentId ? d.agentId : '' });
+      restartJob(job);
+      return say(d.say || `Restarted ${nameOf(job.agentId)}'s session; they carry on from their last step.`, { jobId: job.id });
+    } catch (err) {
+      return say(err.message, { jobId: job.id });
+    }
+  }
   // An answer that is merely about a job gets the same link a follow-up does.
   // Asking "how did that go?" from another channel shouldn't dead-end just
   // because the job has already finished and nothing was passed on.
@@ -1790,8 +2064,59 @@ function remoteEnded(job) {
   post('chief', `${name} at @${job.remote.host} ${how} “${job.title}”.${said}`, { jobId: job.id, channel: job.channel, thread: job.thread || null });
 }
 
-function chat({ text, mode = 'edit', model = '', files, thread, channel }) {
+// Full autonomy from Telegram. `/grant`, or the bare words, on their own;
+// `/grant all` for every job a permission stopped.
+const GRANT_WORDS = /^(\/grant|(grant\s+)?full\s+autonomy)(\s+(to\s+|for\s+)?(all|everyone))?[.!]?$/i;
+const GRANTED = 'You now have permission to run the commands that were blocked. Carry on from where you stopped.';
+// Stopped by a permission it lacked, and ours to raise.
+const blockedJobs = () => state.jobs
+  .filter((j) => j.denials?.length && j.status !== 'working' && j.status !== 'queued' && !j.guest && !j.away && !j.remote)
+  .sort((x, y) => (y.endedAt || 0) - (x.endedAt || 0));
+// In reply to a job's message (or in its thread), that job; otherwise the one
+// most recently stopped by a missing permission, or with `all`, every one.
+// `message` is the boss's own words from `/auto <words>` in a job's thread,
+// said in place of the stock line.
+function grantFromPhone(root, thread, message = '', all = false) {
+  const say = (line) => post('chief', line, { channel: GENERAL, thread });
+  if (root) {
+    const job = threadJob(root);
+    return void say(job ? grantJob(job, message) : 'That thread has no job of ours to grant full autonomy to.');
+  }
+  const blocked = blockedJobs();
+  if (!blocked.length) return void say('Nothing is blocked on a permission. To give a job full autonomy, reply /grant to one of its messages.');
+  const picked = all ? blocked : blocked.slice(0, 1);
+  const rest = blocked.slice(picked.length);
+  say([...picked.map((j) => grantJob(j)),
+    rest.length ? `Still blocked: ${rest.map((j) => `${nameOf(j.agentId)} on “${clip(j.title, 60)}”`).join('; ')}. Send /grant again for the next, or /grant all for every one.` : '',
+  ].filter(Boolean).join('\n'));
+}
+
+// Raises one job to Full autonomy, as the app's grant button does, and says how it went.
+function grantJob(job, message = '') {
+  const name = nameOf(job.agentId);
+  // A guest's clearance is capped by their link, and an away job's by its
+  // host; neither is the boss's to raise from here, nor from the app.
+  if (job.guest || job.away || job.remote) return `“${clip(job.title, 80)}” runs under someone else’s office, so its clearance isn’t yours to raise.`;
+  const was = job.mode;
+  job.mode = 'auto';
+  job.via = 'telegram';
+  addLog(job, { kind: 'system', summary: `Full autonomy granted from Telegram${was === 'auto' ? ' (it already had it)' : `, up from ${MODES[was]?.label || was}`}.` });
+  // A session already running keeps the permissions it started with: the
+  // grant counts from its next turn, which is how the app's picker works too.
+  if (job.status === 'working' || job.status === 'queued') {
+    pushJob(job);
+    if (message.trim()) { answered(job); deliver(job, withSource(message, 'telegram')); }
+    return `${name} has full autonomy on “${clip(job.title, 80)}” from their next turn; the one under way keeps the permissions it started with.`;
+  }
+  answered(job);
+  replyJob(job, { message: withSource(message.trim() || GRANTED, 'telegram'), mode: 'auto' });
+  return `${name} has full autonomy and is carrying on with “${clip(job.title, 80)}”.`;
+}
+
+function chat({ text, mode = 'edit', model = '', files, thread, channel, via }) {
   text = String(text || '').trim();
+  // Before post(): a bot token must never land in the chat.
+  if (via !== 'telegram' && /^\/telegram\b/i.test(text)) return void telegramCommand(text, channel);
   files = attachments(files);
   if (!text && !files.length) throw new Error('Say something first.');
   if (!MODES[mode]) throw new Error('Unknown mode.');
@@ -1803,6 +2128,7 @@ function chat({ text, mode = 'edit', model = '', files, thread, channel }) {
   const where = channelOf(root ? root.channel : channel);
   const msg = post('you', text, {
     channel: where,
+    ...(SOURCES[via] && { via }),
     ...(files.length && { files: files.map(({ path: _, ...f }) => f) }),
     ...(root && { thread: root.id }),
   });
@@ -1812,10 +2138,25 @@ function chat({ text, mode = 'edit', model = '', files, thread, channel }) {
     try { requestRestart({ now: !!restart[1] }); } catch (err) { post('chief', err.message, { channel: where }); }
     return;
   }
+  // The phone has no clearance picker, so it has words for it: `/grant` is the
+  // app's "Grant full autonomy and continue", and `/auto` in front of a request
+  // is the composer's picker set to Full autonomy.
+  if (via === 'telegram') {
+    const grant = !files.length && GRANT_WORDS.exec(text);
+    if (grant) return void grantFromPhone(root, root?.id || msg.id, '', !!grant[3]);
+    const auto = /^\/auto\b\s*/i.exec(text);
+    if (auto) {
+      mode = 'auto';
+      text = text.slice(auto[0].length);
+      const job = root && threadJob(root);
+      if (job) return void grantFromPhone(root, root.id, withFiles(text, files));
+      if (!text && !files.length) return void post('chief', 'Say what the job is after /auto, and it runs at full autonomy.', { channel: where, thread: root?.id || msg.id });
+    }
+  }
   if (!text) text = files.length === 1 ? 'Take a look at the attached file.' : 'Take a look at the attached files.';
   // A reply in a job's thread goes straight to that job; no routing needed.
   const job = root && threadJob(root);
-  if (job) { answered(job); return void deliver(job, withFiles(text, files)); }
+  if (job) { answered(job); if (SOURCES[via]) job.via = via; return void deliver(job, withSource(withFiles(text, files), via)); }
   const remoteJob = root && guests.threadJob(root.id);
   const say = (line, extra = {}) => post('chief', line, { channel: where, thread: root?.id || msg.id, ...extra });
   if (remoteJob) {
@@ -1853,7 +2194,7 @@ function chat({ text, mode = 'edit', model = '', files, thread, channel }) {
     return;
   }
   chiefQueue = chiefQueue
-    .then(() => dispatch(text, mode, model, files, root?.id || msg.id, !!root, where))
+    .then(() => dispatch(text, mode, model, files, root?.id || msg.id, !!root, where, via))
     .catch((err) => post('chief', `I couldn't route that one: ${err.message}`, { channel: where }));
 }
 
@@ -2133,8 +2474,10 @@ function officePrompt(agentId, job) {
     `Office tools: see colleagues, message them, hand off work, flag the boss, use channels. To show the boss an image or file (a screenshot, say), attach_files with absolute paths, then say it in your reply: it goes on your next message to them. Messages from colleagues arrive as user messages starting "Message from"; answer them with message_colleague. ` +
     `When your context has grown heavy and you are between steps, clear_context with notes to yourself lets you resume fresh and cheaper. ` +
     `Everyone shares one laptop. Before a heavy build or full test suite (Gradle, Xcode, an emulator, jest or vitest across a whole app, a docker build), call heavy_work start and wait your turn if told to; call heavy_work done the moment it ends. Run jest with --maxWorkers=2. Anything you leave running (dev servers, watchers, test copies of a server) is stopped when your job ends; if the boss needs one to stay up, keep_running it with its pid and say so in your reply. ` +
+    `When the boss asks for an app for the office, build it as one self-contained HTML file in a project (no network: inline scripts, styles and data) and register it with add_app so it gets an icon on the home screen. ` +
     `Your updates collect in your job's thread, which the boss may not open: use flag_for_boss when you need them (question, decision, blocker, review), not for routine progress. If you flag a question, decision or blocker, you are not done: say plainly in your reply that you are waiting on the boss, and do not present the work as finished. ` +
-    `This job is discussed in #${channelOf(job?.channel)}; everyday talk stays in #general.` + payNote(agentId) + standupBrief(agentId) + recentWork(agentId, job);
+    `This job is discussed in #${channelOf(job?.channel)}; everyday talk stays in #general. ` +
+    (SOURCES[job?.via] ? `${sourceNote(job.via)} Each message from the boss says where it came from; when they say "here" or ask for something to be sent, answer in that place: your replies and attach_files in this job's thread reach them there. If a later message comes from the other place, follow that one. ` : '') + payNote(agentId) + standupBrief(agentId) + recentWork(agentId, job);
 }
 
 // Only said when there is something to spend it on, so it costs nothing to
@@ -2259,11 +2602,11 @@ const agentApi = {
       : `Delivered to ${target.name}.`;
   },
 
-  attach_files(me, { paths }) {
+  async attach_files(me, { paths }) {
     if (!Array.isArray(paths) || !paths.length) throw new Error('Give the absolute paths of the files to attach.');
     const staged = (me.staged ||= []);
     if (staged.length + paths.length > MAX_ATTACH) throw new Error(`At most ${MAX_ATTACH} files go on one message.`);
-    for (const p of paths) staged.push(stageFile(p, me));
+    for (const p of paths) staged.push(await stageFile(p, me));
     return `${staged.length} file${staged.length === 1 ? '' : 's'} will go with your next message to the boss (your final reply, a flag, or a channel post). Nothing is sent yet.`;
   },
 
@@ -2353,6 +2696,12 @@ const agentApi = {
     return `${holder} is running (for ${minutesSince(heavy.since)}), and only one heavy run goes at a time. Do not start yours. Finish any light work, then end your turn: you will get a message when it is your turn.`;
   },
 
+  add_app(me, input) {
+    const { project, ...rest } = input || {};
+    const app = apps.add({ ...rest, repo: project }, nameOf(me.agentId));
+    return `${app.name} is on the home screen (id ${app.id}); the boss opens it from Apps. Registering the same id again updates it.`;
+  },
+
   async keep_running(me, { pid, why }) {
     pid = Number(pid);
     if (!Number.isInteger(pid) || pid < 2) throw new Error('Give the pid of the process to keep.');
@@ -2507,6 +2856,33 @@ const IMAGE_TYPES = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image
 // Audio plays in the chat bubble, so these are served inline like images.
 const AUDIO_TYPES = { '.webm': 'audio/webm', '.m4a': 'audio/mp4', '.mp4': 'audio/mp4', '.mp3': 'audio/mpeg', '.wav': 'audio/wav', '.ogg': 'audio/ogg', '.oga': 'audio/ogg', '.opus': 'audio/ogg', '.aac': 'audio/aac', '.flac': 'audio/flac' };
 const ext = (name) => path.extname(name).toLowerCase();
+
+// iPhone photos arrive as HEIC, which neither the Read tool nor most browsers
+// can open. They are converted to JPEG on the way in (sips ships with macOS;
+// ImageMagick or libheif's heif-convert stand in elsewhere). If nothing can
+// convert it, the original stays and goes by as a plain file.
+const HEIC = new Set(['.heic', '.heif']);
+function convertCommands(src, dst) {
+  return [
+    ['sips', ['-s', 'format', 'jpeg', '-s', 'formatOptions', '85', src, '--out', dst]],
+    ['magick', [src, '-auto-orient', '-quality', '85', dst]],
+    ['heif-convert', ['-q', '85', src, dst]],
+  ];
+}
+async function heicToJpeg(file) {
+  if (!HEIC.has(ext(file))) return file;
+  const dst = file.slice(0, -ext(file).length) + '.jpg';
+  for (const [cmd, args] of convertCommands(file, dst)) {
+    const ok = await new Promise((done) => execFile(cmd, args, { timeout: 60000 }, (err) => done(!err)));
+    if (ok && fs.existsSync(dst) && fs.statSync(dst).size > 0) {
+      fs.rmSync(file, { force: true });
+      fs.chmodSync(dst, 0o600);
+      return dst;
+    }
+    fs.rmSync(dst, { force: true });
+  }
+  return file;
+}
 const uploadDir = (id) => (typeof id === 'string' && /^[a-f0-9]{12}$/.test(id) ? path.join(UPLOADS, id) : null);
 
 function upload(req) {
@@ -2529,7 +2905,7 @@ function upload(req) {
     });
     req.on('error', fail);
     out.on('error', fail);
-    out.on('finish', () => resolve(attachments([id])[0]));
+    out.on('finish', () => heicToJpeg(file).then(() => resolve(attachments([id])[0]), fail));
     req.pipe(out);
   });
 }
@@ -2554,7 +2930,7 @@ function attachments(ids) {
 // Full autonomy that is its project's files, links resolved, never the office's
 // data, so attaching can't copy ~/.ssh/id_rsa where every agent can read it.
 const MAX_ATTACH = 6;
-function stageFile(file, job) {
+async function stageFile(file, job) {
   if (!path.isAbsolute(String(file || ''))) throw new Error(`${file}: use an absolute path.`);
   let src;
   try { src = fs.realpathSync(String(file)); } catch { throw new Error(`${file}: no such file.`); }
@@ -2572,6 +2948,7 @@ function stageFile(file, job) {
   const name = path.basename(src).replace(/[\x00-\x1f\/\\:*?"<>|]/g, '_').replace(/^\.+/, '').slice(0, 120) || 'file';
   fs.copyFileSync(src, path.join(dir, name));
   fs.chmodSync(path.join(dir, name), 0o600);
+  await heicToJpeg(path.join(dir, name));
   const { path: _, ...f } = attachments([id])[0];
   return f;
 }
@@ -2856,6 +3233,49 @@ const server = http.createServer(async (req, res) => {
         return json(res, err.code >= 400 && err.code < 600 ? err.code : 500, { error: err.message });
       }
     }
+    // A self-contained HTML page from a project, for the preview pane. It runs
+    // its own inline scripts and styles but sits in an opaque origin (sandbox,
+    // no allow-same-origin) with no network, so it can't touch the office.
+    if (req.method === 'GET' && url.pathname === '/api/files/page') {
+      const dir = repoPath(url.searchParams.get('repo'));
+      if (!dir) return json(res, 404, { error: 'Unknown project folder.' });
+      try {
+        const f = files.page(dir, url.searchParams.get('path') || '');
+        res.writeHead(200, {
+          'content-type': 'text/html; charset=utf-8', 'content-length': f.size, 'cache-control': 'no-store', 'x-content-type-options': 'nosniff',
+          'content-security-policy': "default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; img-src data: blob:; font-src data:; media-src data: blob:; sandbox allow-scripts",
+        });
+        return fs.createReadStream(f.abs).pipe(res);
+      } catch (err) {
+        return json(res, err.code >= 400 && err.code < 600 ? err.code : 500, { error: err.message });
+      }
+    }
+    // The home screen's apps: list them, add or update one, remove one, or
+    // put them in order (body: { order: [ids] }).
+    if (url.pathname === '/api/apps' && ['GET', 'POST', 'DELETE'].includes(req.method)) {
+      try {
+        if (req.method === 'POST') {
+          const body = await readBody(req);
+          if (Array.isArray(body?.order)) apps.reorder(body.order);
+          else return json(res, 200, { app: apps.add(body, 'boss'), apps: apps.list() });
+        }
+        if (req.method === 'DELETE') apps.remove(url.searchParams.get('id') || '');
+        return json(res, 200, { apps: apps.list() });
+      } catch (err) {
+        return json(res, err.code >= 400 && err.code < 600 ? err.code : 500, { error: err.message });
+      }
+    }
+    // An app's own saved data (web/src/apps.js passes the page's requests on).
+    if (url.pathname === '/api/apps/data' && ['GET', 'PUT'].includes(req.method)) {
+      try {
+        if (req.method === 'GET') return json(res, 200, { value: apps.readData(url.searchParams.get('id') || '') });
+        const body = await readBody(req, 1_100_000);
+        apps.writeData(body?.id || '', body?.value);
+        return json(res, 200, { ok: true });
+      } catch (err) {
+        return json(res, err.code >= 400 && err.code < 600 ? err.code : 500, { error: err.message });
+      }
+    }
     // The boss's own file editor: a project's folders and text files.
     if (url.pathname === '/api/files' && ['GET', 'PUT'].includes(req.method)) {
       const body = req.method === 'PUT' ? await readBody(req, 2 * files.MAX_BYTES) : null;
@@ -2869,6 +3289,10 @@ const server = http.createServer(async (req, res) => {
         return json(res, err.code >= 400 && err.code < 600 ? err.code : 500, { error: err.message });
       }
     }
+    // Folder completion for the chat box: what a half-typed path could become.
+    if (req.method === 'GET' && url.pathname === '/api/paths') {
+      return json(res, 200, { items: completePaths(url.searchParams.get('q') || '') });
+    }
     if (req.method === 'GET' && url.pathname === '/api/repos') return json(res, 200, { root: ROOT, repos: listRepos() });
     // A project's user journey map, and the job drawing it if one is under way.
     if (url.pathname === '/api/journeys' && ['GET', 'POST'].includes(req.method)) {
@@ -3086,7 +3510,7 @@ const server = http.createServer(async (req, res) => {
       react(parts[2], (await readBody(req)).emoji);
       return json(res, 200, { ok: true });
     }
-    if (req.method === 'POST' && url.pathname === '/api/chat') { chat(await readBody(req)); return json(res, 202, { ok: true }); }
+    if (req.method === 'POST' && url.pathname === '/api/chat') { chat({ ...(await readBody(req)), via: 'web' }); return json(res, 202, { ok: true }); }
     if (req.method === 'GET' && url.pathname === '/api/channels') return json(res, 200, { channels: state.channels });
     if (req.method === 'POST' && url.pathname === '/api/channels') {
       const { name, purpose } = await readBody(req);
@@ -3177,6 +3601,8 @@ const server = http.createServer(async (req, res) => {
         return json(res, 200, { diff: await fileDiff(cwd, job.changes, url.searchParams.get('path') || '') });
       }
       if (req.method === 'POST' && parts[3] === 'stop') { stopJob(job); return json(res, 200, { ok: true }); }
+      if (req.method === 'POST' && parts[3] === 'restart') { restartJob(job); return json(res, 200, { ok: true }); }
+      if (req.method === 'POST' && parts[3] === 'rescue') return json(res, 200, publicJob(rescueJob(job, await readBody(req)), 0));
       if (req.method === 'POST' && parts[3] === 'model') { setModel(job, (await readBody(req)).model); return json(res, 200, { ok: true }); }
       if (req.method === 'POST' && parts[3] === 'reply') { replyJob(job, await readBody(req)); return json(res, 200, { ok: true }); }
     }
@@ -3216,6 +3642,64 @@ server.on('error', (err) => {
   console.error(`Port ${PORT} is already in use. Start the office with another: agentstudio --port <n>, or PORT=<n>.`);
   process.exit(78);
 });
+// ---------- Telegram ----------
+//
+// The boss's own bot, for when they are away from the laptop: what they send
+// it goes into #general as if typed here, and what is said to them comes back.
+// See server/telegram.js for pairing and who may use it.
+
+// What reaches the phone: the chief's top-level notes in #general (finished
+// jobs, flags, the standup), and everything said in a thread the boss
+// started from Telegram. Not the break room, not agent-to-agent asides, and
+// not what the boss typed themselves.
+function relayToTelegram(msg) {
+  if (!telegram?.paired || msg.from === 'you' || msg.to || msg.kind === 'chill' || msg.kind === 'telegram' || msg.channel === CHILL) return;
+  const root = msg.thread && state.chat.find((m) => m.id === msg.thread);
+  const fromPhone = root?.via === 'telegram' || phoneThreads.has(msg.thread);
+  if (!fromPhone && !(msg.from === 'chief' && !msg.thread && msg.channel === GENERAL)) return;
+  // Read like a chat, not a log: the chief, who carries most of it and names
+  // whoever it is about, speaks unlabelled; an agent's name heads their
+  // message only when the speaker changes.
+  const named = msg.from !== 'chief' && msg.from !== lastPhoneSpeaker;
+  lastPhoneSpeaker = msg.from;
+  const head = named ? `${nameOf(msg.from)}:\n` : '';
+  const thread = msg.thread || msg.id;
+  const files = attachments((msg.files || []).map((x) => x.id));
+  // The app puts a grant button on a blocked job's message; the phone gets the word for it.
+  const blocked = (msg.denials?.length || msg.kind === 'finished') && state.jobs.find((j) => j.id === msg.jobId && j.denials?.length && !j.guest && !j.away);
+  const hint = blocked ? `\n\nBlocked from using ${blocked.denials.join(', ')}. Reply /grant to give ${nameOf(blocked.agentId)} full autonomy and let them carry on.` : '';
+  if (String(msg.text || '').trim()) telegram.send(`${head}${msg.text}${hint}`, thread);
+  // Attachments follow as photos, videos or files. Voice replies are added
+  // later and separately, so they never come through here.
+  files.forEach((f, i) => telegram.sendFile(f.path, { name: f.name, caption: !i && named && !String(msg.text || '').trim() ? nameOf(msg.from) : '', thread }));
+}
+
+// `/telegram <token>` connects a bot, `/telegram pair` gives a new pairing
+// code, `/telegram off` forgets the bot, `/telegram` says how it stands.
+// Answered in the office only, and never posted, so the token is kept out of
+// the chat.
+function telegramCommand(text, channel) {
+  const where = channelOf(channel);
+  const say = (line) => post('chief', line, { channel: where, kind: 'telegram' });
+  const arg = text.replace(/^\/telegram\b/i, '').trim();
+  const pairLine = (bot, code) => `Now open Telegram, find @${bot}, and send it:\n\n/pair ${code}\n\nThe code works once, for 15 minutes, and only in a private chat with the bot. Whoever sends it becomes the only account the bot will listen to.`;
+  if (/^off$/i.test(arg)) { telegram.disconnect(); return say('Telegram is off. The bot token and the paired account are forgotten; nothing reaches the bot any more.'); }
+  if (/^pair$/i.test(arg)) {
+    if (!telegram.status().on) return say('No bot yet. Send /telegram followed by the token @BotFather gave you.');
+    if (telegram.paired) return say('Already paired. To pair a different account, send /telegram off, then connect the bot again.');
+    return say(pairLine(telegram.bot || 'your bot', telegram.newPairing()));
+  }
+  if (!arg) {
+    const st = telegram.status();
+    return say(!st.on ? 'Telegram is off. Make a bot with @BotFather in Telegram, then send /telegram followed by its token.'
+      : st.paired ? `Telegram is on and paired${st.bot ? ` (@${st.bot})` : ''}.${st.error ? ` But: ${st.error}` : ''} /telegram off turns it off.`
+      : 'Telegram has a bot but is not paired yet. /telegram pair gives a code.');
+  }
+  telegram.connect(arg)
+    .then(({ bot, code }) => say(`Connected to @${bot}. ${pairLine(bot, code)}`))
+    .catch((err) => say(`Telegram didn't take that: ${err.message}`));
+}
+
 server.listen(PORT, LAN ? '0.0.0.0' : '127.0.0.1', () => {
   // The key is in this line on purpose: it's how the boss gets in. It only
   // goes to this terminal (or the supervisor's), never to a log file. The
@@ -3240,10 +3724,12 @@ server.listen(PORT, LAN ? '0.0.0.0' : '127.0.0.1', () => {
   refreshUsage();
   setInterval(standupDue, 60 * 1000);
   setTimeout(standupDue, 15 * 1000);
+  telegram.start();
 });
 
 function shutdown(code = 0) {
   tunnel.drop();
+  telegram.stop();
   for (const child of running.values()) child.kill('SIGTERM');
   clearTimeout(saveTimer);
   board.flush();