agent-office-studio 0.3.0 → 0.4.0

package/server/index.js

@@ -2,6 +2,7 @@ import http from 'node:http';
 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 { fileURLToPath, pathToFileURL } from 'node:url';
 import { WebSocketServer } from 'ws';
@@ -17,6 +18,7 @@ import { snapshotTree, summarize, fileDiff } from './changes.js';
 import { Auth } from './auth.js';
 import { Leaderboard } from './leaderboard.js';
 import { Links } from './links.js';
+import { Settings } from './settings.js';
 import { Guests } from './guests.js';
 
 const HERE = path.dirname(fileURLToPath(import.meta.url));
@@ -24,6 +26,7 @@ const APP = path.resolve(HERE, '..');
 const ROOT = path.resolve(process.env.OFFICE_ROOT || path.join(APP, '..'));
 const PORT = Number(process.env.PORT || 4317);
 const CLAUDE = process.env.CLAUDE_BIN || 'claude';
+// OFFICE_DATA is set by the agentoffice command; a clone keeps it beside the code.
 const DATA = path.resolve(process.env.OFFICE_DATA || path.join(APP, 'data'));
 const STATE_FILE = path.join(DATA, 'state.json');
 const DIST = path.join(APP, 'dist');
@@ -39,10 +42,6 @@ const board = new Leaderboard(DATA, { onChange: () => send({ t: 'leaderboard', l
 const MAX_UPLOAD = 25 * 1024 * 1024;
 const MAX_LOG = 600;
 const MAX_CHAT = 300;
-const CHIEF_MODEL = process.env.CHIEF_MODEL || 'sonnet';
-// The daily standup, local time; "off" turns it off. Weekdays unless STANDUP_WEEKENDS=1.
-const STANDUP_AT = process.env.STANDUP_AT ?? '09:30';
-const STANDUP_WEEKENDS = process.env.STANDUP_WEEKENDS === '1';
 // 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;
@@ -173,6 +172,12 @@ let state = { xp: 0, jobs: [], chat: [], channels: [], chiefCost: 0, dismissed:
 try {
   state = { ...state, ...JSON.parse(fs.readFileSync(STATE_FILE, 'utf8')) };
 } catch {}
+// What the boss sets on the Settings page, over the environment's defaults.
+// The context limit used to live at state.clearTokens.
+if (!state.settings || typeof state.settings !== 'object') state.settings = {};
+if (Number.isInteger(state.clearTokens) && !('tokenLimit' in state.settings)) state.settings.tokenLimit = state.clearTokens;
+delete state.clearTokens;
+const settings = new Settings(state.settings, () => save());
 if (!state.channels.some((c) => c.id === GENERAL)) state.channels.unshift({ id: GENERAL, name: GENERAL, createdAt: Date.now() });
 // Sat next to #general, and described even if someone had already opened a
 // channel by that name by hand. An explanation they wrote themselves stays.
@@ -242,7 +247,7 @@ for (const j of state.jobs) {
   if (j.status !== 'working') continue;
   if (j.sessionId) {
     Object.assign(j, {
-      status: 'queued', queuedAt: Date.now(), wantAgent: j.agentId, waiting: false,
+      status: 'queued', queuedAt: Date.now(), wantAgent: j.agentId, waiting: false, clearing: false,
       // An unread message stashed by deliver() comes along too, rather than
       // being written over by the notice about the restart.
       pending: [j.pending, 'The office restarted while you were working, which interrupted you. Pick up exactly where you left off.'].filter(Boolean).join('\n\n'),
@@ -286,7 +291,6 @@ const clients = new Set();
 // A job's title is the first line of its prompt, which can say more than the
 // boss means to share, so linked offices see only that an agent is busy.
 // OFFICE_SHARE_JOB_TITLES=1 sends the titles too.
-const SHARE_TITLES = process.env.OFFICE_SHARE_JOB_TITLES === '1';
 function presence() {
   return hired().map((s) => {
     const job = state.jobs.find((j) => j.agentId === s.id && j.status === 'working');
@@ -296,7 +300,7 @@ function presence() {
       : job ? 'working'
       : chill?.who.includes(s.id) ? 'break'
       : 'idle';
-    return { id: s.id, name: s.name, role: s.role, look: { shirt: s.shirt, hair: s.hair, skin: s.skin }, state: doing, job: job && SHARE_TITLES ? { title: job.title } : null };
+    return { id: s.id, name: s.name, role: s.role, look: { shirt: s.shirt, hair: s.hair, skin: s.skin }, state: doing, job: job && settings.get('shareTitles') ? { title: job.title } : null };
   });
 }
 // Set just below; anything broadcast before then has no guests to tell.
@@ -341,8 +345,20 @@ const publicJob = (j, tail = 40) => {
   const { stopRequested, lastTurn, sent, handoffs, ...rest } = j;
   return { ...rest, log: j.log.slice(-tail) };
 };
+// Whose office this is: the owner set in Settings (default OFFICE_OWNER), else the first name on this account.
+const ACCOUNT_NAME = (() => {
+  let full = '';
+  if (process.platform === 'darwin') full = spawnSync('/usr/bin/id', ['-F'], { encoding: 'utf8' }).stdout?.trim() || '';
+  return (full.split(/\s+/)[0] || os.userInfo().username || '').slice(0, 40);
+})();
+const owner = () => settings.get('owner') || ACCOUNT_NAME;
+function announceSettings() {
+  send({ t: 'settings', owner: owner(), settings: settings.status(), contextLimit: contextLimit() });
+}
 const snapshot = () => ({
   t: 'hello',
+  owner: owner(),
+  settings: settings.status(),
   staff: STAFF,
   modes: Object.fromEntries(Object.entries(MODES).map(([k, v]) => [k, v.label])),
   progress: progress(),
@@ -362,6 +378,7 @@ const snapshot = () => ({
   dismissed: state.dismissed,
   voice: voiceReady(DATA),
   tts: { ...piperReady(DATA), replies: voiceOn() },
+  contextLimit: contextLimit(),
 });
 
 // ---------- what the agents are costing this machine ----------
@@ -524,9 +541,7 @@ const endChill = (id) => { if (chill?.id === id) chill = null; };
 // The model writes the small talk, but not for every chat: at most one per
 // BANTER_GAP, and BANTER=off turns it off. Anything else, or any failure,
 // comes back with no script and the browser uses a canned chat instead.
-const BANTER_ON = process.env.BANTER !== 'off';
-const BANTER_GAP = Number(process.env.BANTER_GAP_SECONDS ?? 120) * 1000;
-const BANTER_MODEL = process.env.BANTER_MODEL || 'haiku';
+const BANTER_GAP = () => settings.get('banterGap') * 1000;
 let banterAt = 0;
 
 function banterContext(pair) {
@@ -545,16 +560,16 @@ async function claimBanter(pair, game = false) {
   const c = claimChill(pair, game);
   if (!c) return { id: null };
   if (game) return { id: c.id };
-  if (!BANTER_ON || Date.now() - banterAt < BANTER_GAP) return { id: c.id };
+  if (!settings.get('banter') || Date.now() - banterAt < BANTER_GAP()) return { id: c.id };
   banterAt = Date.now();
   try {
-    const { lines, cost } = await writeBanter(banterContext(pair), { bin: CLAUDE, model: BANTER_MODEL, env: auth.env() });
+    const { lines, cost } = await writeBanter(banterContext(pair), { bin: CLAUDE, model: settings.get('banterModel'), env: auth.env() });
     state.chiefCost += cost || 0;
     send({ t: 'chief', busy: false, cost: state.chiefCost });
     c.at = Date.now();
     return { id: c.id, script: lines };
   } catch {
-    banterAt = Date.now() - BANTER_GAP + 30 * 1000;
+    banterAt = Date.now() - BANTER_GAP() + 30 * 1000;
     return { id: c.id };
   }
 }
@@ -581,11 +596,24 @@ const waits = new Map();
 const REPLY_WAIT_MS = 10 * 60 * 1000;
 // Long-lived jobs get resumed on every reply and pay for the whole history each
 // turn, so agents auto-compact earlier than the default. AGENT_COMPACT_PCT to tune.
-const AUTOCOMPACT_PCT = process.env.AGENT_COMPACT_PCT || '60';
+// Past this many tokens of context, the next message an agent gets carries a
+// nudge to clear_context. 0 turns the nudge off. AGENT_CLEAR_TOKENS to tune.
+// The limit set in the office wins over the environment's, which is the default.
+const clearTokens = () => settings.get('tokenLimit');
+const contextLimit = () => { const t = settings.status().find((x) => x.key === 'tokenLimit'); return { tokens: t.value, default: t.default, custom: t.custom }; };
+// The nudge goes with a message the session is about to pay its whole history
+// to read, once per session, and never to a guest (who has no such tool).
+function withClearHint(job, text) {
+  const limit = clearTokens();
+  if (!limit || job.guest || job.hinted || !(job.context >= limit)) return text;
+  job.hinted = true;
+  const k = Math.round(job.context / 1000);
+  return `${text}\n\n(Office note: your context is at ${k}k tokens, and every turn pays for all of it. If you are between steps, call clear_context with notes to yourself now, then end your turn.)`;
+}
 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__restart_office', 'mcp__office__clear_context',
 ];
 // A guest's job can see who is in and ask the boss, nothing more: no
 // messaging colleagues, handing off or channels. Enforced again in agentApi,
@@ -671,7 +699,7 @@ function start(job, agentId) {
   args.push('--mcp-config', mcpFile, '--allowedTools', (job.guest ? GUEST_TOOLS : OFFICE_TOOLS).join(','), '--append-system-prompt', job.guest ? guestPrompt(agentId, job) : officePrompt(agentId, job));
   // Being given work in a channel is how you end up in it.
   try { joinChannel(channelOf(job.channel), agentId); } catch {}
-  const first = job.pending;
+  const first = job.sessionId ? withClearHint(job, job.pending) : job.pending;
 
   Object.assign(job, {
     status: 'working', agentId, pending: null, denials: [], error: null,
@@ -694,7 +722,7 @@ function start(job, agentId) {
   } catch (err) {
     return finish(job, 'failed', `Could not write the office tools' config: ${err.message}`);
   }
-  const child = spawn(CLAUDE, args, { cwd, env: { CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: AUTOCOMPACT_PCT, ...(job.guest ? { CLAUDE_CODE_DISABLE_AUTO_MEMORY: '1' } : {}), ...auth.env() }, stdio: ['pipe', 'pipe', 'pipe'] });
+  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);
   startProcs();
   child.stdin.on('error', () => {});
@@ -721,6 +749,7 @@ function start(job, agentId) {
     if (procs) { delete procs[job.id]; }
     endGrace(job);
     if (job.status !== 'working') return;
+    if (job.clearing && !job.stopRequested) return recycle(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);
@@ -729,6 +758,30 @@ function start(job, agentId) {
   child.on('close', (code) => ended(`claude exited with code ${code}`));
 }
 
+// Start a job over in a fresh session: the history is what costs tokens on
+// every turn, so the agent's own handoff note, the brief and anything that
+// arrived meanwhile are all the new session carries.
+function recycle(job) {
+  const note = job.clearNote;
+  const carried = job.context;
+  const wake = [
+    `Your original brief:\n${job.prompt}`,
+    `Your context has just been cleared (${(job.clears || 0) + 1} time${job.clears ? 's' : ''} on this job), ${job.clearedBy === 'boss' ? 'at the boss\'s request' : 'by you, to save tokens'}. Your notes:\n${note}`,
+    'The clear is DONE. If the brief or your notes only asked you to clear your context, that step is complete: do not call clear_context again, just confirm in one line that you are on a fresh context and finish. ' +
+      'The project still holds everything you changed. Check where the work stands, then carry on.',
+    job.pending,
+  ].filter(Boolean).join('\n\n');
+  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 });
+  job.clears = (job.clears || 0) + 1;
+  job.lastClear = { note, by: job.clearedBy || 'self', 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);
+  save();
+  setImmediate(pump);
+}
+
 function write(child, text) {
   if (!child.stdin.writable) return false;
   child.stdin.write(JSON.stringify({ type: 'user', message: { role: 'user', content: text } }) + '\n');
@@ -743,7 +796,7 @@ function deliver(job, text) {
     job.lastTurn = null;
     if (job.waiting) { job.waiting = false; pushJob(job); }
     addLog(job, { kind: 'user', summary: text });
-    if (child && write(child, text)) return 'live';
+    if (child && write(child, withClearHint(job, text))) return 'live';
     // The session ended between the check and the write, so there is nobody
     // to hand it to. Hold it for the next turn: passing it to replyJob would
     // only hand it straight back here, for as long as the stack allows.
@@ -773,6 +826,12 @@ function onLine(job, line) {
     job.sessionId = e.session_id;
     addLog(job, { kind: 'system', summary: `Clocked in · ${e.model}` });
   } else if (e.type === 'assistant') {
+    // Each assistant message carries the usage of one API call, whose input side
+    // is the real context size right now. (A subagent's calls are its own context.)
+    const au = e.message?.usage;
+    if (au && !e.parent_tool_use_id) {
+      job.context = (au.input_tokens || 0) + (au.cache_read_input_tokens || 0) + (au.cache_creation_input_tokens || 0);
+    }
     for (const c of e.message?.content || []) {
       if (c.type === 'text' && c.text.trim()) {
         addLog(job, { kind: 'text', summary: c.text.trim().slice(0, 6000) });
@@ -798,10 +857,10 @@ function onLine(job, line) {
   } else if (e.type === 'result') {
     job.cost += e.total_cost_usd || 0;
     job.turns++;
-    // The input side of the last turn is how much context this session is
-    // carrying. Worth seeing: a long-resumed job pays it on every turn.
+    // The result's usage is summed over every API call in the turn, so its cache
+    // reads count the whole history once per tool call: not the context size.
+    // job.context is kept from the last assistant message instead (see above).
     const u = e.usage || {};
-    job.context = (u.input_tokens || 0) + (u.cache_read_input_tokens || 0) + (u.cache_creation_input_tokens || 0);
     board.addTokens((u.input_tokens || 0) + (u.output_tokens || 0));
     guests.addTokens(job, (u.input_tokens || 0) + (u.output_tokens || 0));
     board.addTime(e.duration_ms);
@@ -811,6 +870,13 @@ function onLine(job, line) {
     addLog(job, { kind: 'result', ok, summary: String(e.result || e.subtype || '').trim().slice(0, 8000), cost: e.total_cost_usd, ms: e.duration_ms });
     job.lastTurn = { ok, error: ok ? null : `Ended with ${e.subtype}`, text: String(e.result || '').trim() };
     endGrace(job);
+    // The agent asked for a clean slate: close this session now, and ended()
+    // starts the job again without its history.
+    if (ok && job.clearNote && running.has(job.id)) {
+      job.clearing = true;
+      running.get(job.id).stdin.end();
+      return;
+    }
     const pending = waits.get(job.id) || [];
     if (ok && pending.length && running.has(job.id)) {
       // Keep the session open; whatever they're waiting for will wake it.
@@ -998,6 +1064,10 @@ function replyJob(job, { message, mode, files }) {
   if (!message) throw new Error('Say something first.');
   if (mode && !MODES[mode]) throw new Error('Unknown mode.');
   if (mode) job.mode = mode;
+  // A cleared session has no history, so what it was doing comes along with the reply.
+  if (!job.sessionId && job.lastClear) {
+    message = `Your context was cleared (${job.lastClear.by === 'boss' ? "at the boss's request" : 'by you'}). What you were on:\n${job.lastClear.note}\n\nOriginal brief:\n${job.prompt}\n\nNow: ${message}`;
+  }
   Object.assign(job, { status: 'queued', queuedAt: Date.now(), pending: message, error: null, endedAt: null, asking: null, awaitingBoss: false });
   addLog(job, { kind: 'user', summary: message });
   pushJob(job);
@@ -1028,6 +1098,51 @@ function dismiss(ids) {
   ].filter(Boolean).join(' ');
 }
 
+// The boss's own "clear context", with no job to hand out. A live session is
+// closed once its turn ends and restarted fresh by ended(); a finished job
+// just forgets its session so the next reply starts clean.
+// What an agent was up to, kept when a context is wiped so neither they nor
+// the boss are left guessing: their last report, or failing that the brief.
+function whereItStood(job) {
+  const lastReply = [...(job.log || [])].reverse().find((e) => e.kind === 'result' && e.summary)?.summary;
+  const said = (job.lastTurn?.text || lastReply || '').trim().slice(0, 2000);
+  const state_ = job.status === 'working' ? 'in progress' : job.awaitingBoss ? 'waiting on the boss' : job.status;
+  return `Job "${job.title}" in ${job.repo} (${state_}). ` + (said ? `Last report:\n${said}` : `No report yet; the brief was:\n${String(job.prompt || '').slice(0, 1000)}`);
+}
+
+function clearContext(ids) {
+  const cleared = [], none = [];
+  for (const id of ids) {
+    const s = hired().find((x) => x.id === id);
+    if (!s) continue;
+    const job = workingJobOf(id);
+    if (job) {
+      if (job.clearNote || job.clearing) { cleared.push(s.name); continue; }
+      job.clearNote = whereItStood(job);
+      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(); }
+      cleared.push(s.name);
+      continue;
+    }
+    const last = state.jobs.filter((j) => j.agentId === id && j.sessionId).sort((a, b) => (b.queuedAt || 0) - (a.queuedAt || 0))[0];
+    if (last) {
+      const note = whereItStood(last);
+      // Held for the next reply, which starts a fresh session, so it carries on knowing.
+      Object.assign(last, { sessionId: null, context: null, hinted: false, lastClear: { note, by: 'boss', at: Date.now() } });
+      addLog(last, { kind: 'system', summary: `Context cleared by the boss. Kept: ${note.slice(0, 300)}` });
+      pushJob(last);
+      cleared.push(s.name);
+    } else none.push(s.name);
+  }
+  save();
+  return [
+    cleared.length ? `Cleared context for ${names(cleared)}.` : 'Nobody had a context to clear.',
+    none.length ? `${names(none)} had nothing to clear.` : '',
+  ].filter(Boolean).join(' ');
+}
+
 function recall(ids) {
   const back = ids.filter((id) => state.dismissed.includes(id));
   if (!back.length) return 'Everyone you named is already in.';
@@ -1141,7 +1256,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, agent, repo, channel), { bin: CLAUDE, model: CHIEF_MODEL, images: shown, env: auth.env() });
+    d = await route(chiefContext(said, agent, repo, channel), { bin: CLAUDE, model: settings.get('chiefModel'), images: shown, env: auth.env() });
     state.chiefCost += d.cost || 0;
     nudgeUsage();
   } finally {
@@ -1181,6 +1296,10 @@ async function dispatch(text, mode, model, files, root, inThread, channel) {
     const ids = [...new Set([...(d.agentIds || []), ...(agent ? [agent.id] : [])])];
     return say(d.action === 'dismiss' ? dismiss(ids) : recall(ids));
   }
+  if (d.action === 'clear') {
+    const ids = [...new Set([...(d.agentIds || []), ...(agent ? [agent.id] : [])])];
+    return say(clearContext(ids.length ? ids : hired().map((x) => x.id)));
+  }
   if (d.action === 'standup') return void runStandup(true);
   // 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
@@ -1407,7 +1526,7 @@ async function runStandup(byBoss) {
   try {
     // A quiet office has nothing worth a model call. Otherwise it writes
     // while everyone walks over.
-    const writing = quiet ? null : writeStandup(context, { bin: CLAUDE, model: CHIEF_MODEL, env: auth.env() }).catch(() => null);
+    const writing = quiet ? null : writeStandup(context, { bin: CLAUDE, model: settings.get('chiefModel'), env: auth.env() }).catch(() => null);
     await sleep(GATHER_MS);
     const written = writing && (await writing);
     if (written) {
@@ -1439,8 +1558,9 @@ async function runStandup(byBoss) {
 // Checked every minute. Missed standups still happen later that day, but
 // not after 6pm, and a day with nothing to talk about is skipped.
 function standupDue() {
-  if (STANDUP_AT === 'off' || standupNow) return;
-  const due = dueToday(STANDUP_AT, STANDUP_WEEKENDS);
+  const at = settings.get('standupAt');
+  if (!at || standupNow) return;
+  const due = dueToday(at, settings.get('standupWeekends'));
   const now = Date.now();
   if (!due || now < due || (state.lastStandup || 0) >= due || new Date().getHours() >= 18) return;
   const since = state.lastStandup || now - DAY_MS;
@@ -1488,8 +1608,18 @@ function officePrompt(agentId, job) {
   const others = onFloor().filter((s) => s.id !== agentId).map((s) => (s.role ? `${s.name} (${s.role})` : s.name)).join(', ');
   return `You are ${me}, one of the agents in the Agent Office. Your colleagues: ${others || 'none yet'}. ` + persona(agentId) +
     `Office tools: see colleagues, message them, hand off work, flag the boss, use channels. 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. ` +
     `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.` + standupBrief(agentId);
+    `This job is discussed in #${channelOf(job?.channel)}; everyday talk stays in #general.` + standupBrief(agentId) + recentWork(agentId, job);
+}
+
+// Survives a cleared context: what this agent was last working on, so
+// "what were you doing?" has an answer even in a brand new session.
+function recentWork(agentId, job) {
+  const mine = state.jobs.filter((j) => j.agentId === agentId && j.id !== job?.id && j.lastClear)
+    .sort((a, b) => b.lastClear.at - a.lastClear.at).slice(0, 2);
+  if (!mine.length) return '';
+  return ' Before your context was last cleared you were on: ' + mine.map((j) => `[${j.id}] ${clip(j.lastClear.note, 600)}`).join(' | ');
 }
 
 // A guest's job: the agent works for someone from another office, so it is
@@ -1500,7 +1630,7 @@ function guestPrompt(agentId, job) {
     `Your only office tools are office_roster and flag_for_boss; the boss here is the host, not ${job.from}. Talk to ${job.from} in your replies.`;
 }
 
-const MAX_MESSAGES = 20, MAX_HANDOFFS = 5, MAX_DEPTH = 2, MAX_FLAGS = 5;
+const MAX_MESSAGES = 20, MAX_HANDOFFS = 5, MAX_DEPTH = 2, MAX_FLAGS = 5, MAX_CLEARS = 5;
 const FLAGS = { question: 'Question for you', decision: 'Needs your decision', blocker: 'Blocked', review: 'Ready for your review' };
 
 function caller(req) {
@@ -1602,6 +1732,14 @@ const agentApi = {
     return 'The chief has put it in front of the boss. Carry on, or wrap up this step if you cannot go further without them.';
   },
 
+  clear_context(me, { notes }) {
+    notes = String(notes || '').trim().slice(0, 4000);
+    if (!notes) throw new Error('Write the notes you will need: what is done, what is left, what you learned.');
+    if ((me.clears || 0) >= MAX_CLEARS) throw new Error("You've cleared your context several times on this job. Finish with what you have.");
+    me.clearNote = notes;
+    return 'Your context will clear when you end your turn. End it now: say nothing more of substance, your notes are what you resume with.';
+  },
+
   restart_office(me, { now = false } = {}) {
     requestRestart({ by: me.agentId, jobId: me.id, now: !!now });
     return 'The office will restart once everyone is between turns, and that includes you: end your turn now. ' +
@@ -2003,6 +2141,27 @@ const server = http.createServer(async (req, res) => {
       if (req.method !== 'GET') { send({ t: 'auth', auth: status }); refreshUsage(); }
       return json(res, 200, status);
     }
+    // The context limit: past it, an agent is nudged to clear_context. 0 turns
+    // the nudge off; null goes back to the AGENT_CLEAR_TOKENS default.
+    if (url.pathname === '/api/context-limit' && ['GET', 'POST'].includes(req.method)) {
+      if (req.method === 'POST') {
+        const { tokens } = await readBody(req);
+        if (tokens !== null && !(Number.isInteger(tokens) && tokens >= 0 && tokens <= 10_000_000)) return json(res, 400, { error: 'Use a whole number of tokens, or 0 to turn it off.' });
+        settings.set({ tokenLimit: tokens });
+        announceSettings();
+      }
+      return json(res, 200, contextLimit());
+    }
+    // The Settings page: every value, its default, and whether it is overridden.
+    // A POST of { key: value | null } saves them all or none; null is the default.
+    if (url.pathname === '/api/settings' && ['GET', 'POST'].includes(req.method)) {
+      if (req.method === 'POST') {
+        try { settings.set(await readBody(req)); }
+        catch (err) { return json(res, err.code || 400, { error: err.message }); }
+        announceSettings();
+      }
+      return json(res, 200, { owner: owner(), settings: settings.status() });
+    }
     // The leaderboard. Joining claims a handle with the service and starts
     // sharing day counters. Leaving deletes the counters; the handle goes too
     // unless linked offices still need it.

package/server/office-mcp.js

@@ -40,6 +40,11 @@ const TOOLS = [
     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.',
     inputSchema: obj({ now: { type: 'boolean', description: 'Skip the wait and interrupt anyone mid-turn. Only if asked to.' } }, []),
   },
+  {
+    name: 'clear_context',
+    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: 'list_channels', description: 'List chat channels: purpose, members, and which one your work is in.', inputSchema: NONE },
   {
     name: 'create_channel',

package/server/settings.js

@@ -0,0 +1,85 @@
+// The office's own settings: what the boss can change from the Settings page.
+// Each one has a default taken from the environment (or built in); a value set
+// in the office is kept in state.settings and wins over it. Clearing a value
+// goes back to the default. Anything not listed here stays environment-only.
+
+const env = (k) => process.env[k];
+const on = (v) => v !== 'off' && v !== '0' && v !== 'false';
+
+// kind: text | number | bool | choice | time. `live` settings take effect at
+// once; the rest are read when the thing they configure next starts.
+export const SETTINGS = [
+  { key: 'owner', group: 'Office', label: 'Office owner', kind: 'text', max: 40, hint: 'Whose office this is. It names the office in the header. Blank uses the name on this account.', fallback: () => String(env('OFFICE_OWNER') || '').trim() },
+  { key: 'shareTitles', group: 'Office', label: 'Share job titles with linked offices', kind: 'bool', hint: 'Off: linked offices only see that an agent is busy.', fallback: () => env('OFFICE_SHARE_JOB_TITLES') === '1' },
+
+  { 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 and start fresh. 0 turns the nudge 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: '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: '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: '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) },
+];
+
+const BY_KEY = new Map(SETTINGS.map((s) => [s.key, s]));
+
+// Returns the cleaned value, or throws with something the boss can act on.
+function clean(def, v) {
+  const bad = (m) => Object.assign(new Error(m), { code: 400 });
+  switch (def.kind) {
+    case 'text': {
+      if (typeof v !== 'string') throw bad(`${def.label}: use text.`);
+      v = v.trim().replace(/\s+/g, ' ');
+      if (v.length > def.max) throw bad(`${def.label} is limited to ${def.max} characters.`);
+      return v;
+    }
+    case 'bool':
+      if (typeof v !== 'boolean') throw bad(`${def.label}: use on or off.`);
+      return v;
+    case 'number':
+      if (!Number.isInteger(v) || v < def.min || v > def.max) throw bad(`${def.label}: use a whole number from ${def.min.toLocaleString()} to ${def.max.toLocaleString()}.`);
+      return v;
+    case 'choice':
+      if (!def.options.includes(v)) throw bad(`${def.label}: pick one of ${def.options.join(', ')}.`);
+      return v;
+    case 'time':
+      if (v !== '' && !/^([01]\d|2[0-3]):[0-5]\d$/.test(v)) throw bad(`${def.label}: use HH:MM, like 09:30, or leave it blank.`);
+      return v;
+  }
+}
+
+export class Settings {
+  // `store` is the object persisted with the office's state; `onChange` saves it.
+  constructor(store, onChange = () => {}) {
+    this.store = store;
+    this.onChange = onChange;
+  }
+
+  get(key) {
+    const def = BY_KEY.get(key);
+    return key in this.store ? this.store[key] : def.fallback();
+  }
+
+  // Apply { key: value | null }. All or nothing: one bad value saves none.
+  set(patch) {
+    if (!patch || typeof patch !== 'object' || Array.isArray(patch)) throw Object.assign(new Error('Nothing to save.'), { code: 400 });
+    const next = {};
+    for (const [key, v] of Object.entries(patch)) {
+      const def = BY_KEY.get(key);
+      if (!def) throw Object.assign(new Error(`Unknown setting: ${key}.`), { code: 400 });
+      next[key] = v === null ? null : clean(def, v);
+    }
+    for (const [key, v] of Object.entries(next)) {
+      if (v === null) delete this.store[key]; else this.store[key] = v;
+    }
+    this.onChange(Object.keys(next));
+    return this.status();
+  }
+
+  status() {
+    return SETTINGS.map(({ fallback, ...def }) => ({ ...def, value: this.get(def.key), default: fallback(), custom: def.key in this.store }));
+  }
+}

package/server/terminal.js

@@ -78,7 +78,7 @@ export class Terminals {
 
   async status() {
     if (!this.on) {
-      return { enabled: false, reason: 'The terminal is off. Start the office with OFFICE_TERMINAL=1 to open it.' };
+      return { enabled: false, reason: 'The terminal is off. Start the office with --terminal (or OFFICE_TERMINAL=1) to open it.' };
     }
     if (!(await loadPty())) return { enabled: false, reason: ptyError };
     let folders = [];