arcroom 0.0.3-beta → 0.0.5-beta

package/dist/hook.js

@@ -3,16 +3,17 @@ import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } fr
 import { join } from 'node:path';
 import { AGENTS, fromAgent, toAgent } from './agents.js';
 import { ensureDaemon } from './daemon.js';
-import { noteEdit, onStop } from './done.js';
+import { EDIT_TOOLS, noteEdit, onStop, SHELL_TOOLS } from './done.js';
 import { toArcroomEvent } from './events.js';
-import { noteDir } from './code.js';
+import { editClash, noteDir } from './code.js';
 import { fence } from './fence.js';
 import { redact, rememberSecrets } from './redact.js';
-import { ARCROOM_HOME, isOff, keyRefused } from './home.js';
+import { ARCROOM_HOME, isOff, keyRefused, loadConfig } from './home.js';
 import { lookupFast } from './lookup.js';
 import { checkLoop, sessionFile } from './loop.js';
 import { pack } from './pack.js';
 import { lastRunNote, projectOf } from './session.js';
+import { laptopHookActs } from './scope.js';
 import { bump, MARK, signFor, toolResult } from './signs.js';
 import { costSinceClaim, markClaim, turnUsage } from './usage.js';
 // Claude Code runs this for every hook event, with the event JSON on stdin.
@@ -43,8 +44,14 @@ export async function hook() {
         const raw = fromAgent(JSON.parse(input), agent);
         if (isOff(raw.cwd))
             return; // switched off for this repo by this person (arcroom off): nothing recorded or sent
-        if (keyRefused())
-            return; // the key was revoked or its account deleted: nothing runs until a new key (arcroom init)
+        if (process.argv.includes('--user') && !laptopHookActs(raw.cwd))
+            return; // laptop-wide hook: only set-up repos, never twice
+        if (keyRefused(loadConfig(raw.cwd))) {
+            // the key was revoked or its account deleted: nothing runs until a new key (arcroom init); said once, at session start
+            if (raw.hook_event_name === 'SessionStart')
+                process.stdout.write(JSON.stringify(toAgent(agent, 'SessionStart', { systemMessage: `${MARK} · stopped: the API refused this laptop's key. Run arcroom init with a new key (web app, Settings → API keys).` }, String(raw.session_id))));
+            return;
+        }
         rememberSecrets(raw.cwd); // this project's .env values are redacted wherever they show up
         const name = raw.hook_event_name;
         const session = String(raw.session_id);
@@ -58,7 +65,7 @@ export async function hook() {
         const injected = (kind, text, keepText = false) => emit('context', { kind, chars: text.length, ...(keepText ? { text: text.slice(0, 2000) } : {}) });
         // Token meter: the turn's usage goes in before its turn.end, so the report built at turn.end includes it.
         // After each tool call too, so the website shows a long turn's tokens while it runs.
-        if (name === 'Stop' || name === 'SessionEnd' || name === 'PostToolUse') {
+        if (name === 'Stop' || name === 'SessionEnd' || name === 'PreToolUse') {
             const usage = turnUsage(session, raw.transcript_path);
             if (usage)
                 emit('usage', usage);
@@ -149,21 +156,27 @@ export async function hook() {
             }
             if (pointer)
                 given.add(pointer.memoId);
-            // what `arcroom wrong` reports when the person says the memory just handed over was wrong
-            const last = pointer ?? (playbook && { memoId: playbook.memoId, intent: 'playbook' });
-            if (last)
-                writeFileSync(join(ARCROOM_HOME, 'last-recall.json'), JSON.stringify({ memo_id: last.memoId, intent: last.intent }));
+            // what `arcroom wrong` reports when the person says the memory just handed over was wrong: every memory handed over
+            // (steps or answer, playbook, each fact and decision), so it can name the one that was wrong
+            const handed = [
+                ...(pointer ? [{ memo_id: pointer.memoId, kind: pointer.kind, text: pointer.intent }] : []),
+                ...(playbook ? [{ memo_id: playbook.memoId, kind: 'playbook', text: playbook.intent ?? 'playbook' }] : []),
+                ...(knowledge ? knowledge.items.map((i) => ({ memo_id: i.id, kind: i.kind, text: i.text })) : []),
+            ];
+            if (handed.length)
+                writeFileSync(join(ARCROOM_HOME, 'last-recall.json'), JSON.stringify({ memo_id: handed[0].memo_id, intent: handed[0].text, handed }));
             if (pointer || knowledge || playbook)
                 writeFileSync(givenFile, JSON.stringify([...given]));
             if (pointer) {
                 injected('recall', pointer.text, true);
                 // the turn's outcome credits (or heals) these steps when the turn ends
+                const match = pointer.match ? { similar: true, match: pointer.match } : {};
                 if (pointer.kind === 'steps')
-                    emit('memory.replayed', { memo_id: pointer.memoId });
+                    emit('memory.replayed', { memo_id: pointer.memoId, ...match });
                 else
-                    emit('memory.reused', { memo_id: pointer.memoId, version: pointer.version });
+                    emit('memory.reused', { memo_id: pointer.memoId, version: pointer.version, ...match });
                 bump(session, pointer.kind === 'steps' ? 'replayed' : 'reused');
-                say(`${MARK} · ${pointer.kind === 'steps' ? 'steps from a past run' : 'a team answer'}${pointer.similar ? ' for a similar task' : ''}: ${pointer.intent.slice(0, 70)}`);
+                say(`${MARK} · ${pointer.kind === 'steps' ? 'steps from a past run' : 'a team answer'}${pointer.similar ? ' for a similar task' : ''}: ${pointer.intent.slice(0, 70)}${pointer.match ? ` (match: ${pointer.match})` : ''}`);
             }
             // a hit is the lookup already done: the reminder would only send the agent to find_task for it again
             // what teammates' agents wrote goes in one fenced block of data (fence.ts); ArcRoom's own reminder stays outside it
@@ -184,11 +197,22 @@ export async function hook() {
                 say(`${MARK} · blocked a repeated ${String(raw.tool_name).replace(OUR_TOOLS, '')} call (same input 3 times in a row)`);
                 bump(session, 'blocked');
             }
-            else
-                noteEdit(raw);
+            else {
+                // two agents on one file: the first edit waits once, with who is on it (the same edit again goes through)
+                const clash = EDIT_TOOLS.has(raw.tool_name)
+                    ? await editClash(loadConfig(raw.cwd), session, raw.cwd, raw.tool_input?.file_path ?? raw.tool_input?.notebook_path).catch(() => undefined)
+                    : undefined;
+                if (clash) {
+                    out.hookSpecificOutput = { hookEventName: 'PreToolUse', permissionDecision: 'deny', permissionDecisionReason: clash };
+                    injected('deny', clash);
+                    say(`${MARK} · another agent is editing this file: asked yours to check first`);
+                }
+                else
+                    noteEdit(raw);
+            }
         }
         // a done-check the agent ran with Bash (the Stop hook asks for them; it never runs them itself)
-        if (name === 'PostToolUse' && raw.tool_name === 'Bash')
+        if (name === 'PostToolUse' && SHELL_TOOLS.has(raw.tool_name))
             noteEdit(raw);
         if (name === 'PostToolUse' && String(raw.tool_name).startsWith(OUR_TOOLS)) {
             const tool = raw.tool_name.slice(OUR_TOOLS.length);
@@ -227,14 +251,16 @@ export async function hook() {
         }
         if (project) {
             // Session memory: start with what the last run in this project did. Slow or offline API = no note.
-            const note = await lastRunNote(session, project).catch(() => undefined);
+            const root = git(['rev-parse', '--show-toplevel'], { cwd: raw.cwd }).stdout?.trim();
+            const note = await lastRunNote(session, project, branch, root).catch(() => undefined);
             if (note) {
                 // the last run here may be a teammate's: its ask is their words, so it is fenced like any memory
                 out.hookSpecificOutput = { hookEventName: 'SessionStart', additionalContext: fence(note) };
                 injected('last_run', note, true);
             }
             // say what leaves the laptop, every session (events.ts keeps it to that)
-            say(`${MARK} · on: team memory · sends prompts, file paths and commands (no file contents)${note ? ' · picked up where the last run here left off' : ''}`);
+            const ws = loadConfig(raw.cwd).workspace;
+            say(`${MARK} · on: team memory${ws ? ` in "${ws}"` : ''} · sends prompts, file paths and commands (no file contents)${note ? ' · picked up where the last run here left off' : ''}`);
         }
         const reply = toAgent(agent, name, out, session);
         if (Object.keys(reply).length)

package/dist/index.js

@@ -1,16 +1,17 @@
 #!/usr/bin/env node
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { codeSetup, forgetBlind, gitRoot, repoKey, writeSetup } from './blind.js';
-import { daemon } from './daemon.js';
+import { daemon, flush, unsent } from './daemon.js';
 import { doctor, print } from './doctor.js';
 import { approveChecks, checksHash, isApproved, loadChecks, readApprovals } from './done.js';
-import { syncTree } from './tree.js';
+import { codeSetup, repoKey, syncTree, writeSetup } from './tree.js';
+import { gitRoot, projectOf } from './git.js';
 import { api, ARCROOM_HOME, loadConfig, setOff } from './home.js';
 import { hook } from './hook.js';
-import { init } from './init.js';
+import { init, uninstall } from './init.js';
+import { sentReport } from './sent.js';
 import { mcp } from './mcp.js';
-import { readStats, statusText } from './signs.js';
+import { readStats, statusText, wrongNote } from './signs.js';
 import { sessionUsage, tokensOf } from './usage.js';
 const [cmd, ...args] = process.argv.slice(2);
 // A command someone typed that fails prints one line, not a stack trace (the hook, daemon and MCP server keep their own handling).
@@ -32,7 +33,7 @@ else if (cmd === 'doctor') {
         process.exitCode = 1;
 }
 else if (cmd === 'whoami') {
-    const me = await api(loadConfig(), '/v1/me');
+    const me = await api(loadConfig(process.cwd()), '/v1/me');
     console.log(`${me.email ?? 'shared key (no person)'} in workspace "${me.workspace}" (key ${me.key_label ?? 'unlabelled'}, made ${me.key_created_at})`);
 }
 else if (cmd === 'status') {
@@ -55,31 +56,29 @@ else if (cmd === 'rule') {
     // arcroom rule [--tag <tag>] [--max-hits N] [--idle-days D]   (no limits = remove the rule)
     const opt = (name) => (args.includes(name) ? args[args.indexOf(name) + 1] : undefined);
     const num = (name) => (opt(name) === undefined ? null : Number(opt(name)));
-    const res = await api(loadConfig(), '/v1/rules', { tag: opt('--tag') ?? null, max_hits: num('--max-hits'), idle_days: num('--idle-days') });
+    const res = await api(loadConfig(process.cwd()), '/v1/rules', { tag: opt('--tag') ?? null, max_hits: num('--max-hits'), idle_days: num('--idle-days') });
     console.log(res.rule ? `rule set: ${JSON.stringify(res.rule)}` : 'rule removed');
 }
 else if (cmd === 'wrong' || cmd === 'share') {
     // arcroom wrong [memo id] [reason]: the memory just handed over (or the one named) was wrong
-    // arcroom share [memo id]: share your new steps with the team before their second pass
+    // arcroom share <memo id>: share an answer saved as "only me" with the team (recorded steps are the team's already)
     const lastFile = join(ARCROOM_HOME, 'last-recall.json');
     const named = /^[0-9a-f-]{36}$/i.test(args[0] ?? '') ? args.shift() : undefined;
-    const last = named ? { memo_id: named, intent: named } : existsSync(lastFile) ? JSON.parse(readFileSync(lastFile, 'utf8')) : undefined;
-    if (!last)
+    const last = named ? { memo_id: named, intent: named } : cmd === 'wrong' && existsSync(lastFile) ? JSON.parse(readFileSync(lastFile, 'utf8')) : undefined;
+    if (!last && cmd === 'share')
+        console.log('steps your agents record are shared with the team already; to share an answer saved as private, pass its id: arcroom share <memo id> (see the Memory page)');
+    else if (!last)
         console.log('no memory was handed over yet; pass its id (see the Memory page)');
+    else if (!named && Array.isArray(last.handed) && last.handed.length > 1)
+        // several memories came in that hand-over: say which, instead of guessing
+        console.log(`The last hand-over had ${last.handed.length} memories. Name the wrong one:\n${last.handed.map((h) => `  arcroom wrong ${h.memo_id}   ${h.kind}: ${h.text}`).join('\n')}`);
     else if (cmd === 'share') {
-        await api(loadConfig(), '/v1/memory/share', { memo_id: last.memo_id });
+        await api(loadConfig(process.cwd()), '/v1/memory/share', { memo_id: last.memo_id });
         console.log(`shared with the team: ${last.intent}`);
     }
     else {
-        const r = await api(loadConfig(), '/v1/memory/wrong', { memo_id: last.memo_id, reason: args.join(' ') || null });
-        const what = r.deleted
-            ? 'deleted (2 people said wrong)'
-            : r.steps_broken
-                ? 'steps broken, the last good version takes over'
-                : r.answer_thrown_away
-                    ? 'answer thrown away'
-                    : `noted (${r.reports} of 2 reports delete it)`;
-        console.log(`reported wrong: ${last.intent} · ${what}`);
+        const r = await api(loadConfig(process.cwd()), '/v1/memory/wrong', { memo_id: last.memo_id, reason: args.join(' ') || null });
+        console.log(`reported wrong: ${last.intent} · ${wrongNote(r)}`);
     }
 }
 else if (cmd === 'code') {
@@ -90,23 +89,40 @@ else if (cmd === 'code') {
         console.log('not inside a git repo');
     else if (sub === 'off' || sub === 'on') {
         writeSetup(s.root, { code: sub === 'off' ? 'off' : undefined });
-        forgetBlind(s.root); // the person here chose it: this laptop stops holding the repo to Blind
         console.log(`Code wing ${sub} for ${s.root} (commit .arcroom.json so the team gets the same setting)`);
     }
-    else if (s.mode !== 'standard')
-        console.log(`Code wing is ${s.mode} for this repo${s.mode === 'off' ? ': arcroom code on turns it on' : ''}`);
+    else if (s.mode === 'off')
+        console.log('Code wing is off for this repo: arcroom code on turns it on');
     else if (sub === 'sync') {
-        const r = await syncTree(loadConfig(), s);
+        const r = await syncTree(loadConfig(process.cwd()), s);
         console.log(`sent ${r.nodes} folders and files (repo ${repoKey(s)})`);
     }
     else {
-        const repos = await api(loadConfig(), '/v1/code/tree');
+        const repos = await api(loadConfig(process.cwd()), '/v1/code/tree');
         const me = repos.find((x) => x.repo === repoKey(s));
         console.log(me
             ? `${me.repo}: ${me.folders} folders, ${me.files} files, ${me.editing} agent(s) editing now, default branch ${me.default_branch}`
             : 'this repo has not sent its tree yet: arcroom code sync');
     }
 }
+else if (cmd === 'flush') {
+    // arcroom flush: the last step of a CI job, so a headless run's final events are not lost when the machine goes away
+    const ok = await flush(process.argv[1]);
+    console.log(ok ? 'everything queued was sent' : `${unsent()} bytes still queued after 60 s: see arcroom doctor`);
+    if (!ok)
+        process.exitCode = 1;
+}
+else if (cmd === 'sent') {
+    // arcroom sent [YYYY-MM-DD] [--all]: what this laptop sent that day, kept 7 days
+    console.log(sentReport(args));
+}
+else if (cmd === 'uninstall') {
+    // arcroom uninstall [--all]: ArcRoom out of this project for every agent; --all also deletes ~/.arcroom
+    const changed = uninstall(process.cwd(), args.includes('--all'));
+    console.log(changed.length ? `Removed ArcRoom from:\n${changed.map((c) => `  ${c}`).join('\n')}` : 'Nothing of ArcRoom was set up in this project.');
+    if (!args.includes('--all'))
+        console.log('Other projects on this laptop keep it. arcroom uninstall --all also deletes ~/.arcroom (key, queue, runtime).');
+}
 else if (cmd === 'off' || cmd === 'on') {
     // arcroom off | on: ArcRoom for the repo you are in, on this laptop only (nothing traced or sent while off)
     const root = gitRoot(process.cwd()) ?? process.cwd();
@@ -123,7 +139,7 @@ else if (cmd === 'checks') {
         console.log('no doneChecks in .arcroom.json here');
     else if (args[0] === 'approve' && !process.stdin.isTTY)
         // an agent's shell has no terminal: approving stays a step the person takes themselves (N14)
-        console.log('not approved: run arcroom checks approve yourself, in a terminal (not through an agent)');
+        console.log(`not approved: run arcroom checks approve yourself, in a terminal (not through an agent); in CI, set ARCROOM_APPROVE_CHECKS=${code} in the job's environment`);
     else if (args[0] === 'approve') {
         const done = approveChecks(process.cwd(), args[1] ?? '');
         console.log(done ? `approved for ${process.cwd()} (after editing files, the agent is asked to run them with its Bash tool before it stops):\n${list}` : 'not approved: run arcroom checks, read the commands, then arcroom checks approve <the code it prints>');
@@ -143,9 +159,10 @@ else if (cmd === 'decide') {
     else {
         const over = opt('--over')?.split(',').map((o) => o.trim()).filter(Boolean);
         const url = opt('--source');
-        const r = await api(loadConfig(), '/v1/memory/remember', {
+        const r = await api(loadConfig(process.cwd()), '/v1/memory/remember', {
             kind: 'decision',
             text,
+            project: projectOf(process.cwd()),
             why: opt('--why') ?? null,
             ...(over ? { options: [text, ...over] } : {}),
             ...(opt('--context') ? { context: opt('--context') } : {}),
@@ -153,8 +170,12 @@ else if (cmd === 'decide') {
             ...(url ? { source: { kind: /\/pull\//.test(url) ? 'pr' : /\/issues\//.test(url) ? 'issue' : 'other', url } } : {}),
             ...(opt('--replaces') ? { replaces: opt('--replaces') } : {}),
         });
-        console.log(`${r.saved ? 'decision saved' : 'decision already saved; detail updated'}${r.replaced ? ', the earlier one is replaced' : ''} (${r.memo_id})`);
+        // refused (replaced or reported wrong before): the API's note says which memory is in force and what to pass
+        if (!r.saved && r.note)
+            console.log(`decision not saved: ${r.note}`);
+        else
+            console.log(`${r.saved ? 'decision saved' : 'decision already saved; detail updated'}${r.replaced ? ', the earlier one is replaced' : ''} (${r.memo_id})`);
     }
 }
 else
-    console.log('usage: arcroom init [--project <id>] (asks for the key; or set ARCROOM_API_KEY) [--url <arcroom api url>] | arcroom whoami | arcroom doctor | arcroom rule [--tag t] [--max-hits n] [--idle-days d] | arcroom wrong [memo id] [reason] | arcroom share [memo id] | arcroom decide "<choice>" [--why ...] [--over "A, B"] | arcroom code [status|sync|on|off] | arcroom checks [approve] | arcroom off | arcroom on');
+    console.log('usage: arcroom init [--project <id>] (asks for the key; or set ARCROOM_API_KEY) [--url <arcroom api url>] | arcroom whoami | arcroom doctor | arcroom rule [--tag t] [--max-hits n] [--idle-days d] | arcroom wrong [memo id] [reason] | arcroom share [memo id] | arcroom decide "<choice>" [--why ...] [--over "A, B"] | arcroom code [status|sync|on|off] | arcroom checks [approve] | arcroom off | arcroom on | arcroom uninstall [--all] | arcroom init --everywhere | arcroom sent [YYYY-MM-DD] [--all] | arcroom flush');

package/dist/init.js

@@ -1,26 +1,30 @@
 import { spawnSync } from 'node:child_process';
-import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { appendFileSync, cpSync, existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, isAbsolute, join, relative } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createInterface } from 'node:readline/promises';
 import { AGENTS, CURSOR_HOOKS, opencodePlugin } from './agents.js';
 import { stopDaemon } from './daemon.js';
-import { onPath } from './git.js';
-import { apiUrl, ARCROOM_HOME, DEFAULT_URL, isLocalUrl, keyRefused } from './home.js';
+import { git, onPath, projectOf } from './git.js';
+import { api, apiUrl, ARCROOM_HOME, DEFAULT_URL, isLocalUrl, keyRefused } from './home.js';
+import { userSettings } from './scope.js';
 const EVENTS = ['SessionStart', 'UserPromptSubmit', 'PreToolUse', 'PostToolUse', 'Stop', 'SessionEnd'];
 const TOOL_EVENTS = new Set(['PreToolUse', 'PostToolUse']);
 const MARK = '.arcroom/runtime'; // identifies our hook entries in a settings file
 // node by its full path, never the word "node": an agent starting a hook inside a repo must not run a node.exe planted there
 const NODE = process.execPath;
 const nodeCmd = JSON.stringify(NODE);
+// After a tool, only a shell run (a done-check passing) and ArcRoom's own tools matter, so Claude Code launches the hook
+// once per tool call instead of twice: each launch is a window flash on Windows (Git Bash, no console of its own).
+export const AFTER_TOOLS = 'Bash|PowerShell|mcp__arcroom__.*';
 /** Puts ArcRoom's hook on every event: replaces an earlier ArcRoom entry, keeps everyone else's hooks. */
-export function withArcroomHooks(settings, command, anyTool = '*') {
+export function withArcroomHooks(settings, command, anyTool = '*', afterTool = anyTool) {
     const hooks = { ...settings.hooks };
     for (const event of EVENTS) {
         const others = (hooks[event] ?? []).filter((g) => !g.hooks.some((h) => h.command.includes(MARK)));
         const ours = { hooks: [{ type: 'command', command }] };
         if (TOOL_EVENTS.has(event))
-            ours.matcher = anyTool;
+            ours.matcher = event === 'PostToolUse' ? afterTool : anyTool;
         hooks[event] = [...others, ours];
     }
     return { ...settings, hooks };
@@ -38,6 +42,28 @@ export function withCodexMcp(toml, entry, node = NODE) {
     const ours = `[mcp_servers.arcroom]\ncommand = ${JSON.stringify(node)}\nargs = [${JSON.stringify(entry)}, "mcp"]\n`;
     return (others ? `${others}\n\n` : '') + ours;
 }
+/**
+ * Keeps the files init wrote out of commits, in this clone only (.git/info/exclude, never committed): they hold this
+ * laptop's paths, so a `git add -A` would break a teammate's setup. A file the repo already tracks is left alone.
+ */
+export function keepOutOfGit(files, cwd) {
+    const root = git(['rev-parse', '--show-toplevel'], { cwd }).stdout?.trim();
+    const path = git(['rev-parse', '--git-path', 'info/exclude'], { cwd }).stdout?.trim();
+    if (!root || !path)
+        return [];
+    const exclude = isAbsolute(path) ? path : join(cwd, path);
+    const have = existsSync(exclude) ? readFileSync(exclude, 'utf8').split(/\r?\n/) : [];
+    // git answers with the real path; a symlinked folder (macOS /var) or a short name (Windows RUNNER~1) would read as outside
+    const real = (p) => (existsSync(p) ? realpathSync.native(p) : p);
+    const add = files
+        .map((f) => '/' + relative(real(root), real(f)).replaceAll('\\', '/'))
+        .filter((rel) => !rel.startsWith('/..') && !have.includes(rel) && git(['ls-files', '--error-unmatch', rel.slice(1)], { cwd: root }).status !== 0);
+    if (!add.length)
+        return [];
+    mkdirSync(dirname(exclude), { recursive: true });
+    appendFileSync(exclude, (have.length && have[have.length - 1] !== '' ? '\n' : '') + add.join('\n') + '\n');
+    return add;
+}
 const readJson = (file) => (existsSync(file) ? JSON.parse(readFileSync(file, 'utf8')) : {});
 const writeJson = (file, value) => {
     mkdirSync(dirname(file), { recursive: true });
@@ -58,6 +84,26 @@ export function initChoice(o) {
     ];
     return { key, url, notes };
 }
+/**
+ * The config after init saves `key` in `repo`. A key for another workspace than the laptop's working default becomes this
+ * repo's own, and every other repo keeps sending where it did (a freelancer's two clients); otherwise it is the default.
+ */
+export function keysAfterInit(saved, repo, key, url, workspace) {
+    const other = !!saved.apiKey && saved.apiKey !== key && !keyRefused({ apiKey: saved.apiKey, url }) && !!saved.workspace && !!workspace && saved.workspace !== workspace;
+    const repos = { ...(saved.repos ?? {}) };
+    if (other)
+        repos[repo] = { apiKey: key, workspace };
+    else
+        delete repos[repo];
+    const next = other ? { ...saved, url, repos } : { ...saved, apiKey: key, url, ...(workspace ? { workspace } : {}), repos };
+    if (!Object.keys(next.repos).length)
+        delete next.repos;
+    if (other)
+        console.log(`This repo sends to "${workspace}"; other repos on this laptop keep sending to "${saved.workspace}".`);
+    else if (saved.workspace && workspace && saved.workspace !== workspace)
+        console.error(`Note: this laptop's default is now "${workspace}" (was "${saved.workspace}").`);
+    return next;
+}
 export async function init(args) {
     const arg = (name) => (args.includes(name) ? args[args.indexOf(name) + 1] : undefined);
     const agent = (arg('--agent') ?? 'claude');
@@ -67,7 +113,10 @@ export async function init(args) {
     }
     const configFile = join(ARCROOM_HOME, 'config.json');
     const saved = existsSync(configFile) ? JSON.parse(readFileSync(configFile, 'utf8')) : {}; // re-running init reuses saved values
-    const choice = initChoice({ argKey: arg('--key'), envKey: process.env.ARCROOM_API_KEY, argUrl: arg('--url'), saved });
+    const repo = projectOf(process.cwd());
+    const mine = saved.repos?.[repo]; // this repo's own key, when it has one
+    const forRepo = mine ? { ...saved, apiKey: mine.apiKey, workspace: mine.workspace } : saved;
+    const choice = initChoice({ argKey: arg('--key'), envKey: process.env.ARCROOM_API_KEY, argUrl: arg('--url'), saved: forRepo });
     let key = choice.key;
     const url = choice.url;
     if (arg('--key'))
@@ -90,9 +139,24 @@ export async function init(args) {
         console.error('That is not an ArcRoom key (it starts with ark_).');
         process.exit(1);
     }
-    // 1. Remember the key for this machine.
+    // 1. Check the key with the API, then remember it for this machine: a typo or a revoked key must not end in "ArcRoom is on".
+    let workspace = forRepo.apiKey === key ? forRepo.workspace : undefined;
+    try {
+        const me = await api({ apiKey: key, url }, '/v1/me');
+        workspace = me.workspace;
+        console.log(`Connected to workspace "${me.workspace}"${me.email ? ` as ${me.email}` : ''}.`);
+    }
+    catch (e) {
+        if (/invalid api key/.test(e.message)) {
+            console.error('The API refused this key. Make a new one in the web app (Settings → API keys) and run arcroom init again.');
+            process.exit(1);
+        }
+        console.error(`Could not check the key (${e.message}); saved it anyway. Run arcroom doctor once you are online.`);
+    }
     mkdirSync(ARCROOM_HOME, { recursive: true, mode: 0o700 });
-    writeFileSync(configFile, JSON.stringify({ apiKey: key, url }, null, 2), { mode: 0o600 });
+    const cfg = keysAfterInit(saved, repo, key, url, workspace);
+    cfg.setUp = [...new Set([...(cfg.setUp ?? []), repo])]; // laptop-wide hooks (--everywhere) act only in repos set up here
+    writeFileSync(configFile, JSON.stringify(cfg, null, 2), { mode: 0o600 });
     stopDaemon(); // the next hook event starts the updated one
     // 2. Copy the hook runtime to a stable place (npx's own copy is temporary).
     const runtime = join(ARCROOM_HOME, 'runtime');
@@ -113,7 +177,7 @@ export async function init(args) {
     }
     if (agent !== 'claude')
         return initOther(agent, entry, project);
-    const settings = withArcroomHooks(current, `${nodeCmd} "${entry}" hook${project ? ` --project ${project}` : ''}`);
+    const settings = withArcroomHooks(current, `${nodeCmd} "${entry}" hook${project ? ` --project ${project}` : ''}`, '*', AFTER_TOOLS);
     // never pre-approve a server from the shared .mcp.json by name: a pull request could change what that name runs
     const approved = (current.enabledMcpjsonServers ?? []).filter((n) => n !== 'arcroom');
     if (approved.length)
@@ -121,9 +185,13 @@ export async function init(args) {
     else
         delete settings.enabledMcpjsonServers;
     // Live badge at the bottom of Claude Code ("ArcRoom · live · 2 reused"), unless the project has its own status line.
+    // It runs a command on every redraw, a window flash each time on Windows, so there it is only on with --status.
     const theirs = current.statusLine;
-    if (!theirs || theirs.command?.includes(MARK))
+    const status = process.platform !== 'win32' || args.includes('--status');
+    if (status && (!theirs || theirs.command?.includes(MARK)))
         settings.statusLine = { type: 'command', command: `${nodeCmd} "${entry}" status`, padding: 0 };
+    else if (!status && theirs?.command?.includes(MARK))
+        delete settings.statusLine;
     mkdirSync(dirname(file), { recursive: true });
     writeFileSync(file, JSON.stringify(settings, null, 2) + '\n');
     // 4. Register the MCP server (find_task / claim_task / complete_task) for this project: in Claude Code's local scope
@@ -142,17 +210,28 @@ export async function init(args) {
         mcpConfig.mcpServers = { ...mcpConfig.mcpServers, arcroom: { command: NODE, args: [entry, 'mcp'] } };
         writeFileSync(mcpFile, JSON.stringify(mcpConfig, null, 2) + '\n');
     }
+    const kept = keepOutOfGit([file, ...(local ? [] : [mcpFile])], process.cwd());
+    // 5. --everywhere: the same hook and tools for every folder on this laptop (Claude Code's user settings and user scope),
+    // acting only in repos set up here, so other clones and worktrees of this repo are covered too.
+    const everywhere = args.includes('--everywhere');
+    if (everywhere) {
+        const user = userSettings();
+        const mine = existsSync(user) ? JSON.parse(readFileSync(user, 'utf8')) : {};
+        writeJson(user, withArcroomHooks(mine, `${nodeCmd} "${entry}" hook --user`, '*', AFTER_TOOLS));
+        claudeCli(['mcp', 'remove', '--scope', 'user', 'arcroom']);
+        claudeCli(['mcp', 'add', '--scope', 'user', 'arcroom', '--', NODE, entry, 'mcp', '--user']);
+    }
     console.log(`ArcRoom is on for this project.
   key      ${join(ARCROOM_HOME, 'config.json')}
   hooks    ${file}
-  tools    ${local ? 'Claude Code local scope (claude mcp list)' : `${mcpFile} (approve "arcroom" when Claude Code asks)`}
-Start a new Claude Code session here to begin capturing runs.`);
+  tools    ${local ? 'Claude Code local scope (claude mcp list)' : `${mcpFile} (approve "arcroom" when Claude Code asks)`}${kept.length ? `\n  git      kept out of commits in this clone: ${kept.join(', ')}` : ''}${everywhere ? `\n  laptop   ${userSettings()}: every clone and worktree of a repo set up here` : ''}
+Start a new Claude Code session here to begin capturing runs. Check it any time: arcroom doctor`);
 }
-/** `claude mcp add --scope local arcroom`: false when the claude command is not on PATH or the add failed. */
-function addLocalMcp(entry) {
+/** Runs the claude command; null when it is not on PATH. */
+function claudeCli(args) {
     const claude = onPath(process.platform === 'win32' ? ['claude.exe', 'claude.cmd'] : ['claude']);
     if (!claude)
-        return false;
+        return null;
     const run = (args) => claude.endsWith('.cmd') // an npm install on Windows: a batch file runs through cmd, every argument quoted
         ? spawnSync(process.env.ComSpec ?? 'cmd.exe', ['/d', '/s', '/c', `"${[claude, ...args].map((a) => `"${a}"`).join(' ')}"`], {
             windowsVerbatimArguments: true,
@@ -160,8 +239,106 @@ function addLocalMcp(entry) {
             encoding: 'utf8',
         })
         : spawnSync(claude, args, { encoding: 'utf8', windowsHide: true });
-    run(['mcp', 'remove', '--scope', 'local', 'arcroom']); // none yet is fine
-    return run(['mcp', 'add', '--scope', 'local', 'arcroom', '--', NODE, entry, 'mcp']).status === 0;
+    return run(args).status;
+}
+/** `claude mcp add --scope local arcroom`: false when the claude command is not on PATH or the add failed. */
+function addLocalMcp(entry) {
+    if (claudeCli(['mcp', 'remove', '--scope', 'local', 'arcroom']) === null)
+        return false; // none yet is fine
+    return claudeCli(['mcp', 'add', '--scope', 'local', 'arcroom', '--', NODE, entry, 'mcp']) === 0;
+}
+/** A hooks map without ArcRoom's entries (Claude Code and Codex group them; Cursor lists commands); empty events go. */
+function withoutOurHooks(hooks) {
+    if (!hooks)
+        return hooks;
+    const ours = (h) => String(h?.command ?? '').includes(MARK) || (h?.hooks ?? []).some((x) => String(x?.command ?? '').includes(MARK));
+    const next = Object.fromEntries(Object.entries(hooks).map(([event, list]) => [event, (list ?? []).filter((h) => !ours(h))]).filter(([, list]) => list.length));
+    return Object.keys(next).length ? next : undefined;
+}
+/**
+ * `arcroom uninstall [--all]`: takes out of this project what init put in for every agent (hooks, status line, MCP entries,
+ * the OpenCode plugin), keeping everyone else's settings, and stops the uploader. --all also removes ~/.arcroom (the key,
+ * the queue, the runtime). Returns what it changed.
+ */
+export function uninstall(cwd, all = false, removeLocalMcp = () => claudeCli(['mcp', 'remove', '--scope', 'local', 'arcroom']), removeUserMcp = () => claudeCli(['mcp', 'remove', '--scope', 'user', 'arcroom'])) {
+    const changed = [];
+    const edit = (file, change) => {
+        if (!existsSync(file))
+            return;
+        const before = JSON.parse(readFileSync(file, 'utf8'));
+        const after = change(structuredClone(before));
+        if (JSON.stringify(after) === JSON.stringify(before))
+            return;
+        if (!Object.keys(after).length)
+            rmSync(file);
+        else
+            writeFileSync(file, JSON.stringify(after, null, 2) + '\n');
+        changed.push(file);
+    };
+    const ourServer = (s) => JSON.stringify(s ?? '').replaceAll('\\\\', '/').includes(MARK);
+    const hooksOf = (v) => {
+        const hooks = withoutOurHooks(v.hooks);
+        if (hooks)
+            v.hooks = hooks;
+        else
+            delete v.hooks;
+        if (String(v.statusLine?.command ?? '').includes(MARK))
+            delete v.statusLine;
+        return v;
+    };
+    edit(join(cwd, '.claude', 'settings.local.json'), hooksOf);
+    edit(join(cwd, '.codex', 'hooks.json'), hooksOf);
+    edit(join(cwd, '.cursor', 'hooks.json'), (v) => {
+        const hooks = withoutOurHooks(v.hooks);
+        if (hooks)
+            v.hooks = hooks;
+        else
+            delete v.hooks;
+        return Object.keys(v).length === 1 && v.version !== undefined ? {} : v;
+    });
+    for (const file of [join(cwd, '.mcp.json'), join(cwd, '.cursor', 'mcp.json')])
+        edit(file, (v) => {
+            if (ourServer(v.mcpServers?.arcroom))
+                delete v.mcpServers.arcroom;
+            if (v.mcpServers && !Object.keys(v.mcpServers).length)
+                delete v.mcpServers;
+            return v;
+        });
+    edit(join(cwd, 'opencode.json'), (v) => {
+        if (ourServer(v.mcp?.arcroom))
+            delete v.mcp.arcroom;
+        if (v.mcp && !Object.keys(v.mcp).length)
+            delete v.mcp;
+        return Object.keys(v).length === 1 && v.$schema ? {} : v;
+    });
+    const toml = join(cwd, '.codex', 'config.toml');
+    if (existsSync(toml)) {
+        const before = readFileSync(toml, 'utf8');
+        const after = before.replace(/\n?\[mcp_servers\.arcroom\][\s\S]*?(?=\n\[|$)/, '').trimEnd();
+        if (after !== before.trimEnd()) {
+            if (after)
+                writeFileSync(toml, after + '\n');
+            else
+                rmSync(toml);
+            changed.push(toml);
+        }
+    }
+    const plugin = join(cwd, '.opencode', 'plugins', 'arcroom.js');
+    if (existsSync(plugin))
+        rmSync(plugin), changed.push(plugin);
+    if (removeLocalMcp() === 0)
+        changed.push('Claude Code local MCP entry "arcroom"');
+    if (all) {
+        edit(userSettings(), hooksOf);
+        if (removeUserMcp() === 0)
+            changed.push('Claude Code user MCP entry "arcroom"');
+    }
+    stopDaemon();
+    if (all && existsSync(ARCROOM_HOME)) {
+        rmSync(ARCROOM_HOME, { recursive: true, force: true });
+        changed.push(ARCROOM_HOME);
+    }
+    return changed;
 }
 /** Steps 3 and 4 for Codex, Cursor and OpenCode: their own hook and MCP files, in this project. */
 function initOther(agent, entry, project) {
@@ -202,8 +379,10 @@ function initOther(agent, entry, project) {
         cursor: 'Restart Cursor. Cursor adds context only after a tool call, so team memory reaches the agent on its first tool use.',
         opencode: "Restart OpenCode. Experimental: per-prompt recall rides OpenCode's experimental system-prompt hook, so it may change with OpenCode.",
     };
+    const kept = keepOutOfGit(written, cwd);
     console.log(`ArcRoom is on for ${agent} in this project.
   key      ${join(ARCROOM_HOME, 'config.json')}
-${written.map((f) => `  wrote    ${f}`).join('\n')}
-${next[agent]}`);
+${written.map((f) => `  wrote    ${f}`).join('\n')}${kept.length ? `\n  git      kept out of commits in this clone: ${kept.join(', ')}` : ''}
+${next[agent]}
+Check it any time: arcroom doctor`);
 }

package/dist/lookup.js

@@ -36,7 +36,7 @@ const CODE_MS = 1200; // the code map is the extra: it never holds recall up
 export async function lookup(prompt, cwd, session, given) {
     const [r, code] = await Promise.all([
         recall(prompt, cwd, projectOf(cwd), given, RECALL_MS).catch(() => undefined),
-        codeContext(loadConfig(), cwd, session, prompt, CODE_MS).catch(() => undefined),
+        codeContext(loadConfig(cwd), cwd, session, prompt, CODE_MS).catch(() => undefined),
     ]);
     if (!r)
         markDown();