agent-office-studio 0.6.0 → 0.8.0

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/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,20 @@ 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: '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/settings.js

@@ -16,6 +16,9 @@ export const SETTINGS = [
   { 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: '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' },
 

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);
+  });
+}

package/server/tunnel.js

@@ -0,0 +1,136 @@
+// A public address for the office, so a phone can reach it from anywhere: a
+// Cloudflare quick tunnel. `cloudflared` dials out from this machine and gives
+// back a random https://….trycloudflare.com name that forwards to the office,
+// so nothing listens on the network and no router is touched. No account.
+//
+// It is only ever started by an explicit click, never at boot, and it dies
+// with the office. The address is new every time. Whoever has the link with
+// the key can run Claude here, so the key stays the one thing that matters.
+//
+// It is only called on once the address works from outside: a phone that
+// looks a name up too early caches "no such name" for minutes, and a tunnel
+// can connect yet route nowhere (see emptyConfig). Either way the phone would
+// show a blank page, so the QR waits.
+
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import https from 'node:https';
+import { Resolver } from 'node:dns/promises';
+
+// cloudflared reads ~/.cloudflared/config.yml even for a quick tunnel, and a
+// named tunnel's ingress there (ending, as they do, in http_status:404) then
+// answers every request to our address with an empty 404: a blank page on the
+// phone. So it gets a config of its own, with nothing in it.
+function emptyConfig() {
+  const file = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'office-tunnel-')), 'config.yml');
+  fs.writeFileSync(file, '');
+  return file;
+}
+
+// Does https://host/ reach this office from the internet? Looked up on public
+// resolvers, not this machine's, which may have cached the name as missing.
+// The office answers a keyless visit with 401, which Cloudflare never sends.
+const resolver = new Resolver({ timeout: 3000, tries: 1 });
+resolver.setServers(['1.1.1.1', '8.8.8.8']);
+export async function reachable(host) {
+  let ip;
+  try { [ip] = await resolver.resolve4(host); } catch { return false; }
+  if (!ip) return false;
+  return new Promise((resolve) => {
+    const req = https.get({ host: ip, servername: host, headers: { host }, path: '/', timeout: 8000 }, (res) => { res.resume(); resolve(res.statusCode === 401); });
+    req.on('timeout', () => req.destroy());
+    req.on('error', () => resolve(false));
+  });
+}
+
+const URL_RE = /https:\/\/([a-z0-9-]+\.trycloudflare\.com)/i;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+export class Tunnel {
+  // findBin() gives the cloudflared to run (it may download it, calling
+  // onStep('download')); allow(host) lets the office accept that Host and
+  // forget(host) takes it back; check(host) is the outside check.
+  constructor({ port, allow, forget, findBin, check = reachable, onChange = () => {} }) {
+    Object.assign(this, { port, allow, forget, findBin, check, onChange });
+    this.state = 'off'; // off | starting | on | error
+    this.step = null; // while starting: download | connect | check
+    this.host = null;
+    this.error = null;
+    this.child = null;
+    this.run = 0; // bumped by every start and stop, so a stale run stands down
+  }
+
+  status() {
+    return { state: this.state, step: this.state === 'starting' ? this.step : null, url: this.state === 'on' ? `https://${this.host}` : null, error: this.error };
+  }
+
+  set(state, extra = {}) {
+    Object.assign(this, { state, error: null, ...extra });
+    this.onChange(this.status());
+  }
+
+  start() {
+    if (this.state === 'starting' || this.state === 'on') return this.status();
+    const run = ++this.run;
+    this.set('starting', { host: null, step: 'connect' });
+    this.boot(run).catch((err) => { if (run === this.run) this.fail(err.message); });
+    return this.status();
+  }
+
+  async boot(run) {
+    const bin = await this.findBin((step) => { if (run === this.run) this.set('starting', { step }); });
+    if (run !== this.run) return;
+    this.set('starting', { step: 'connect' });
+    const host = await new Promise((resolve, reject) => {
+      const child = spawn(bin, ['tunnel', '--config', emptyConfig(), '--no-autoupdate', '--url', `http://127.0.0.1:${this.port}`], { stdio: ['ignore', 'ignore', 'pipe'] });
+      this.child = child;
+      let tail = '', name = null;
+      const timer = setTimeout(() => reject(new Error('Timed out waiting for Cloudflare. Check your connection and try again.')), 45000);
+      const done = (fn, v) => { clearTimeout(timer); fn(v); };
+      // The name is printed a second before the connection is up.
+      child.stderr.on('data', (d) => {
+        tail = (tail + d).slice(-4000);
+        const m = !name && URL_RE.exec(tail);
+        if (m && m[1] !== 'api.trycloudflare.com') name = m[1];
+        if (name && /Registered tunnel connection/.test(tail)) done(resolve, name);
+      });
+      child.on('error', (err) => done(reject, new Error(err.code === 'ENOENT' ? 'cloudflared couldn’t be started.' : err.message)));
+      child.on('exit', (code) => {
+        if (this.child !== child) return; // stopped on purpose
+        done(reject, new Error(this.state === 'on' ? 'The public address closed. Make a new one.' : `cloudflared stopped (${code}).`));
+        if (this.state === 'on' && run === this.run) this.fail('The public address closed. Make a new one.');
+      });
+    });
+    if (run !== this.run) return;
+    this.allow(host);
+    this.host = host;
+    this.set('starting', { step: 'check' });
+    for (const end = Date.now() + 90000; Date.now() < end; await sleep(2000)) {
+      if (run !== this.run) return;
+      if (await this.check(host)) { if (run === this.run) this.set('on', { host }); return; }
+    }
+    throw new Error('Cloudflare connected, but the address doesn’t reach this office from outside. Try again in a minute.');
+  }
+
+  fail(message) {
+    this.run++;
+    this.drop();
+    this.set('error', { error: message, host: null });
+  }
+
+  drop() {
+    const child = this.child;
+    this.child = null;
+    if (this.host) this.forget(this.host);
+    if (child) { try { child.kill('SIGTERM'); } catch {} }
+  }
+
+  stop() {
+    this.run++;
+    this.drop();
+    this.set('off', { host: null });
+    return this.status();
+  }
+}

package/shared/shop.js

@@ -0,0 +1,127 @@
+// What the office economy pays and sells.
+//
+// Shared by the server (which pays, charges and keeps the books) and the
+// browser (which shows the shop and draws what was bought), so a price or a
+// rate can never mean one thing in the ledger and another on screen.
+
+// Pay. An agent earns by the active minute (time the model was actually
+// working, not time spent waiting on the boss or a colleague) plus a bonus
+// for finishing, and both are scaled by the model that did the work: getting
+// a job done on a lighter model is worth more than brute-forcing it on the
+// heaviest. Only finished jobs pay. A failed or stopped job pays nothing.
+// All money is naira. perMinute and finishBonus are the defaults; the boss
+// sets them in Settings and setPay() applies them, in the server and, from
+// the economy status, in the browser.
+export const PAY = {
+  perMinute: 1000,
+  finishBonus: 2500,
+  // Minutes beyond this on one job are not paid: a job that drags on is not
+  // a job done better.
+  maxMinutes: 60,
+  // The office's cut of every naira an agent earns, for the boss to spend.
+  potShare: 0.4,
+  // A boss's "great work" on a finished job pays its finish bonus again.
+  kudosOncePerJob: true,
+};
+
+export const naira = (v) => `₦${Math.round(Number(v) || 0).toLocaleString('en-NG')}`;
+export function setPay(p = {}) {
+  for (const k of ['perMinute', 'finishBonus']) if (Number.isFinite(p[k]) && p[k] >= 0) PAY[k] = p[k];
+}
+
+export const MODEL_PAY = { haiku: 3, sonnet: 1.75, opus: 1 };
+export const modelTier = (model) => Object.keys(MODEL_PAY).find((t) => String(model || '').includes(t)) || '';
+export const modelPay = (model) => MODEL_PAY[modelTier(model)] || 1;
+
+// The cut, in whole naira. The agent's share is rounded down and the pot
+// takes the rest, so the two always add up to what was earned.
+export function split(gross) {
+  const g = Math.max(0, Math.round(gross));
+  const agent = Math.floor(g * (1 - PAY.potShare));
+  return { gross: g, agent, pot: g - agent };
+}
+
+// Everything for sale. `scope` says who owns it and where it goes:
+//   desk    on one agent's desk; an agent buys it with their own pay, or the
+//           boss buys it for them out of the pot
+//   office  somewhere in the room; bought out of the pot
+//   floor / wall  the room's finish; bought out of the pot, one in use at a time
+//   layout  a different floor plan; bought out of the pot, one in use at a time
+export const ITEMS = [
+  // desk
+  { id: 'mug', scope: 'desk', name: 'Coffee mug', price: 2000, icon: '☕' },
+  { id: 'duck', scope: 'desk', name: 'Rubber duck', price: 3000, icon: '🦆' },
+  { id: 'cactus', scope: 'desk', name: 'Cactus', price: 3500, icon: '🌵' },
+  { id: 'photo', scope: 'desk', name: 'Photo frame', price: 5000, icon: '🖼️' },
+  { id: 'lamp', scope: 'desk', name: 'Desk lamp', price: 6000, icon: '💡' },
+  { id: 'headphones', scope: 'desk', name: 'Headphones', price: 8000, icon: '🎧' },
+  { id: 'lava', scope: 'desk', name: 'Lava lamp', price: 9000, icon: '🫧' },
+  { id: 'bonsai', scope: 'desk', name: 'Bonsai', price: 12000, icon: '🌳' },
+  { id: 'keyboard', scope: 'desk', name: 'Mechanical keyboard', price: 14000, icon: '⌨️' },
+  { id: 'trophy', scope: 'desk', name: 'Little trophy', price: 15000, icon: '🏆' },
+  { id: 'monitor', scope: 'desk', name: 'Second monitor', price: 20000, icon: '🖥️' },
+  { id: 'chair', scope: 'desk', name: 'Gaming chair', price: 30000, icon: '💺' },
+  { id: 'cat', scope: 'desk', name: 'Desk cat', price: 40000, icon: '🐈' },
+  // office
+  { id: 'neon', scope: 'office', name: 'Neon sign', price: 50000, icon: '🔆' },
+  { id: 'vending', scope: 'office', name: 'Vending machine', price: 70000, icon: '🥤' },
+  { id: 'arcade', scope: 'office', name: 'Arcade cabinet', price: 80000, icon: '🕹️' },
+  { id: 'jukebox', scope: 'office', name: 'Jukebox', price: 90000, icon: '🎵' },
+  { id: 'aquarium', scope: 'office', name: 'Aquarium', price: 120000, icon: '🐠' },
+  { id: 'pingpong', scope: 'office', name: 'Ping-pong table', price: 150000, icon: '🏓' },
+  // floor and walls
+  { id: 'floor-oak', scope: 'floor', name: 'Oak floor', price: 0, color: '#ece3d4', icon: '🟫' },
+  { id: 'floor-walnut', scope: 'floor', name: 'Walnut floor', price: 40000, color: '#b48a63', icon: '🟫' },
+  { id: 'floor-terrazzo', scope: 'floor', name: 'Terrazzo', price: 40000, color: '#e6e1da', icon: '⬜' },
+  { id: 'floor-concrete', scope: 'floor', name: 'Polished concrete', price: 40000, color: '#c9c9c4', icon: '⬛' },
+  { id: 'wall-cream', scope: 'wall', name: 'Cream walls', price: 0, color: '#f5f0e8', icon: '🧱' },
+  { id: 'wall-sage', scope: 'wall', name: 'Sage walls', price: 35000, color: '#d6e2d0', icon: '🧱' },
+  { id: 'wall-navy', scope: 'wall', name: 'Navy walls', price: 35000, color: '#3d4f6e', icon: '🧱' },
+  { id: 'wall-blush', scope: 'wall', name: 'Blush walls', price: 35000, color: '#f1d9d2', icon: '🧱' },
+  // layouts
+  { id: 'layout-classic', scope: 'layout', name: 'Classic', price: 0, icon: '🏢', blurb: 'Two rows of desks, the library and server room on the back wall.' },
+  { id: 'layout-pods', scope: 'layout', name: 'Pods', price: 150000, icon: '🧩', blurb: 'Desks in two back-to-back clusters of four, a table and rug between them.' },
+  { id: 'layout-studio', scope: 'layout', name: 'Studio', price: 250000, icon: '🎨', blurb: 'One long row of desks along the back, the floor left open for the table and the pool.' },
+  { id: 'layout-campus', scope: 'layout', name: 'Campus', price: 400000, icon: '🏛️', blurb: 'Desks facing in round a courtyard, with the pool table at its heart.' },
+];
+
+export const itemById = (id) => ITEMS.find((i) => i.id === id);
+// What every office starts out owning and using.
+export const DEFAULTS = { floor: 'floor-oak', wall: 'wall-cream', layout: 'layout-classic' };
+// The scopes where one choice is in use at a time.
+export const SINGLE = new Set(['floor', 'wall', 'layout']);
+
+// Milestones. Each pays a one-off bonus, split like any pay.
+export const ACHIEVEMENTS = [
+  { id: 'first-job', name: 'First day', blurb: 'Finished a first job.', bonus: 2500, test: (s) => s.jobs >= 1 },
+  { id: 'ten-jobs', name: 'Regular', blurb: 'Finished 10 jobs.', bonus: 10000, test: (s) => s.jobs >= 10 },
+  { id: 'fifty-jobs', name: 'Veteran', blurb: 'Finished 50 jobs.', bonus: 40000, test: (s) => s.jobs >= 50 },
+  { id: 'haiku-hero', name: 'Haiku hero', blurb: 'Finished 5 jobs on Haiku.', bonus: 15000, test: (s) => (s.byTier.haiku || 0) >= 5 },
+  { id: 'lean', name: 'Lean machine', blurb: 'Finished a job on Haiku in under 2 active minutes.', bonus: 5000, test: (s, j) => j?.tier === 'haiku' && j.minutes < 2 },
+  { id: 'kudos', name: 'Great work', blurb: 'Got kudos from the boss.', bonus: 5000, test: (s) => s.kudos >= 1 },
+  { id: 'streak-3', name: 'On a roll', blurb: 'Finished jobs three days running.', bonus: 12000, test: (s) => s.streak >= 3 },
+  { id: 'big-earner', name: 'Big earner', blurb: 'Earned ₦200,000 in all.', bonus: 20000, test: (s) => s.earned >= 200000 },
+  { id: 'shopper', name: 'Treat yourself', blurb: 'Bought something for the desk.', bonus: 1500, test: (s) => s.bought >= 1 },
+];
+
+// Titles, from lifetime earnings. Shown on the name tag and in the chat.
+export const LEVELS = [
+  { at: 0, title: 'Intern' },
+  { at: 25000, title: 'Associate' },
+  { at: 100000, title: 'Specialist' },
+  { at: 300000, title: 'Senior' },
+  { at: 800000, title: 'Principal' },
+  { at: 2000000, title: 'Distinguished' },
+];
+export function levelOf(earned) {
+  let n = 0;
+  LEVELS.forEach((l, i) => { if ((Number(earned) || 0) >= l.at) n = i; });
+  return { n: n + 1, title: LEVELS[n].title, next: LEVELS[n + 1]?.at ?? null };
+}
+
+// A streak of working days lifts the wage (not the finish bonus).
+export const STREAK_BOOST = [{ days: 14, boost: 0.2 }, { days: 7, boost: 0.1 }, { days: 3, boost: 0.05 }];
+export const streakBoost = (days) => STREAK_BOOST.find((b) => days >= b.days)?.boost || 0;
+
+// What a boss may tip from the pot in one go.
+export const TIP = { min: 500, max: 50000, presets: [1000, 5000, 20000] };