agent-office-studio 0.7.0 → 0.9.1

package/server/journeys.js

@@ -0,0 +1,101 @@
+// User journey maps, one per project: the routes a person takes through the
+// app, as steps and the arrows between them. An agent reads the project and
+// writes the map; the browser draws it as a flow canvas.
+//
+// Maps live in the office's data folder, not the project, so mapping never
+// leaves a file in someone's repo. Whatever the agent wrote is cut down to
+// the shape below before the browser sees it.
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const KINDS = ['entry', 'screen', 'action', 'decision', 'system', 'end'];
+const MAX_JOURNEYS = 24;
+const MAX_STEPS = 60;
+const MAX_EDGES = 120;
+const ID_RE = /^[A-Za-z0-9_.-]{1,48}$/;
+
+const text = (v, n) => (typeof v === 'string' ? v.trim().slice(0, n) : '');
+
+export class Journeys {
+  constructor(dataDir) {
+    this.dir = path.join(dataDir, 'journeys');
+  }
+
+  file(repo) {
+    return path.join(this.dir, `${repo}.json`);
+  }
+
+  ensureDir() {
+    fs.mkdirSync(this.dir, { recursive: true });
+    return this.dir;
+  }
+
+  read(repo) {
+    let raw;
+    try { raw = JSON.parse(fs.readFileSync(this.file(repo), 'utf8')); } catch { return null; }
+    let at = 0;
+    try { at = fs.statSync(this.file(repo)).mtimeMs; } catch {}
+    return clean(raw, at);
+  }
+
+  // What the mapping agent is told. It writes one file and touches nothing else.
+  brief(repo) {
+    const file = this.file(repo);
+    return [
+      `Map the user journeys of ${repo}.`,
+      '',
+      'Read the project to find every route a person takes through it: signing up, the main tasks, settings, payments, errors and dead ends. ' +
+      'Use the code (routes, screens, handlers, API calls) as the source of truth, not the README alone. Do not change any file in the project.',
+      '',
+      `Write the map as JSON to ${file} (create it, or replace the old one). That is the only file you write. Shape:`,
+      '',
+      '{ "summary": "one line on what the product is",',
+      '  "journeys": [ { "id": "signup", "name": "Sign up", "summary": "what the person is trying to do",',
+      '    "steps": [ { "id": "s1", "kind": "entry", "label": "Lands on home", "detail": "one or two lines", "where": "src/pages/Home.tsx" } ],',
+      '    "edges": [ { "from": "s1", "to": "s2", "label": "optional, e.g. \\"valid\\" or \\"no account\\"" } ] } ] }',
+      '',
+      `kind is one of: ${KINDS.join(', ')}. entry is where the journey starts; screen a page or view; action something the person does; ` +
+      'decision a branch (label its edges); system work the app does out of sight (an API call, an email, a job); end where the journey finishes, good or bad.',
+      'Keep labels short (under 40 characters). Ids are letters, digits, dashes. Order journeys by how often a person would take them. ' +
+      `At most ${MAX_JOURNEYS} journeys and ${MAX_STEPS} steps each. If the project has no user-facing flow (a library, a CLI), map how a developer uses it instead.`,
+      '',
+      'When the file is written, reply with one line per journey.',
+    ].join('\n');
+  }
+}
+
+// Only the shape the canvas draws gets through: known kinds, short strings,
+// edges between steps that exist.
+function clean(raw, at) {
+  if (!raw || !Array.isArray(raw.journeys)) return null;
+  const journeys = [];
+  for (const j of raw.journeys.slice(0, MAX_JOURNEYS)) {
+    if (!j || !Array.isArray(j.steps)) continue;
+    const steps = [];
+    const ids = new Set();
+    for (const s of j.steps.slice(0, MAX_STEPS)) {
+      const id = typeof s?.id === 'string' && ID_RE.test(s.id) ? s.id : null;
+      if (!id || ids.has(id)) continue;
+      ids.add(id);
+      steps.push({
+        id,
+        kind: KINDS.includes(s.kind) ? s.kind : 'screen',
+        label: text(s.label, 60) || id,
+        detail: text(s.detail, 400),
+        where: text(s.where, 200),
+      });
+    }
+    if (!steps.length) continue;
+    const edges = (Array.isArray(j.edges) ? j.edges : []).slice(0, MAX_EDGES)
+      .filter((e) => ids.has(e?.from) && ids.has(e?.to) && e.from !== e.to)
+      .map((e) => ({ from: e.from, to: e.to, label: text(e.label, 30) }));
+    journeys.push({
+      id: typeof j.id === 'string' && ID_RE.test(j.id) ? j.id : `j${journeys.length + 1}`,
+      name: text(j.name, 60) || `Journey ${journeys.length + 1}`,
+      summary: text(j.summary, 300),
+      steps, edges,
+    });
+  }
+  return { summary: text(raw.summary, 300), updatedAt: at, journeys };
+}

package/server/links.js

@@ -26,6 +26,9 @@ const MAX_AGENTS = 16;
 const STATES = new Set(['working', 'idle', 'break', 'meeting', 'away']);
 const CODE_RE = /^[0-9A-HJKMNP-TV-Z]{8}$/;
 const ID_RE = /^[A-Za-z0-9_-]{1,64}$/;
+// Ids key plain objects (saved guests, tokens used), so none may name their prototype.
+const NOT_IDS = new Set(['__proto__', 'constructor', 'prototype']);
+const isId = (v) => ID_RE.test(String(v ?? '')) && !NOT_IDS.has(String(v));
 const HEX_RE = /^#[0-9a-f]{6}$/i;
 const CLEARANCES = new Set(['plan', 'edit', 'auto']); // MODES in index.js: auto is Full autonomy
 
@@ -40,13 +43,13 @@ export function normaliseCode(code) {
 }
 
 function cleanLink(l) {
-  if (!l || !ID_RE.test(String(l.id))) return null;
+  if (!l || !isId(l.id)) return null;
   return {
     id: String(l.id),
     peer: text(l.peer, 20),
     kind: l.kind === 'guest' ? 'guest' : 'link',
     role: ['host', 'guest'].includes(l.role) ? l.role : 'peer',
-    invite: ID_RE.test(String(l.invite ?? '')) ? String(l.invite) : null,
+    invite: isId(l.invite) ? String(l.invite) : null,
     createdAt: Number.isFinite(l.createdAt) ? l.createdAt : null,
   };
 }
@@ -77,7 +80,11 @@ function cleanPolicy(guest) {
   const ourAgents = guest?.ourAgents !== false;
   const theirAgents = ['read', 'edit'].includes(guest?.theirAgents) ? guest.theirAgents : 'off';
   if (!ourAgents && theirAgents === 'off') throw fail(400, 'Let them use your agents, or let their agents work here, or both.');
-  return { repos, clearance, tokensPerDay, ourAgents, theirAgents };
+  // Which of our agents they may use. Absent (a guest made before this existed)
+  // means all of them.
+  const agents = ourAgents && Array.isArray(guest?.agents) ? [...new Set(guest.agents.map(String).filter((a) => ID_RE.test(a)))] : null;
+  if (agents && !agents.length) throw fail(400, 'Pick at least one of your agents to lend.');
+  return { repos, clearance, tokensPerDay, ourAgents, theirAgents, agents };
 }
 
 export class Links {
@@ -145,7 +152,7 @@ export class Links {
   // A guest link's limits, as the host set them. Null if this isn't one we host.
   guestPolicy(linkId) {
     const l = this.links.find((x) => x.id === linkId);
-    return l?.role === 'host' ? this.saved.guests[l.id] || null : null;
+    return l?.role === 'host' && Object.hasOwn(this.saved.guests, l.id) ? this.saved.guests[l.id] : null;
   }
 
   save() {

package/server/machine.js

@@ -0,0 +1,164 @@
+// Keeping the agents from sinking the machine they run on: how hard it is
+// swapping right now, and cleaning up what an agent left running.
+
+import os from 'node:os';
+import fs from 'node:fs';
+import { execFile } from 'node:child_process';
+import { ps, tree } from './procstat.js';
+
+// ---------- pressure ----------
+
+// Swap traffic is the signal that matters: "free memory" on macOS stays near
+// zero by design, and its memory level reads healthy while the disk thrashes.
+// Pages swapped in and out, as running totals.
+function swapPages() {
+  if (process.platform === 'linux') {
+    try {
+      const v = fs.readFileSync('/proc/vmstat', 'utf8');
+      const n = (k) => Number(v.match(new RegExp(`^${k} (\\d+)`, 'm'))?.[1] || 0);
+      return Promise.resolve({ pages: n('pswpin') + n('pswpout'), pageSize: 4096 });
+    } catch { return Promise.resolve(null); }
+  }
+  if (process.platform !== 'darwin') return Promise.resolve(null);
+  return new Promise((resolve) => {
+    execFile('/usr/bin/vm_stat', { timeout: 3000 }, (err, out) => {
+      if (err) return resolve(null);
+      const n = (k) => Number(out.match(new RegExp(`${k}:\\s+(\\d+)`))?.[1] || 0);
+      const pageSize = Number(out.match(/page size of (\d+)/)?.[1] || 16384);
+      resolve({ pages: n('Swapins') + n('Swapouts'), pageSize });
+    });
+  });
+}
+
+// Readings over the last minute or so; the rate is taken across all of them
+// so one burst doesn't hold the queue.
+const WINDOW_MS = 60_000;
+const readings = [];
+
+export async function samplePressure() {
+  const r = await swapPages();
+  if (!r) return;
+  const now = Date.now();
+  readings.push({ at: now, ...r });
+  while (readings.length > 2 && now - readings[1].at > WINDOW_MS) readings.shift();
+}
+
+// MB a second swapped over the window, or null with too little to go on.
+export function swapRate() {
+  if (readings.length < 2) return null;
+  const a = readings[0], b = readings[readings.length - 1];
+  const secs = (b.at - a.at) / 1000;
+  if (secs < 5 || b.pages < a.pages) return null;
+  return ((b.pages - a.pages) * b.pageSize) / secs / (1 << 20);
+}
+
+export function resetPressure() {
+  readings.length = 0;
+}
+
+// Above these the machine is thrashing: swap traffic of a size that stalls
+// everything, or three times more runnable work than there are cores.
+export const LIMITS = { swapMBs: 100, loadPerCore: 3 };
+
+// Why a new agent should not start now, in words for the boss, or null.
+export function overloaded() {
+  if (process.env.OFFICE_PRESSURE_CHECK === 'off') return null;
+  const swap = swapRate();
+  if (swap !== null && swap > LIMITS.swapMBs) return `the machine is swapping memory to disk (about ${Math.round(swap)} MB/s)`;
+  const cores = os.cpus().length;
+  const load = os.loadavg()[0];
+  if (load > cores * LIMITS.loadPerCore) return `the processor is overloaded (load ${load.toFixed(0)} on ${cores} cores)`;
+  return null;
+}
+
+// ---------- leftovers ----------
+
+// What each job's agent has started, from the process samples taken while it
+// works: jobId -> Map(pid -> { cmd, pgid }). Kept across the sessions of one
+// job (a cleared context or a model switch), so a dev server started before
+// the clear is still the job's.
+const started = new Map();
+// And the process groups they ran in: jobId -> Map(pgid -> leader as seen, or
+// null if it wasn't). Each command an
+// agent runs gets a group of its own, and whatever it puts in the background
+// stays in that group after the shell exits, so the group finds those too.
+const groups = new Map();
+
+export function remember(jobId, procs, root) {
+  let mine = started.get(jobId);
+  if (!mine) started.set(jobId, (mine = new Map()));
+  let gs = groups.get(jobId);
+  if (!gs) groups.set(jobId, (gs = new Map()));
+  // The agent's own group is the office's, which is nobody's to clean up.
+  const own = procs.find((p) => p.pid === root)?.pgid;
+  for (const p of procs) {
+    if (p.pid === root) continue;
+    if (!mine.has(p.pid)) mine.set(p.pid, { cmd: p.cmd, pgid: p.pgid, start: p.start });
+    if (p.pgid > 1 && p.pgid !== own && !gs.get(p.pgid)) gs.set(p.pgid, p.pid === p.pgid ? { cmd: p.cmd, start: p.start } : null);
+  }
+}
+
+// Whether a process is the job's: seen under it, or in a group it ran.
+export function startedByJob(jobId, p) {
+  if (started.get(jobId)?.get(p.pid)?.cmd === p.cmd) return true;
+  // A new group leader that merely reuses an old group's number is not.
+  return !!groups.get(jobId)?.has(p.pgid) && p.pid !== p.pgid;
+}
+
+export function forget(jobId) {
+  started.delete(jobId);
+  groups.delete(jobId);
+}
+
+const name = (cmd) => {
+  const words = String(cmd).split(/\s+/);
+  const bin = (words[0] || '').split('/').pop();
+  // "node .../vite" says less than "vite".
+  const script = /^(node|python\d?|ruby|sh|bash|zsh|npm|npx|pnpm|yarn|bun|deno)$/.test(bin) && words.slice(1).find((w) => w && !w.startsWith('-'));
+  return (script ? script.split('/').pop() : bin).slice(0, 40) || 'process';
+};
+
+// Daemons that any build or tool connects to, whoever started them. Stopping
+// one under another agent's running build fails that build, so they are only
+// stopped when nobody else is working.
+const SHARED = /GradleDaemon|KotlinCompileDaemon|GradleWrapperMain.*--daemon|\bwatchman\b|\badb\b.*(fork-server|server)/;
+
+// Stop whatever the job started that is still running, except what the agent
+// asked to keep and anything inside `live` (another agent's process tree).
+// A pid only counts if its command and start are the ones recorded, so a
+// reused pid is left alone. Returns the names of what was stopped.
+const same = (now, was) => !!now && !!was && now.cmd === was.cmd && (now.start == null || was.start == null || Math.abs(now.start - was.start) < 2000);
+export async function reap(jobId, { keep = [], live = [] } = {}) {
+  const mine = started.get(jobId);
+  const gs = groups.get(jobId) || new Map();
+  forget(jobId);
+  if (!mine?.size) return [];
+  const snap = await ps();
+  if (!snap) return [];
+  // Never the office itself or what runs it.
+  const spare = new Set();
+  for (let pid = process.pid; pid > 1 && !spare.has(pid); pid = snap.procs.get(pid)?.ppid) spare.add(pid);
+  for (const root of [...live, ...keep]) for (const p of tree(snap, root)) spare.add(p.pid);
+  const roots = [];
+  for (const [pid, was] of mine) if (same(snap.procs.get(pid), was)) roots.push(pid);
+  // A group's number can't be reused while anything is still in it, so one
+  // with no leader left is the job's. One with a leader is only if that
+  // leader is the one seen while the job worked, not a newcomer with its pid.
+  const ours = (g) => !snap.procs.has(g) || same(snap.procs.get(g), gs.get(g));
+  for (const p of snap.procs.values()) if (gs.has(p.pgid) && p.pid !== p.pgid && ours(p.pgid)) roots.push(p.pid);
+  const doomed = new Map();
+  for (const pid of roots) {
+    if (spare.has(pid)) continue;
+    for (const p of tree(snap, pid)) if (!spare.has(p.pid) && !(live.length && SHARED.test(p.cmd))) doomed.set(p.pid, p);
+  }
+  if (!doomed.size) return [];
+  for (const pid of doomed.keys()) try { process.kill(pid, 'SIGTERM'); } catch {}
+  // Whatever ignores a polite stop gets a firm one, if it is still the same process.
+  setTimeout(async () => {
+    const later = await ps();
+    for (const [pid, p] of doomed) if (same(later?.procs.get(pid), p)) try { process.kill(pid, 'SIGKILL'); } catch {}
+  }, 5000).unref();
+  return [...doomed.values()].map((p) => name(p.cmd));
+}
+
+export { name as procName };

package/server/office-mcp.js

@@ -35,6 +35,11 @@ const TOOLS = [
     description: 'Surface something in the main chat for the boss: a question, decision, blocker, or work ready to review. Not for routine progress. One or two self-contained sentences.',
     inputSchema: obj({ kind: { type: 'string', enum: ['question', 'decision', 'blocker', 'review'] }, summary: { type: 'string' } }, ['kind', 'summary']),
   },
+  {
+    name: 'attach_files',
+    description: 'Attach images or files (screenshots, say) to your next message to the boss: your final reply, a flag_for_boss, or a post_to_channel. Absolute paths, up to 6, 25 MB each. Nothing is sent by this call itself.',
+    inputSchema: obj({ paths: names }, ['paths']),
+  },
   {
     name: 'restart_office',
     description: 'Restart the office server so changes to its own code (agent-office/server) take effect. Waits until nobody is mid-turn, so end your turn right after; you are messaged when it is back. Not needed for web changes: a build is enough.',
@@ -45,6 +50,30 @@ const TOOLS = [
     description: 'Drop this session\'s history to cut token use, at a natural break between steps. Give notes to yourself: what is done, what is left, what you learned (files, decisions, gotchas). End your turn right after; you resume fresh from the brief and your notes. Not for the end of a job.',
     inputSchema: obj({ notes: { type: 'string' } }, ['notes']),
   },
+  {
+    name: 'heavy_work',
+    description: 'One heavy build or test run at a time on this shared laptop (Gradle, Xcode, emulator, jest or vitest across a whole app, docker build). start before it: you either get the slot or are told to end your turn and are messaged when it is yours. done straight after it ends, even if it failed.',
+    inputSchema: obj({ action: { type: 'string', enum: ['start', 'done'] }, what: { type: 'string', description: 'What you are running, like "the Android Gradle build"' } }, ['action']),
+  },
+  {
+    name: 'keep_running',
+    description: 'Keep a process you started (a dev server the boss needs to look at, say) running after this job ends; everything else you leave running is stopped then. The boss is told what was kept.',
+    inputSchema: obj({ pid: { type: 'number' }, why: { type: 'string' } }, ['pid', 'why']),
+  },
+  { name: 'office_shop', description: 'Your pay so far, how pay works, and what you can buy for your desk.', inputSchema: NONE },
+  {
+    name: 'buy_item',
+    description: 'Buy something for your own desk with your pay, by its id from office_shop. Only once your work is done or between steps; it is your money.',
+    inputSchema: obj({ item: { type: 'string' } }, ['item']),
+  },
+  { name: 'bets', description: 'Open and live bets between colleagues, your wallet, and the stake limits.', inputSchema: NONE },
+  {
+    name: 'place_bet',
+    description: 'Stake your own naira that a colleague\'s next job finishes in under N active minutes. Held until someone takes the other side; the winner gets both stakes. Not on your own job.',
+    inputSchema: obj({ on: { type: 'string', description: 'Colleague id or name' }, minutes: { type: 'number' }, stake: { type: 'number' } }, ['on', 'minutes', 'stake']),
+  },
+  { name: 'take_bet', description: 'Take the other side of an open bet (it takes N minutes or more) with a matching stake. Ids are in bets.', inputSchema: obj({ id: { type: 'string' } }, ['id']) },
+  { name: 'cancel_bet', description: 'Take back a bet you offered that nobody has taken; your stake comes back.', inputSchema: obj({ id: { type: 'string' } }, ['id']) },
   { name: 'list_channels', description: 'List chat channels: purpose, members, and which one your work is in.', inputSchema: NONE },
   {
     name: 'create_channel',

package/server/phone.js

@@ -0,0 +1,70 @@
+// The phone link: where a phone can reach this office, and a QR code for it.
+//
+// By default the office listens on 127.0.0.1 only, so there is nothing for a
+// phone to reach. Two ways in, both opt-in:
+//   - OFFICE_ALLOWED_HOSTS names a host that fronts the office (Tailscale);
+//     the link points at that name.
+//   - OFFICE_LAN=1 listens on the local network too, and the link points at
+//     this machine's private addresses. Plain http, so anyone else on that
+//     Wi-Fi who sees the key can open the office: home networks only.
+
+import os from 'node:os';
+import qrcode from 'qrcode-generator';
+
+// Private IPv4 addresses (10/8, 172.16/12, 192.168/16), the only ones we
+// would put a key behind. Link-local, CGNAT and public ones are skipped.
+export function lanAddresses(ifaces = os.networkInterfaces()) {
+  const out = [];
+  for (const list of Object.values(ifaces)) {
+    for (const a of list || []) {
+      if (a.family !== 'IPv4' || a.internal) continue;
+      const [p, q] = a.address.split('.').map(Number);
+      if (p === 10 || (p === 172 && q >= 16 && q <= 31) || (p === 192 && q === 168)) out.push(a.address);
+    }
+  }
+  return out;
+}
+
+// The links a phone could use, best first: named hosts over https, then LAN.
+export function phoneLinks({ key, port, lan, hosts = [], addresses = lanAddresses() }) {
+  const links = hosts
+    .filter((h) => !['localhost', '127.0.0.1', '[::1]'].includes(h))
+    .map((h) => ({ kind: 'host', label: h, url: `https://${h}/?key=${key}` }));
+  if (lan) for (const a of addresses) links.push({ kind: 'lan', label: `${a}:${port}`, url: `http://${a}:${port}/?key=${key}` });
+  return links;
+}
+
+const code = (text) => {
+  const qr = qrcode(0, 'M'); // type 0: smallest version that fits
+  qr.addData(text);
+  qr.make();
+  return qr;
+};
+
+// An SVG with a quiet zone, which scanners need. Dark on white whatever the
+// theme: they read contrast, not colours.
+export function qrSvg(text) {
+  const qr = code(text), n = qr.getModuleCount(), q = 4;
+  let d = '';
+  for (let r = 0; r < n; r++) for (let c = 0; c < n; c++) if (qr.isDark(r, c)) d += `M${c + q} ${r + q}h1v1h-1z`;
+  const s = n + q * 2;
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${s} ${s}" shape-rendering="crispEdges"><rect width="${s}" height="${s}" fill="#fff"/><path d="${d}" fill="#000"/></svg>`;
+}
+
+// Half-blocks for a terminal: two module rows per text row. Inverted (light
+// modules drawn as blocks) so it reads on a dark terminal, which is most.
+export function qrText(text) {
+  const qr = code(text), n = qr.getModuleCount(), q = 2;
+  const dark = (r, c) => r >= q && c >= q && r < n + q && c < n + q && qr.isDark(r - q, c - q);
+  const s = n + q * 2;
+  const rows = [];
+  for (let r = 0; r < s; r += 2) {
+    let line = '';
+    for (let c = 0; c < s; c++) {
+      const top = !dark(r, c), bottom = r + 1 < s ? !dark(r + 1, c) : true;
+      line += top && bottom ? '█' : top ? '▀' : bottom ? '▄' : ' ';
+    }
+    rows.push(line);
+  }
+  return rows.join('\n');
+}

package/server/procstat.js

@@ -14,26 +14,28 @@ function cpuSeconds(s) {
   return Number(days) * 86400 + rest.split(':').reduce((a, p) => a * 60 + parseFloat(p), 0);
 }
 
-function ps() {
+export function ps() {
   return new Promise((resolve) => {
-    execFile(PS, ['-axo', 'pid=,ppid=,rss=,cputime='], { timeout: 4000, maxBuffer: 8 << 20 }, (err, out) => {
+    execFile(PS, ['-axo', 'pid=,ppid=,pgid=,rss=,cputime=,etime=,command='], { timeout: 4000, maxBuffer: 16 << 20 }, (err, out) => {
       if (err) return resolve(null);
+      const at = Date.now();
       const procs = new Map();
       const kids = new Map();
       for (const line of out.split('\n')) {
-        const m = line.trim().match(/^(\d+)\s+(\d+)\s+(\d+)\s+(\S+)$/);
+        const m = line.trim().match(/^(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(\S+)\s*(.*)$/);
         if (!m) continue;
         const pid = Number(m[1]), ppid = Number(m[2]);
-        procs.set(pid, { pid, ppid, rss: Number(m[3]) * 1024, cpu: cpuSeconds(m[4]) });
+        // start: when it began, to the second, so a reused pid can be told apart.
+        procs.set(pid, { pid, ppid, pgid: Number(m[3]), rss: Number(m[4]) * 1024, cpu: cpuSeconds(m[5]), start: at - cpuSeconds(m[6]) * 1000, cmd: m[7] });
         if (!kids.has(ppid)) kids.set(ppid, []);
         kids.get(ppid).push(pid);
       }
-      resolve({ procs, kids, at: Date.now() });
+      resolve({ procs, kids, at });
     });
   });
 }
 
-function tree(snap, root) {
+export function tree(snap, root) {
   const out = [];
   const queue = [root];
   const seen = new Set();
@@ -78,6 +80,10 @@ export async function sampleProcs(roots) {
   return by;
 }
 
+// Every process under `root` as of the last sample, for remembering what an
+// agent started so it can be cleaned up once the agent is gone.
+export const lastTree = (root) => (prev ? tree(prev, root) : []);
+
 // Starting fresh after a quiet spell: the next sample has nothing to diff
 // against, so don't report a percentage for it.
 export function resetProcs() {

package/server/settings.js

@@ -14,11 +14,16 @@ export const SETTINGS = [
 
   { key: 'tokenLimit', group: 'Agents', label: 'Token limit', kind: 'number', min: 0, max: 10_000_000, step: 10000, unit: 'tokens', hint: 'Past this much context, an agent is nudged to clear it; if it does not, the office clears it. 0 turns this off.', fallback: () => Math.max(0, parseInt(env('AGENT_CLEAR_TOKENS') ?? '150000', 10) || 0) },
   { key: 'compactPct', group: 'Agents', label: 'Compact at', kind: 'number', min: 10, max: 95, step: 5, unit: '%', hint: 'How full an agent’s context gets before Claude Code compacts it. Applies to jobs that start after you save.', fallback: () => Math.min(95, Math.max(10, parseInt(env('AGENT_COMPACT_PCT') ?? '60', 10) || 60)) },
+  { key: 'maxAgents', group: 'Agents', label: 'Agents working at once', kind: 'number', min: 0, max: 50, step: 1, unit: 'agents', hint: 'More jobs than this wait in the queue, and you are told why. Jobs also wait while the machine is swapping or overloaded. 0 turns the limit off.', fallback: () => Math.max(0, parseInt(env('OFFICE_MAX_AGENTS') ?? '4', 10) || 0) },
   { key: 'chiefModel', group: 'Agents', label: 'Chief of staff model', kind: 'choice', options: ['haiku', 'sonnet', 'opus'], hint: 'Routes your messages and writes the standup.', fallback: () => env('CHIEF_MODEL') || 'sonnet' },
 
+  { key: 'payPerMinute', group: 'Pay', label: 'Pay per active minute', kind: 'number', min: 0, max: 1_000_000, step: 100, unit: 'naira', hint: 'What an agent earns for each minute the model was working, on Opus. Haiku pays 3×, Sonnet 1.75×. Applies to work paid from now on.', fallback: () => 1000 },
+  { key: 'payFinishBonus', group: 'Pay', label: 'Bonus for finishing a job', kind: 'number', min: 0, max: 1_000_000, step: 100, unit: 'naira', hint: 'Paid once when a job finishes, scaled by model like the minute rate. Kudos pays it again.', fallback: () => 2500 },
+
   { key: 'standupAt', group: 'Standup', label: 'Standup time', kind: 'time', hint: 'Local time, 24-hour. Blank turns the daily standup off.', fallback: () => (env('STANDUP_AT') ?? '09:30') === 'off' ? '' : (env('STANDUP_AT') ?? '09:30') },
   { key: 'standupWeekends', group: 'Standup', label: 'Hold standups on weekends', kind: 'bool', fallback: () => env('STANDUP_WEEKENDS') === '1' },
 
+  { key: 'breakRoom', group: 'Break room', label: 'Break-room chatter and pool', kind: 'bool', hint: 'Off: idle agents just wait, with no small talk or pool games, and nothing is posted to #chill-room.', fallback: () => env('BREAK_ROOM') === 'on' || env('BREAK_ROOM') === '1' },
   { key: 'banter', group: 'Break room', label: 'Written break-room talk', kind: 'bool', hint: 'Off: the break room uses canned lines only.', fallback: () => on(env('BANTER')) },
   { key: 'banterModel', group: 'Break room', label: 'Break-room model', kind: 'choice', options: ['haiku', 'sonnet', 'opus'], fallback: () => env('BANTER_MODEL') || 'haiku' },
   { key: 'banterGap', group: 'Break room', label: 'Time between conversations', kind: 'number', min: 10, max: 86400, step: 10, unit: 'seconds', hint: 'At most one written conversation per this long.', fallback: () => Math.max(10, Number(env('BANTER_GAP_SECONDS') ?? 120) || 120) },

package/server/talk.js

@@ -0,0 +1,51 @@
+// Click-an-agent chat. One short model call answers as that agent, from their
+// sheet, what they are doing right now and what has just been said, so a quick
+// "how's it going?" costs a fraction of a job. It cannot start work: anything
+// the boss wants built goes through the message box, and the agent says so.
+
+import { spawn } from 'node:child_process';
+
+const SCHEMA = {
+  type: 'object',
+  properties: { reply: { type: 'string' } },
+  required: ['reply'],
+  additionalProperties: false,
+};
+
+const SYSTEM = `You are one coworker in an office of coding agents, answering the boss, who just clicked on you to say something. You get your own sheet (role, personality, background, story, ties), what you are working on right now, and the last few lines of this chat.
+
+Rules:
+- Reply in character, in one to three short sentences, under 240 characters in total. Spoken out loud, so plain words.
+- Answer from the facts you were given. Never invent progress, files, results or numbers. If you were not told, say you would have to check.
+- This chat cannot start, change or stop work. If the boss asks for that, say to send it through the message box (or press N for a new job), warmly and briefly.
+- Let your story and ties colour the reply only sometimes. Never force a reference in.
+- Use real names for people. No markdown, emoji, quotation marks around the reply, or stage directions.`;
+
+export function writeReply(context, { bin = 'claude', model = 'haiku', timeoutMs = 20000, env = process.env } = {}) {
+  return new Promise((resolve, reject) => {
+    const args = [
+      '-p', '--model', model, '--output-format', 'json', '--json-schema', JSON.stringify(SCHEMA),
+      '--tools', '', '--setting-sources', '', '--strict-mcp-config', '--no-session-persistence',
+      '--system-prompt', SYSTEM,
+    ];
+    const child = spawn(bin, args, { env, stdio: ['pipe', 'pipe', 'pipe'] });
+    let out = '', err = '';
+    child.stdout.on('data', (d) => (out += d));
+    child.stderr.on('data', (d) => (err += d));
+    const timer = setTimeout(() => child.kill('SIGKILL'), timeoutMs);
+    child.on('error', (e) => { clearTimeout(timer); reject(e); });
+    child.on('close', () => {
+      clearTimeout(timer);
+      try {
+        const r = JSON.parse(out);
+        const { reply } = r.structured_output || JSON.parse(r.result);
+        const clean = String(reply).replace(/\s+/g, ' ').trim().slice(0, 300);
+        if (!clean) throw new Error('Empty.');
+        resolve({ reply: clean, cost: r.total_cost_usd || 0 });
+      } catch {
+        reject(new Error(err.trim().split('\n').pop() || 'They did not answer.'));
+      }
+    });
+    child.stdin.end(context);
+  });
+}