coworking-agents 0.5.0 → 0.7.0

package/CHANGELOG.md

@@ -1,5 +1,74 @@
 # Changelog
 
+## 0.7.0 — 2026-10-13
+- Phone app, live: the office pushes every change as it happens (the 3-second poll only runs while the stream is down)
+- Phone app: tap an agent to see it in full: what it is asking or doing now, your last request, its last answer, what it did, the files it touched, helpers, model, context, cost (texts hidden in private mode)
+- Phone app: write to an agent that finished its turn, typed into its terminal (same rule as the office)
+- Phone app: see a task's changes (summary and coloured diff) before concluding
+- Menu bar (and Windows tray tip): the fullest token limit as a small bar next to the counts, so token use is visible at a glance
+- macOS notifications now come from a small hidden Coworking Agents app (the menu bar script compiled with osacompile, office icon, re-signed ad hoc), so they show its name and icon instead of Script Editor's
+- Phone tab bar sits lower, closer to the bottom edge
+- Phone app shell: the page no longer scrolls (only the middle does), so the header stays below the notch and the tab bar stays on the bottom on iPhone, even after the keyboard
+- Phone app in the office's own look: pixel font, pixel buttons and borders, each agent's face; the page names its files per run so a home-screen icon never keeps an old version
+- Phone app redone: tabs for Now (who needs you, every agent and what it is doing), Tasks (reply, allow, conclude, retry, cancel, and a new task in a folder already in use), Office (the live picture without names) and Usage (today, month, goal, limits); respects the notch and the home bar
+- New app icon: an agent at its desk with the laptop and the speech bubble
+- Create the app on this computer (free, no store, no signing): `coworking-agents install-app` or Personalise — a Coworking Agents app in Applications (macOS), the Start Menu and Desktop (Windows) or the applications menu (Linux); opening it starts the office if needed in an app window. `uninstall-app` removes it
+- The phone panel goes on the home screen like an app (iPhone and Android); its code is kept across restarts, and *Change the phone code* cuts every phone off
+- First run asks once: *Install as an app* (and optionally start with the computer) or *Keep the browser*; the answer decides how it opens from the terminal next time and can be changed in Personalise
+- Use it as an app, if you want: *Install as an app* (its own window and Dock/taskbar icon; nothing cached), `--app` for an app window of Chrome/Edge/Brave/Chromium, and *Start with the computer* (`coworking-agents autostart on|off`): hidden at login with the tray icon, through each system's own login entry, no shell. The browser keeps working as before
+- Tray icon on Windows (PowerShell + Windows Forms: red dot, menu, balloons) and Linux (zenity icon and tooltip, or notify-send notices); on macOS a red count, today's spend, limits, who is working and tasks asking permission; system notifications when nobody has the office open, outside quiet hours
+- macOS menu bar icon (Personalise or `--menubar`): how many are working and who needs you; clicking one opens the office on that agent; it goes away when the office closes. No dependency: the system's own JavaScript for Automation reads a private status file
+- Office events: confetti when a task's tests pass, a PR is opened or a week ends under the cost goal; rain inside the office when tests or a task fail (calmer with reduced motion)
+- Office mood: *stuck* when many agents wait on you or sit silent — the room turns grey-blue and the radio slows; a warm tone when everything flows
+- Files touched most (Repositories panel): the files agent sessions edited most over the last 7 days, by repo and AI (off in private mode)
+- Security: typing into Terminal re-checks, at that moment, that the agent still owns the tab (never into a bare shell); the heavy routes (search in logs, gh, cleanup) run one at a time
+- TV mode (☰ → 📺 or `?tv=1`): full screen with only the office and big counters; Esc leaves
+- Waiting on you today (daily report and the pasted summary): measured time the agents waited on your answers and office tasks stood blocked on you, with the longest waits
+- Budgets per day and per repository: once reached, new office tasks wait and running ones stop
+- Standing instructions per repository (Repositories panel): sent with every task the office creates there
+- GitHub through gh: turn an open issue into a task (title, text and link), and review a pull request by number with a read-only reviewer that gets the diff as data
+- Cleanup (Repositories panel): remove worktrees of finished tasks; uncommitted work is never removed and a branch is deleted only when merged or pushed
+- Permission rules: always deny anything containing a text (wins over everything) and always allow an exact command, with arguments but nothing chained; one click denies the usual dangerous ones
+- Secrets before commit: Ready to ship? scans the lines the task added and its new files for keys, tokens, private keys and credential files; the commit is blocked until you remove them or confirm (the value is never shown)
+- Visits (with `--phone`): a one-hour, LAN-only, read-only link that shows a picture of the office drawn without names plus how many are working; its own token, PNG-only frames, ended on demand
+- Sounds and do not disturb (Personalise tab): turn each sound on or off; a daily quiet window (may cross midnight) mutes sounds and system notifications while notices still land in the bell
+- Compare models: a table on your finished tasks per AI, model and effort with average cost, attempts, tests passing and how many ended well
+- Search what was said: the tasks search box also looks in what you asked and what Claude and Codex answered over the last 7 days (never tool output; off in private mode)
+- Message several agents (☰ → 📣): one request to the agents you pick; typed into terminal sessions that are waiting, continued in the background for VS Code and app conversations, busy ones left out
+- Repositories panel (☰ → 📦): who is in each repo now, what is not committed, to push or behind, worktrees, open tasks, PRs and today's activity
+- Batch: repeat a new task in other folders (one per line), one task each, every folder checked by the server
+- Schedules: run a saved template every day, on weekdays or on one weekday at a set time (while the office is open; catches up the same day)
+- Chains: a task set to *chain* starts as soon as the previous one ended well (no need to conclude it) and gets its result; a failed step stops the chain and says so
+- Security: a pentest sweep in the tests reads every route from server.js (cookie, custom header, foreign and look-alike origins, missing/foreign Host, path traversal, login redirect, security headers); XSS checks on every HTML builder; PR links only as https; importing a backup lists the templates' test commands before you accept
+
+## 0.6.0 — 2026-10-13
+- Tasks redesigned: list grouped by waiting on you / running / done with coloured state pills; detail with a clear header, alerts on top, result and review on the left, cost and model on the right, one primary action, quiet secondary ones and a red cancel, activity folded
+- Backup: export and import templates, queue and economy settings, cost goal, decor, outfits and progress as one JSON file (Personalise tab)
+- Achievements: First try (tasks done without a retry), Approved (reviews that said OK), Penny-wise (weeks under the cost goal)
+- Weekly card: best day, the AI used most and the week's cost; a notice on Sundays when it is ready
+- Ready to ship?: concluding a task first shows tests, review, files, what is not committed and the branch; commit with an editable message and open a PR with `gh`, only when you press it
+- Agents that say they are working but write nothing for 10 minutes get a notice
+- File clashes land in the notices, with a pause button when one side is an office task
+- Month's cost goal in Usage: spent so far, end-of-month projection, and a notice when the pace or the total goes over
+- Shop: beanie, bow, wizard hat, round glasses, mustache, green and blue shirts; bought outfits say *Wear* and open the wardrobe instead of *Move*
+- Phone panel (opt-in `--phone`): a small page on your Wi-Fi to see who needs you and answer permissions, replies and single-choice questions; its own restricted server and token, QR code in the terminal and in the office
+- Automatic review (opt-in): when a task finishes with changes, a read-only reviewer with the same AI reads the diff and its verdict shows on the original task
+- Task templates: save a request you repeat with its folder and settings; fill the form or create and run with one click
+- The new-task form stays open and keeps what you typed across the periodic refresh
+- Daily report to paste: cost of the day's sessions, what each agent did, what is still open (tasks and agents waiting on you), as Markdown or Slack markup
+- Limits: at the pace of the last hour, the office warns when a 5-hour or weekly window will run out before it resets; limit warnings also land in the 🔔 notices with a tip to make it last
+- Switch in the terminal: change the model and effort of a running Claude or Codex terminal session from the office (Claude `/model` + `/effort`; Codex picker, this session only); recommendation notices do it on Apply
+- Codex subagent cost counted from the subagents' own logs, once
+- Compact: shrink a task's or an outside conversation's context in the background (Claude `/compact`, Codex compaction), keeping the same session
+- Permissions mid-run: a task pauses when the agent wants a tool it may not use (Claude) or to leave its sandbox (Codex) and the office asks Allow / Always allow / Deny, on the card and as a notice
+- Codex tasks run through `codex app-server`, the mode where Codex can ask before leaving its sandbox; cost per model call, counted once
+- "Open the conversation" jumps to the exact conversation in VS Code, the Claude app or the Codex app
+- Sessions opened outside are watched while they run: when there is a real reason (stuck on one step, nearly full context, the kind of work) the office sends a notice with the recommended model and effort; Apply puts it in that agent's request box
+- Ask any Claude or Codex session from the office, even one opened in VS Code or the app: the request continues the same conversation with the model and effort you choose (the recommended ones come pre-picked)
+- Sessions opened outside show their real effort (Codex from its log, Claude from its settings)
+- Task detail shows current, pending and recommended config once, in the recommendation card
+- Update check every hour and when the releases tab opens
+
 ## 0.5.0 — 2026-10-11
 - Agent panel: tasks started by the office show running vs pending model and effort, cost and Save / More capacity / Apply recommendation; monitored sessions show the recommendation as not applied
 - Codex models and efforts come from Codex's own model list; Claude efforts low to max

package/README.md

@@ -180,16 +180,25 @@ Agents away from their desks (kitchen, meeting room, nap corner) carry a name ta
 
 ## Tasks: hand work to agents from the office
 
-Open **Tasks** and describe the work, pick a folder, an agent (Claude Code, Codex or *Automatic*), a profile and optionally a role (Backend, Frontend, Reviewer). The agent runs in the background (`claude -p` / `codex exec`), in its own git worktree if you tick it. You never need the terminal:
+Open **Tasks** and describe the work, pick a folder, an agent (Claude Code, Codex or *Automatic*), a profile and optionally a role (Backend, Frontend, Reviewer). The agent runs in the background (`claude -p` / `codex app-server`), in its own git worktree if you tick it. You never need the terminal:
 
-- **Answer** its questions and **approve** tools it was not allowed to use; it resumes the same session. **Retry**, start a **new session with a summary**, or **hand off** to the other agent with the decisions, tests and open items.
+- **Permissions mid-run:** when the agent wants a tool it may not use (Claude) or to step outside its sandbox (Codex), the run pauses and the office asks: *Allow*, *Always allow* (for that task) or *Deny*, on the card, in the task and as a 🔔 notice. **Answer** its questions; it resumes the same session. **Retry**, start a **new session with a summary**, or **hand off** to the other agent with the decisions, tests and open items.
 - **Review** everything since the task started: commits, staged and unstaged changes and new files, plus your test command's output (filtered to the failing lines and the tail).
+- **Automatic review** (opt-in in the settings): a task that finishes with changes gets a read-only reviewer with the same AI (Claude in plan mode, Codex in a read-only sandbox; edits are refused automatically); the verdict, problems with file:line and missing tests show on the original task.
+- **Ready to ship?** Concluding first lists tests, review verdict, files changed, what is not committed and the branch. *Commit* (editable message) and *Open PR* (pushes the branch and runs `gh pr create`, needs `gh auth login`) run only when you press them.
+- **Schedules, chains and batches:** run a saved template every day, on weekdays or on one weekday (while the office is open); *chain* a task so it starts when the previous one ended well and receives its result (a failure stops the chain); repeat a new task in several folders at once.
+- **Compare models** on your own finished tasks (cost, attempts, tests, ended well) and **search what was said**: the search box also looks in what you asked and what the agents answered over the last 7 days (never tool output, off in private mode).
+- **Safety nets:** *Ready to ship?* blocks a commit that carries keys, tokens, private keys or credential files until you remove them or confirm; standing **permission rules** answer on their own (deny anywhere always wins; allow only an exact command, nothing chained); budgets **per day and per repository** hold new tasks and stop running ones.
+- **GitHub (through your gh):** turn an open issue into a task, or review a pull request by number with a read-only reviewer that gets the diff as data.
+- **Per repository:** standing instructions sent with every task there, and a **cleanup** of finished tasks' worktrees that never removes uncommitted work or unmerged branches.
+- **Templates:** save a request you repeat (folder, agent, profile, role, test command) and fire it again with one click.
 - **Queue:** priority, "after task X" dependencies, how many agents run at once and how many attempts a task gets.
 - **Model and effort:** Claude `haiku`/`sonnet`/`opus` with efforts low → max; Codex models and efforts from Codex's own model list. *Save*, *More capacity*, *Apply recommendation* or pick by hand. A change made while a step runs is shown as **pending** and marked **applied** when the next step starts.
-- **Click the agent:** a session started by the office shows its task, running vs pending config, cost and the same controls. A session opened elsewhere is **monitored**: you see the recommendation, marked as not applied, and can turn it into a task.
-- **Cost:** per real model, tokens in/out/cache, attempts and subagents (Claude's totals include them; Codex's stream doesn't show them). Unknown prices show as unknown, never as zero. Ranking by AI, task and session for today / 7 / 30 days. A budget pauses the task; when the cost is unknown it says the budget can't be enforced, and a call already running may go slightly over.
+- **Click the agent:** a session started by the office shows its task, running vs pending config, cost and the same controls. A session opened elsewhere (terminal, VS Code extension, the Claude or Codex app) shows its real model and effort, the recommendation, and an **Ask this agent** box: the request continues that same conversation in the background (`claude -p --resume` / Codex `thread/resume`) with the model and effort you pick, and from then on it has the task controls. It waits while the agent is busy so two replies never mix; **Open the conversation** jumps straight to it in VS Code, the Claude app or the Codex app (reopen it there if it was already open). A session running in a terminal (Terminal, iTerm or tmux) also gets **Switch in the terminal**: the office types `/model` and `/effort` into Claude, or drives Codex's own `/model` picker choosing *this session only*, so Codex's saved default is untouched (Codex in macOS Terminal needs the Accessibility permission). While it runs the office keeps watching and, when there's a concrete reason (stuck on one step for 10+ min, context almost full, the work looks deeper or lighter than its setup), sends a notice with the recommendation: *Apply* picks it for the next request, *Not now* leaves it.
+- **Cost:** per real model, tokens in/out/cache, attempts and subagents (Claude's totals include them; Codex subagents are read from their own logs, which point at the parent conversation). Unknown prices show as unknown, never as zero. Ranking by AI, task and session for today / 7 / 30 days. A budget pauses the task; when the cost is unknown it says the budget can't be enforced, and a call already running may go slightly over.
 - **Recommendations:** local rules on scope, wording and attempts plus what similar finished tasks show (success with tests, cost, retries). No AI call to choose. Optional **auto-apply** up to a profile and a number of changes per task, all logged.
 - **Warnings:** the same action repeated without progress, two failed attempts, a run costing over 3× the median finished task, budget reached or unenforceable. Notices carry the exact proposal: *Apply*, *See why*, *Not now*.
+- **Compact:** shrinks the same session's context (Claude `/compact`, Codex compaction) without running anything else, for office tasks and for conversations opened in VS Code or the app once their context passes 50%.
 - **Economy mode:** short instructions on demand (read only what's needed, no long logs, no re-exploring), filtered logs, attempt and parallel limits, resume to keep the cache, or a fresh session with a summary when the context is too big.
 
 Tasks live in `~/.config/coworking-agents/tasks/`. In private mode names, folders, results, diffs and notice texts stay hidden.
@@ -198,6 +207,40 @@ Tasks live in `~/.config/coworking-agents/tasks/`. In private mode names, folder
 
 The 🔔 bell collects agent requests, task updates, recommendations (*Apply*, *See why*, *Not now*), cost alerts and new versions, grouped so repeats don't pile up. It keeps working with the tab in the background and recovers what was already pending when you open the office. **Releases** shows the installed version, the newest on npm (or *unavailable*), when it checked, a clickable map of every release and the notes of the newer one, with the update command for how you installed it. The office admin appears behind the top-bar counter only when there's version news: he waves the sign until you've seen it, keeps holding it until you update, then celebrates.
 
+## As an app (optional)
+
+The office works in any browser. If you prefer an app:
+
+- **Create the app** (Personalise, or `npx coworking-agents install-app`): a *Coworking Agents* app made on your computer — free, no store, no signing — in Applications (macOS), the Start Menu and Desktop (Windows) or the applications menu (Linux). Opening it starts the office if needed and shows it in an app window. `uninstall-app` removes it.
+- **On the phone:** with `--phone`, add the phone panel to the home screen (Safari → Share → Add to Home Screen; Chrome → Add to Home screen). It opens full screen on the same Wi-Fi; the code is kept, and *Change the phone code* cuts every phone off.
+- **Install as an app** (Personalise, or Chrome/Edge's install icon): its own window, no tabs, an icon in the Dock or taskbar. Nothing is cached; it is the same live office.
+- **`npx coworking-agents --app`** opens it in an app window of Chrome, Edge, Brave or Chromium without installing anything.
+- **Start with the computer:** `npx coworking-agents autostart on` (or the switch in Personalise) starts it hidden at login with the tray icon; `autostart off` undoes it. It uses each system's own login entry (macOS LaunchAgent, Windows Startup folder, Linux XDG autostart) with the program and its arguments, never a shell line.
+
+## More panels
+
+- **📦 Repositories:** who is in each repo now, what is not committed, to push or behind, worktrees, open tasks, PRs and today's activity.
+- **📣 Message several agents:** one request to the agents you pick, typed into terminal sessions that are waiting and continued in the background for VS Code and app conversations; busy ones are left out.
+- **Office events and mood:** confetti for tests passing, a PR opened or a week under the cost goal; rain when tests or a task fail; the room turns grey-blue when many agents are stuck on you and warm when everything flows.
+- **Files touched most** (Repositories): what agent sessions edited most this week.
+- **🖥 Tray icon** (Personalise or `--menubar`): how many are working, who needs you (red), a small bar with the fullest token limit (`●2 ▰▰▱▱▱ 41%`), today's spend, the limits, who is working on what and tasks asking permission; clicking opens the office on that agent or task, and it notifies you when nobody has the office open (outside quiet hours). macOS uses JavaScript for Automation, Windows uses PowerShell and Windows Forms, Linux uses `zenity` (icon and tooltip) or `notify-send` (notices only) — all part of the system or one package away. It reads a private status file the office writes and goes away when the office closes.
+- **📺 TV mode** (or `?tv=1`): full screen, only the office and big counters; Esc leaves.
+- **Waiting on you today** in the daily report: measured time the agents waited on your answers and tasks stood blocked on you.
+- **Sounds and do not disturb** (Personalise): each sound on or off, and a daily quiet window that mutes sounds and system notifications.
+
+## Phone panel (opt-in)
+
+`npx coworking-agents --phone` also serves a small app for your phone on the same Wi-Fi, in the office's pixel look, updated live as things change. Scan the QR code printed in the terminal or shown in ☰ → 📱 Phone, then add it to the home screen.
+
+- **Now:** who needs you and every agent with what it is doing.
+- **Tap an agent** to see it in full: what it asks or does right now, your last request, its last answer, what it did, the files it touched, its helpers, model, context and cost. When it finished its turn you can **write to it**; the text is typed into its terminal, like the office does (not into the Claude app or VS Code).
+- **Tasks:** answer permission questions (*Allow* / *Deny*), reply, conclude, retry or cancel, **see the changes** (summary and coloured diff) and start a new task in a folder already in use.
+- **Office:** a picture of the office drawn without names. **Usage:** today's and the month's spend and the limits.
+
+In private mode the phone shows no texts.
+
+It is a separate server that only answers on your LAN address, with its own token (kept so the home-screen icon keeps working; *Change the phone code* replaces it), an exact Host and Origin check, and only the phone's own routes: none of the office's files, launching or windows (a task's diff is the one thing it reads, and not in private mode). The office itself stays on `127.0.0.1`. The local network link is plain HTTP, so use it only on networks you trust. With the phone panel on, **👀 Visit** creates a one-hour, read-only link (its own token) that shows only a picture of the office drawn without names and how many are working; end it any time.
+
 ## MCP (read-only)
 
 `claude mcp add coworking -- npx coworking-agents mcp` gives other agents `list_agents`, `get_agent_status`, `get_conflicts`, `get_daily_report` and `list_tasks`. Nothing through MCP changes anything.

package/ROADMAP.md

@@ -26,8 +26,6 @@ Estimated cost · wait reminder · git state on the door · daily report as Mark
 - **Seasonal decor** by date (subtle, off with a toggle).
 
 ## Tasks — next steps
-- Mid-step permission prompts in the page (today denied tools are listed after the step; approving resumes with them allowed).
-- Compaction of a headless Claude session (`/compact` through `-p`) once it's confirmed to work; today the option is a fresh session with a summary.
-- Codex subagent usage (not in `codex exec --json`).
-- CI: left out on purpose for now (GitHub Actions removed); `npm test` runs before every commit.
+- Switching model and effort in VS Code and the desktop apps (only terminals take typing; there it applies from the next request sent from the office).
+- CI: left out for now; `npm test` runs before every commit.
 - Semantic search over history only if plain text search stops being enough; smarter automatic assignment.

package/bin/coworking-agents.js

@@ -12,11 +12,16 @@ const opt = (n, d) => { const i = args.indexOf(n); return i >= 0 && args[i + 1]
 if (flag('-h') || flag('--help')) {
   console.log(`coworking-agents — a pixel office for your AI coding agents (Claude Code, Codex, …)
 
-  npx coworking-agents [--port 4777] [--no-open] [--private]
+  npx coworking-agents [--port 4777] [--no-open] [--private] [--phone]
 
   --port      port to listen on (default 4777, falls back to a free one)
   --no-open   don't open the browser
   --private   hide session titles, paths and file names (screen sharing)
+  --app       open in an app window (Chrome, Edge, Brave or Chromium) instead of a browser tab
+  install-app       create the Coworking Agents app on this computer (uninstall-app removes it)
+  autostart on|off  start hidden with the computer, with the tray icon
+  --menubar   show a menu bar icon with who needs you (macOS; also a switch in Personalise)
+  --phone     also serve a small phone panel on your Wi-Fi (own token, QR code in the terminal; trusted networks only)
   --demo [N]  show a fake office with every state and N agents (default 10)
   --json      print one snapshot and exit
   mcp         run a read-only MCP server on stdio (claude mcp add coworking -- npx coworking-agents mcp)
@@ -25,6 +30,17 @@ if (flag('-h') || flag('--help')) {
 }
 
 if (args[0] === 'mcp') { require('../src/mcp').serve(); return; }
+// the app: `coworking-agents install-app` / `uninstall-app` (made on this computer, free, no store)
+if (args[0] === 'install-app') { const r = require('../src/appinstall').install(require('../src/update').installMode()); console.log(`Created: ${r.where}\nOpen "Coworking Agents" like any app. Remove it with: coworking-agents uninstall-app`); return; }
+if (args[0] === 'uninstall-app') { require('../src/appinstall').uninstall(); console.log('Removed the Coworking Agents app.'); return; }
+// start with the computer: `coworking-agents autostart on | off | status`
+if (args[0] === 'autostart') {
+  const a = require('../src/autostart');
+  if (args[1] === 'on') { const r = a.enable(require('../src/update').installMode()); console.log(`On: the office starts hidden at login, with its tray icon.\n${r.file}\nUndo with: coworking-agents autostart off`); }
+  else if (args[1] === 'off') { a.disable(); console.log('Off: the office no longer starts with the computer.'); }
+  else console.log(a.enabled() ? 'Autostart is on.' : 'Autostart is off. Turn it on with: coworking-agents autostart on');
+  return;
+}
 
 if (flag('--json')) {
   const { snapshot } = require('../src/collect');
@@ -33,11 +49,28 @@ if (flag('--json')) {
   return;
 }
 
+// the choice made in the office the first time ("use as an app" or "keep the browser") decides how it opens next time
+function wantsApp() {
+  if (flag('--app')) return true;
+  try { return JSON.parse(fs.readFileSync(path.join(os.homedir(), '.config', 'coworking-agents', 'tasks', 'tasks.json'), 'utf8')).settings.appChoice === 'app'; } catch { return false; }
+}
 function open(url) {
+  if (wantsApp() && openApp(url)) return;
   const cmd = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open';
   const a = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
   execFile(cmd, a, () => {});
 }
+// --app: an app window of Chrome, Edge, Brave or Chromium (no tabs, no address bar); the default browser otherwise
+function openApp(url) {
+  const fs = require('fs'), path = require('path'), { spawnSync, spawn } = require('child_process');
+  const pf = process.env.ProgramFiles || 'C:\\Program Files', pf86 = process.env['ProgramFiles(x86)'] || 'C:\\Program Files (x86)', local = process.env.LOCALAPPDATA || '';
+  const candidates = process.platform === 'darwin' ? ['Google Chrome', 'Microsoft Edge', 'Brave Browser', 'Chromium'].map(n => `/Applications/${n}.app/Contents/MacOS/${n}`)
+    : process.platform === 'win32' ? [path.join(pf, 'Google', 'Chrome', 'Application', 'chrome.exe'), path.join(pf86, 'Google', 'Chrome', 'Application', 'chrome.exe'), path.join(local, 'Google', 'Chrome', 'Application', 'chrome.exe'), path.join(pf86, 'Microsoft', 'Edge', 'Application', 'msedge.exe'), path.join(pf, 'Microsoft', 'Edge', 'Application', 'msedge.exe')]
+    : ['google-chrome', 'google-chrome-stable', 'chromium', 'chromium-browser', 'microsoft-edge', 'brave-browser'].map(n => { try { const r = spawnSync('which', [n], { encoding: 'utf8' }); return r.status === 0 ? r.stdout.trim() : ''; } catch { return ''; } });
+  const exe = candidates.find(c => c && fs.existsSync(c)); if (!exe) return false;
+  spawn(exe, ['--app=' + url], { detached: true, stdio: 'ignore' }).unref();
+  return true;
+}
 
 // The token link lives in a file only you can read (0600): a second run reopens the same
 // office, and a foreign program on port 4777 can't impersonate it (it doesn't have the token).
@@ -58,27 +91,36 @@ async function reuse() {
   const privacy = flag('--private'), demo = flag('--demo');
   if (!demo && !privacy && !flag('--port')) {
     const s = await reuse();
+    if (s && flag('--phone')) { console.log(`coworking-agents is already running without the phone panel (${s.base}). Close it (Ctrl+C in its terminal) and start again with --phone.`); return; }
     if (s) { console.log(`coworking-agents already running → ${s.base}/?t=${s.token}`); if (!flag('--no-open')) open(`${s.base}/?t=${s.token}`); return; }
   }
   // keep the same token across restarts so an open tab keeps working (file is 0600, only yours)
-  let token;
-  if (!demo && !privacy) { try { const prev = JSON.parse(fs.readFileSync(STATE_FILE, 'utf8')); if (/^[0-9a-f]{48}$/.test(prev.token)) token = prev.token; } catch {} }
+  let token, phoneToken;
+  if (!demo && !privacy) { try { const prev = JSON.parse(fs.readFileSync(STATE_FILE, 'utf8')); if (/^[0-9a-f]{48}$/.test(prev.token)) token = prev.token; if (/^[0-9a-f]{32}$/.test(prev.phoneToken || '')) phoneToken = prev.phoneToken; } catch {} }
+  // the phone code is kept with the office token (0600 file) so a home-screen icon keeps working; "new code" replaces it
+  const onPhoneToken = t => { phoneToken = t; try { const cur = JSON.parse(fs.readFileSync(STATE_FILE, 'utf8')); fs.writeFileSync(STATE_FILE, JSON.stringify({ ...cur, phoneToken: t }), { mode: 0o600 }); } catch {} };
   let hq;
-  try { hq = await start({ port, privacy, demo, token }); }
+  const phone = flag('--phone');
+  const menubar = flag('--menubar');
+  try { hq = await start({ port, privacy, demo, token, phone, menubar, phoneToken, onPhoneToken }); }
   catch (e) {
     if (e.code !== 'EADDRINUSE') throw e;
-    hq = await start({ port: 0, privacy, demo, token }); // port taken by something else: use a free one
+    hq = await start({ port: 0, privacy, demo, token, phone, menubar, phoneToken, onPhoneToken }); // port taken by something else: use a free one
   }
   if (!demo && !privacy) {
     try {
       fs.mkdirSync(STATE_DIR, { recursive: true, mode: 0o700 });
-      fs.writeFileSync(STATE_FILE, JSON.stringify({ pid: process.pid, base: hq.base, token: hq.token }), { mode: 0o600 });
+      fs.writeFileSync(STATE_FILE, JSON.stringify({ pid: process.pid, base: hq.base, token: hq.token, phoneToken: hq.phone ? hq.phone.url.split('t=')[1] : phoneToken }), { mode: 0o600 });
       // the file stays on exit: it keeps the token for the next run (reuse() pings before trusting it)
       const bye = () => process.exit(0);
       process.on('SIGINT', bye); process.on('SIGTERM', bye);
     } catch {}
   }
   console.log(`coworking-agents → ${hq.url}${privacy ? '  (private mode)' : ''}\nCtrl+C to close.`);
+  if (phone) {
+    if (hq.phone) console.log(`\nPhone (same Wi-Fi, trusted networks only — the LAN link is not encrypted) → ${hq.phone.url}\n${require('../src/qr').toTerminal(require('../src/qr').encode(hq.phone.url))}\n`);
+    else console.log(`\nPhone panel not started: ${hq.phoneReason === 'nolan' ? 'no local network address found' : hq.phoneReason}`);
+  }
   if (!flag('--no-open')) open(hq.url);
   if (!demo && !flag('--no-update-check')) {
     const up = await require('../src/update').startChecks();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coworking-agents",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "A pixel-art coworking office for your AI coding agents (Claude Code, Codex, …): see who's working, who needs you, and who's editing the same checkout.",
   "bin": {
     "coworking-agents": "bin/coworking-agents.js"

package/public/index.html

@@ -7,7 +7,9 @@
 <link rel="icon" href="favicon.ico?v=4" sizes="any">
 <link rel="icon" href="favicon.png?v=4" type="image/png" sizes="64x64">
 <link rel="icon" href="favicon.svg?v=4" type="image/svg+xml">
-<link rel="apple-touch-icon" href="apple-touch-icon.png?v=3">
+<link rel="apple-touch-icon" href="apple-touch-icon.png?v=4">
+<link rel="manifest" href="manifest.webmanifest">
+<meta name="theme-color" content="#17151a">
 <link rel="stylesheet" href="style.css">
 </head>
 <body>

package/public/js/achievements.js

@@ -60,6 +60,7 @@ function achFacts() {
     models: models.size,
     skills: Math.max(0, ...cred.map(c => (c.skills || []).length)), mcps: Math.max(0, ...cred.map(c => (c.mcps || []).length)),
     parallel: achCount('parallel'), aiKinds: achCount('aiKinds'), pets: achCount('pets'), zeroQueue: achCount('zeroQueue'),
+    cleanTasks: achCount('cleanTasks'), reviewOk: achCount('reviewOk'), underGoal: achCount('underGoal'),
     clashes: achCount('clashes'), team: achCount('team'), bigCtx: achCount('bigCtx'), files: achCount('files'), sessionTools: achCount('sessionTools'),
     fast: achCount('fast'), patience: achCount('patience'), compacts: achCount('compacts'), focusDone: achCount('focusDone'),
     replay: achCount('replay'), avatars: achCount('avatars'), lights: achCount('lights'), weatherDays: achCount('weatherDays'),
@@ -110,6 +111,9 @@ const ACH = [
   { id: 'writer', g: 'live', icon: '📄', fact: 'files', steps: [5, 15, 30, 60, 100] },
   { id: 'workaholic', g: 'live', icon: '⚙', fact: 'sessionTools', steps: [200, 500, 1000, 2000, 4000] },
   { id: 'bump', g: 'live', icon: '💥', fact: 'clashes', steps: [1, 5, 20, 50, 100] },
+  { id: 'cleanrun', g: 'live', icon: '🎯', fact: 'cleanTasks', steps: [10, 25, 50, 100, 250] },
+  { id: 'approved', g: 'live', icon: '🔎', fact: 'reviewOk', steps: [1, 5, 20, 50, 100] },
+  { id: 'thrifty', g: 'live', icon: '🐷', fact: 'underGoal', steps: [1, 4, 12, 26, 52] },
   { id: 'fast', g: 'live', icon: '🏃', fact: 'fast', steps: [1, 10, 50, 200, 500] },
   { id: 'patience', g: 'live', icon: '🗿', fact: 'patience', steps: [1, 5, 15, 40, 100] },
   { id: 'inbox', g: 'live', icon: '✓', fact: 'zeroQueue', steps: [1, 10, 50, 150, 500] },
@@ -202,7 +206,22 @@ function checkAchievements() {
   }
   for (const p of live) if (p.repo) { achAdd('repos', p.repo.name); if (p.branch && p.branch !== 'HEAD') achAdd('branches', p.repo.name + ':' + p.branch); }
   { const clean = trees.size >= 3 && [...trees.values()].every(g => g.dirty === 0); if (clean && !achClean) achBump('cleanDesk'); achClean = clean; }
+  // Sunday: the week's card is ready (once a week)
+  if (new Date().getDay() === 0 && usageData && usageData.days && typeof pushNotice === 'function' && store.get('weekCardSaid', '') !== weekKey()) {
+    store.set('weekCardSaid', weekKey()); pushNotice('week:' + weekKey(), 'ok', T.share.ready, T.share.readyWhy, { tab: 'paper' });
+  }
   for (const c of data.fileClashes || []) achAdd('clashes', c.file + '|' + c.who.slice().sort().join(','));
+  // office tasks: done on the first attempt, a review that said OK, and weeks spent under the month's cost goal
+  for (const t of (typeof taskData !== 'undefined' && taskData.tasks) || []) {
+    if (t.state === 'done' && t.attempts === 1) achAdd('cleanTasks', t.id);
+    if (t.review && /^\s*OK\b/i.test(t.review.text || '')) achAdd('reviewOk', t.id);
+  }
+  { const goal = Number(((typeof taskData !== 'undefined' && taskData.settings) || {}).monthGoal) || 0, days = (usageData && usageData.days) || {};
+    if (goal) {
+      const keys = Array.from({ length: 7 }, (_, i) => { const d = new Date(Date.now() - (i + 1) * 864e5); return d.getFullYear() + '-' + String(d.getMonth() + 1).padStart(2, '0') + '-' + String(d.getDate()).padStart(2, '0'); });
+      const worked = keys.filter(k => days[k] && days[k].tools >= 10).length, spent = keys.reduce((n, k) => n + ((days[k] && days[k].usd) || 0), 0);
+      if (worked >= 3 && spent <= goal * 7 / 30) { const n0 = achCount('underGoal'); achAdd('underGoal', keys[keys.length - 1]); if (achCount('underGoal') > n0) confettiAt = Date.now(); } // one per finished 7-day window, celebrated
+    } }
   const need = live.filter(p => p.state === 'needs_you' || p.state === 'waiting').length;
   if (achQueueWas >= 2 && need === 0) achBump('zeroQueue');
   achQueueWas = need;
@@ -286,8 +305,20 @@ const shadeHex = (hex, f) => Art.shade(hex, f);
     if (at === seq.length) { at = 0; achBump('konami'); confettiAt = Date.now(); checkAchievements(); }
   });
 }
-// confetti over the office (konami, or any legend-tier unlock)
-let confettiAt = 0;
+// confetti over the office (konami, any legend-tier unlock, tests passing, a PR opened, a week under the cost goal)
+let confettiAt = 0, officeRainAt = 0;
+const reducedMotion = () => { try { return matchMedia('(prefers-reduced-motion: reduce)').matches; } catch { return false; } };
+// rain inside the office when tests fail or a task fails: a grey cloud and drops for a few seconds
+function drawOfficeRain(t) {
+  const age = Date.now() - officeRainAt; if (age > 4500) return;
+  const fade = age < 400 ? age / 400 : age > 3800 ? (4500 - age) / 700 : 1;
+  ctx.fillStyle = `rgba(30, 40, 60, ${(.32 * fade).toFixed(3)})`; ctx.fillRect(0, 0, W, H);
+  if (reducedMotion()) return;
+  for (let i = 0; i < 120; i++) {
+    const h = Art.hash('rn' + i), x = (h % W) + (age / 25) % 8, y = ((h >>> 8) % H + age / 1000 * (260 + (h >>> 16) % 160)) % H;
+    r(x, y, 1, 6, `rgba(170, 210, 255, ${(.8 * fade).toFixed(3)})`);
+  }
+}
 function drawConfetti(t) {
   const age = Date.now() - confettiAt;
   if (age > 4000) return;

package/public/js/alerts.js

@@ -1,7 +1,8 @@
 'use strict';
 // ---------------- alerts: rate limits filling up, contexts close to compaction, and the compact action ----------------
 const CTX_WARN = .75;               // from here a "compact" button shows over the agent
-const LIMIT_STEPS = [80, 95];       // notify once per window when usage crosses these
+const LIMIT_STEPS = [80, 95];
+const STALL_MS = 10 * 60000;   // working, but nothing new in its log for this long       // notify once per window when usage crosses these
 const WAIT_NUDGE = 5 * 60000;       // an agent waiting on you this long gets one reminder
 const waitStart = new Map();        // id → { state, at }: when it started waiting
 const alerted = new Set();
@@ -22,6 +23,7 @@ function toast(html, kind) {
   setTimeout(() => { el.classList.add('out'); setTimeout(() => el.remove(), 300); }, 7000);
 }
 function notifyOS(title, body) {
+  if (typeof quietNow === 'function' && quietNow()) return; // do not disturb
   playTune('limit');
   if (notifyOn && !focusing() && 'Notification' in window && Notification.permission === 'granted' && document.hidden) { try { new Notification(title, { body }); } catch {} }
 }
@@ -36,11 +38,29 @@ function checkAlerts() {
         const key = `lim:${id}:${win}:${step}:${w.resetsAt}`;
         if (w.usedPercent >= step && !alerted.has(key)) {
           alerted.add(key);
+          if (typeof pushNotice === 'function') { const label = `${(AGENT[id] || {}).label || id} · ${win === '5h' ? T.usage.fiveHour : T.usage.week}`; pushNotice(`lim:${id}:${win}`, step >= 95 ? 'warn' : 'ok', `${A.limit(Math.round(w.usedPercent))} · ${label}`, `${T.usage.resets} ${untilText(w.resetsAt)}. ${A.limitTip}`, {}); }
           if (!firstAlertPass) { const label = `${(AGENT[id] || {}).label || id} · ${win === '5h' ? T.usage.fiveHour : T.usage.week}`; toast(`<b>${esc(A.limit(Math.round(w.usedPercent)))}</b>${esc(label)} · ${esc(T.usage.resets)} ${esc(untilText(w.resetsAt))}`, step >= 95 ? 'bad' : 'warn'); notifyOS(A.limit(Math.round(w.usedPercent)), `${label} · ${T.usage.resets} ${untilText(w.resetsAt)}`); }
         }
       }
     }
   }
+  // pace: at the rate of the last ~hour, will the window run out before it resets? said once per window
+  for (const [id, l] of Object.entries(L)) {
+    for (const [win, w] of [['5h', l && l.primary], ['week', l && l.secondary]]) {
+      if (!w || !w.resetsAt) continue;
+      const k = id + ':' + win, list = (paceSamples.get(k) || []).filter(x => x.resetsAt === w.resetsAt && data.now - x.at < 36e5);
+      if (!list.length || list[list.length - 1].pct !== w.usedPercent) list.push({ at: data.now, pct: w.usedPercent, resetsAt: w.resetsAt });
+      paceSamples.set(k, list); try { store.set('pace', JSON.stringify([...paceSamples])); } catch {}
+      const first = list[0], hrs = (data.now - first.at) / 36e5, rate = hrs >= .25 ? (w.usedPercent - first.pct) / hrs : 0; // % per hour
+      if (rate <= 0 || w.usedPercent < 40 || w.usedPercent >= 100) continue;
+      const left = (100 - w.usedPercent) / rate * 36e5, key = `pace:${k}:${w.resetsAt}`;
+      if (data.now + left < w.resetsAt - 6e5 && !alerted.has(key) && !paceSaid.includes(key)) {
+        alerted.add(key); paceSaid = [...paceSaid.slice(-20), key]; try { store.set('paceSaid', JSON.stringify(paceSaid)); } catch {} const label = `${(AGENT[id] || {}).label || id} · ${win === '5h' ? T.usage.fiveHour : T.usage.week}`;
+        if (typeof pushNotice === 'function') pushNotice('pace:' + k, 'warn', A.pace(label, untilText(data.now + left)), A.paceWhy(Math.round(w.usedPercent), Math.round(rate), untilText(w.resetsAt)), {});
+        notifyOS(A.pace(label, untilText(data.now + left)), A.paceWhy(Math.round(w.usedPercent), Math.round(rate), untilText(w.resetsAt)));
+      }
+    }
+  }
   for (const p of data.people) {
     const pct = ctxPct(p), key = `ctx:${p.id}:${p.compactedAt || 0}`;
     if (pct >= .85 && !alerted.has(key)) {
@@ -48,6 +68,16 @@ function checkAlerts() {
       if (!firstAlertPass) { toast(`<b>${esc(A.context(Math.round(pct * 100)))}</b>${esc(p.name)} · ${esc(p.title || '')}`, 'warn'); notifyOS(A.context(Math.round(pct * 100)), p.name); }
     }
   }
+  // stalled: says it is working but wrote nothing to its log for a while (stuck, looping on a slow command, waiting on the network)
+  for (const p of data.people) {
+    if (p.leaving || !p.lastActivity || ['idle', 'asleep', 'needs_you', 'waiting'].includes(p.state)) continue;
+    const quiet = data.now - p.lastActivity, key = `stall:${p.id}:${p.lastActivity}`;
+    if (quiet >= STALL_MS && !alerted.has(key)) {
+      alerted.add(key); const mins = Math.round(quiet / 60000), what = p.doing ? `${p.doing.tool}${p.doing.what ? ' ' + p.doing.what : ''}` : '';
+      if (typeof pushNotice === 'function') pushNotice('stall:' + p.id, 'warn', A.stall(p.name, mins), A.stallWhy(what), { agent: p.id });
+      if (!firstAlertPass) notifyOS(A.stall(p.name, mins), A.stallWhy(what));
+    }
+  }
   // waiting on you for a while (a question or a command to approve): one reminder per wait
   const seen = new Set();
   for (const p of data.people) {
@@ -74,6 +104,8 @@ function checkAlerts() {
   }
   firstAlertPass = false;
 }
+let paceSaid = []; try { paceSaid = JSON.parse(store.get('paceSaid', '[]')) || []; } catch { paceSaid = []; }
+let paceSamples = new Map(); try { paceSamples = new Map(JSON.parse(store.get('pace', '[]'))); } catch { paceSamples = new Map(); }
 let firstAlertPass = true; // what's already true on load is noted, not announced
 
 async function compactAgent(id, btn) {

package/public/js/ambient.js

@@ -101,7 +101,7 @@ function radioNote(freq, at, len, wave, vol) {
 }
 function radioTick() {
   if (!radioOn || !soundOn) return;
-  const mood = officeMood(), bpm = mood === 'rush' ? 132 : mood === 'calm' ? 78 : 104, step = 60 / bpm / 2;
+  const mood = officeMood(), bpm = mood === 'rush' ? 132 : mood === 'calm' ? 78 : mood === 'stuck' ? 66 : 104, step = 60 / bpm / 2;
   const st = STATIONS[radioStation()];
   while (radioNext < audio.currentTime + .25) {
     const bar = Math.floor(radioStep / 16), beat = radioStep % 16, chord = [0, 3, 4, 2][bar % 4];

package/public/js/collection.js

@@ -100,6 +100,8 @@ const SHOP = [
   { id: 'bigtank', price: 900, icon: '🐠' },
   { id: 'cap', price: 150, icon: '🧢' }, { id: 'headphones', price: 300, icon: '🎧' }, { id: 'shades', price: 250, icon: '🕶' }, { id: 'party', price: 200, icon: '🥳' },
   { id: 'shirt_pink', price: 300, icon: '👕' }, { id: 'shirt_black', price: 300, icon: '👕' }, { id: 'shirt_gold', price: 400, icon: '👕' }, { id: 'crown', price: 1500, icon: '👑' },
+  { id: 'beanie', price: 200, icon: '🧶' }, { id: 'bow', price: 150, icon: '🎀' }, { id: 'wizard', price: 700, icon: '🧙' }, { id: 'glasses', price: 200, icon: '👓' }, { id: 'mustache', price: 150, icon: '🥸' },
+  { id: 'shirt_green', price: 300, icon: '👕' }, { id: 'shirt_blue', price: 300, icon: '👕' },
 ];
 const owns = id => prog.owned.includes(id);
 function buy(id) {
@@ -113,7 +115,7 @@ function renderShop() {
   const S2 = T.shop, body = reportEl.querySelector('.report-body'), c = coins();
   body.innerHTML = tabsHtml() + `<div class="wallet"><span class="coin"></span><b>${c.toLocaleString(lang === 'pt' ? 'pt-BR' : 'en')}</b> ${esc(T.ach.coins)}<span class="note">${esc(S2.sub)}</span></div>
     <div class="shop">${SHOP.map(it => { const has = owns(it.id), can = c >= it.price; return `<div class="item ${has ? 'owned' : ''}"><span class="ach-ico">${it.icon}</span><div><b>${esc(S2.items[it.id].name)}</b><p>${esc(S2.items[it.id].desc)}</p>
-      ${has ? `<small class="ok">${esc(S2.owned)}</small> <button class="btn small" data-move-item>${esc(S2.move)}</button>` : `<button class="btn small" data-buy="${it.id}" ${can ? '' : 'disabled'}><span class="coin"></span> ${it.price}</button>`}</div></div>`; }).join('')}</div>
+      ${has && typeof OUTFIT !== 'undefined' && OUTFIT[it.id] ? `<small class="ok">${esc(S2.inWardrobe)}</small> <button class="btn small" data-tab="office">${esc(S2.wear)}</button>` : has ? `<small class="ok">${esc(S2.owned)}</small> <button class="btn small" data-move-item>${esc(S2.move)}</button>` : `<button class="btn small" data-buy="${it.id}" ${can ? '' : 'disabled'}><span class="coin"></span> ${it.price}</button>`}</div></div>`; }).join('')}</div>
     ${prog.owned.length ? `<p><button class="btn small" data-move-item>✥ ${esc(S2.decoTitle)}</button></p>` : ''}`;
 }
 reportEl.addEventListener('click', e => { if (e.target.closest('[data-share-card]')) return shareCard(); if (e.target.closest('[data-visit-photo]')) return visitPhoto(); const b = e.target.closest('[data-buy]'); if (b) buy(b.dataset.buy); if (e.target.closest('[data-move-item]')) setDecorating(true); });

package/public/js/fun.js

@@ -113,9 +113,12 @@ function drawHolidayWindow(x, y, w, h, t, sky) {
 // ---- office mood: how busy the office is changes the room ----
 // rush = most of the office working (the ON AIR sign lights, the coffee machine never stops),
 // calm = nobody working (the lights dim a little and the robot vacuum gets to work)
+// stuck = many agents waiting on you or silent while "working" (the room goes grey-blue and the radio slows down)
 function officeMood() {
   if (!data) return 'normal';
   const live = data.people.filter(p => !p.leaving);
+  const blocked = live.filter(p => ['needs_you', 'waiting'].includes(p.state) || (p.lastActivity && !['idle', 'asleep'].includes(p.state) && data.now - p.lastActivity > 10 * 60000)).length;
+  if (blocked >= 2 && blocked / Math.max(1, live.length) >= .4) return 'stuck';
   const work = live.filter(p => !['idle', 'asleep', 'needs_you', 'waiting'].includes(p.state)).length;
   if (work >= 3 && work / Math.max(1, live.length) >= .6) return 'rush';
   if (live.length && work === 0) return 'calm';
@@ -133,8 +136,10 @@ let moodBox = null;
 // lit things on the wall are redrawn over the night shade (like the LED panel)
 let wallLit = [];
 function moodShade() { // drawn over everything but the lit things, before the lights
-  if (officeMood() !== 'calm') return;
-  ctx.fillStyle = 'rgba(20, 18, 40, .12)'; ctx.fillRect(0, 0, W, H);
+  const m = officeMood();
+  if (m === 'calm') { ctx.fillStyle = 'rgba(20, 18, 40, .12)'; ctx.fillRect(0, 0, W, H); }
+  if (m === 'stuck') { ctx.fillStyle = 'rgba(40, 58, 92, .28)'; ctx.fillRect(0, 0, W, H); } // grey-blue: things are stuck on you
+  if (m === 'rush') { ctx.fillStyle = 'rgba(255, 176, 84, .05)'; ctx.fillRect(0, 0, W, H); } // warm: it flows
 }
 
 // ---- the cat: visits whoever has been waiting on you the longest, and likes being petted ----