arcroom 0.0.2-beta → 0.0.4-beta

package/dist/index.js

@@ -2,13 +2,14 @@
 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 { 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 { sessionUsage, tokensOf } from './usage.js';
@@ -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,23 +56,28 @@ 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 r = await api(loadConfig(process.cwd()), '/v1/memory/wrong', { memo_id: last.memo_id, reason: args.join(' ') || null });
         const what = r.deleted
             ? 'deleted (2 people said wrong)'
             : r.steps_broken
@@ -96,17 +102,35 @@ else if (cmd === 'code') {
     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 (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 +147,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,7 +167,7 @@ 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,
             why: opt('--why') ?? null,
@@ -157,4 +181,4 @@ else if (cmd === 'decide') {
     }
 }
 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, 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,26 @@ 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/) : [];
+    const add = files
+        .map((f) => '/' + relative(root, 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 +82,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 +111,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 +137,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 +175,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 +183,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,25 +208,135 @@ 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,
+            windowsHide: true,
             encoding: 'utf8',
         })
-        : spawnSync(claude, args, { encoding: 'utf8' });
-    run(['mcp', 'remove', '--scope', 'local', 'arcroom']); // none yet is fine
-    return run(['mcp', 'add', '--scope', 'local', 'arcroom', '--', NODE, entry, 'mcp']).status === 0;
+        : spawnSync(claude, args, { encoding: 'utf8', windowsHide: true });
+    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) {
@@ -201,8 +377,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();

package/dist/loop.js

@@ -12,9 +12,17 @@ const stable = (v) => Array.isArray(v)
 export function signature(tool, input) {
     return createHash('sha256').update(`${tool}\0${stable(input)}`).digest('hex').slice(0, 16);
 }
-/** True when the last LOOP_LIMIT-1 calls were all this same call. */
-export function isLoop(recent, sig) {
-    return recent.length >= LOOP_LIMIT - 1 && recent.slice(-(LOOP_LIMIT - 1)).every((s) => s === sig);
+// Read-only status checks an agent repeats while it waits (CI, a deploy, a container): polling, not a loop, when there
+// is a wait between them. Anything else repeated is still blocked on the 3rd identical call in a row.
+const POLL = /^(?:sleep \d+\s*(?:&&|;)\s*)?(?:gh (?:run|pr|workflow) (?:view|watch|list|checks|status)|gh pr checks|git (?:status|log|fetch)|kubectl (?:get|describe|rollout status)|docker (?:ps|logs)|curl\b|Start-Sleep\b)/i;
+export const POLL_GAP_MS = 10_000;
+export const isPoll = (tool, input) => (tool === 'Bash' || tool === 'PowerShell') && POLL.test(String(input?.command ?? '').trim());
+/** True when the last LOOP_LIMIT-1 calls were all this same call, and it is not a status check polled with a wait. */
+export function isLoop(recent, sig, poll = false, now = Date.now()) {
+    const last = recent.slice(-(LOOP_LIMIT - 1)).map((c) => (typeof c === 'string' ? { sig: c, at: 0 } : c));
+    if (last.length < LOOP_LIMIT - 1 || !last.every((c) => c.sig === sig))
+        return false;
+    return !(poll && now - last[last.length - 1].at >= POLL_GAP_MS);
 }
 /** Path of a per-session state file under ~/.arcroom/sessions. */
 export function sessionFile(session, suffix = '') {
@@ -27,9 +35,9 @@ export function checkLoop(session, tool, input) {
     const file = sessionFile(session);
     const recent = existsSync(file) ? JSON.parse(readFileSync(file, 'utf8')) : [];
     const sig = signature(tool, input);
-    if (isLoop(recent, sig)) {
+    if (isLoop(recent, sig, isPoll(tool, input))) {
         return `ArcRoom loop guard: this exact ${tool} call already ran ${LOOP_LIMIT - 1} times in a row. Don't repeat it; try a different approach.`;
     }
-    writeFileSync(file, JSON.stringify([...recent, sig].slice(-(LOOP_LIMIT - 1))));
+    writeFileSync(file, JSON.stringify([...recent, { sig, at: Date.now() }].slice(-(LOOP_LIMIT - 1))));
     return undefined;
 }

package/dist/mcp.js

@@ -7,9 +7,11 @@ import { hostname } from 'node:os';
 import { relative, resolve } from 'node:path';
 import { createInterface } from 'node:readline';
 import { api, isOff, keyRefused, loadConfig } from './home.js';
+import { hooksHere, setUpHere } from './scope.js';
+import { keepForLater, unreachable, WRITES } from './pending.js';
 import { codeNoteBody } from './code.js';
 import { defuse, MEMORY_NOTE } from './fence.js';
-import { localFile } from './fresh.js';
+import { localFile, lf } from './fresh.js';
 import { ICONS } from './logo.js';
 import { withRoute } from './route.js';
 const INTENT = "The subtask in standard form 'verb object: qualifiers', lowercase, no filler words. " +
@@ -224,7 +226,7 @@ const PATHS = {
     remember: '/v1/memory/remember',
     code_note: '/v1/code/note',
 };
-const sha256 = (file) => createHash('sha256').update(readFileSync(file)).digest('hex');
+const sha256 = (file) => createHash('sha256').update(lf(readFileSync(file))).digest('hex');
 /** {"file:<path>": sha256} for files the answer depends on; a missing file is recorded as "missing". */
 export function fileDeps(paths, cwd) {
     return Object.fromEntries(paths.map((p) => {
@@ -251,7 +253,11 @@ export async function handle(method, params, call, ctx) {
                 protocolVersion: params?.protocolVersion ?? '2025-06-18',
                 capabilities: { tools: {} },
                 serverInfo: { name: 'arcroom', title: 'ArcRoom', version: '0.0.0', websiteUrl: 'https://arcroomai.com', icons: ICONS },
-                instructions: 'Code changes are recorded automatically from the session; do not call these tools for them. Check find_task before a question, lookup or analysis someone could reuse (split_task when a request has several parts); claim_task, then complete_task when you do one yourself. Save a lasting fact or decision with remember; after you understand a folder, save one line about it with code_note. Run a part that has route.model with the Agent tool on that model.',
+                instructions: isOff(ctx.cwd)
+                    ? 'ArcRoom is switched off for this repo (arcroom off): its tools do nothing here.'
+                    : !hooksHere(ctx.cwd)
+                        ? 'No ArcRoom hooks run for this client, so nothing is recorded on its own. Check find_task before a task, a question, a lookup or analysis someone could reuse (split_task when a request has several parts); claim_task, then complete_task with what you did, including code changes, when you finish one. Save a lasting fact or decision with remember; after you understand a folder, save one line about it with code_note.'
+                        : 'Code changes are recorded automatically from the session; do not call these tools for them. Check find_task before a question, lookup or analysis someone could reuse (split_task when a request has several parts); claim_task, then complete_task when you do one yourself. Save a lasting fact or decision with remember; after you understand a folder, save one line about it with code_note. Run a part that has route.model with the Agent tool on that model.',
             };
         case 'ping':
             return {};
@@ -261,18 +267,23 @@ export async function handle(method, params, call, ctx) {
             const path = PATHS[params?.name];
             if (!path)
                 throw { code: -32602, message: `unknown tool ${params?.name}` };
-            if (keyRefused())
+            if (keyRefused(loadConfig(ctx.cwd)))
                 return { content: [{ type: 'text', text: 'ArcRoom is stopped on this machine: its key was revoked or its account deleted. Run arcroom init with a new key.' }], isError: true };
             if (isOff(ctx.cwd))
                 return { content: [{ type: 'text', text: 'ArcRoom is switched off for this repo (arcroom on to use it again).' }], isError: true };
+            if (process.argv.includes('--user') && !setUpHere(ctx.cwd))
+                return { content: [{ type: 'text', text: 'ArcRoom is not set up for this repo: run arcroom init in it once.' }], isError: true };
             // depends_on is only ever built here from real file hashes (fileDeps), never taken from the agent
             const { for: pinFor, depends_on_files, depends_on: _given, ...args } = params.arguments ?? {};
             if (params.name === 'code_note') {
+                const note = codeNoteBody(args, ctx.cwd);
                 try {
-                    const r = await call(path, codeNoteBody(args, ctx.cwd));
+                    const r = await call(path, note);
                     return { content: [{ type: 'text', text: JSON.stringify(r) }] };
                 }
                 catch (err) {
+                    if (unreachable(err))
+                        return keptLater(path, note, ctx.cwd);
                     return { content: [{ type: 'text', text: `ArcRoom error: ${err.message}` }], isError: true };
                 }
             }
@@ -303,6 +314,8 @@ export async function handle(method, params, call, ctx) {
                 // a lookup past its deadline is "nothing found": an error would send the agent off debugging ArcRoom
                 if (params.name === 'find_task' && err.name === 'TimeoutError')
                     return { content: [{ type: 'text', text: JSON.stringify({ match: 'none', note: 'ArcRoom did not answer in time; carry on without it' }) }] };
+                if (WRITES.has(path) && unreachable(err))
+                    return keptLater(path, body, ctx.cwd);
                 return { content: [{ type: 'text', text: `ArcRoom error: ${err.message}` }], isError: true };
             }
         }
@@ -331,8 +344,13 @@ export function sessionCache(call, ms = 5 * 60_000) {
         return r;
     };
 }
+/** A save the API could not be reached for: kept on this laptop and sent when it answers again (pending.ts). */
+function keptLater(path, body, cwd) {
+    keepForLater(path, body, cwd);
+    return { content: [{ type: 'text', text: JSON.stringify({ kept: true, note: 'ArcRoom is offline: saved on this laptop, sent when it is back. Carry on.' }) }] };
+}
 export async function mcp() {
-    const cfg = loadConfig();
+    const cfg = loadConfig(process.cwd()); // one MCP process per session, started in its project
     const call = sessionCache((path, body) => api(cfg, path, body, path === PATHS.find_task ? FIND_DEADLINE_MS : 10_000));
     const branch = git(['rev-parse', '--abbrev-ref', 'HEAD']).stdout?.trim() || null;
     const ctx = { claimant: `${hostname()}:${process.pid}`, branch, cwd: process.cwd() }; // one MCP process per Claude session

package/dist/pending.js

@@ -0,0 +1,47 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { api, ARCROOM_HOME, loadConfig } from './home.js';
+// An agent's save (complete_task, remember, code_note) that could not reach the API waits here, on this laptop, and the
+// uploader sends it once the API answers again, instead of it being lost. Only "could not reach": a timeout may have
+// arrived, and sending it twice could store it twice.
+// ponytail: a complete_task sent after its 10-minute claim ran out is refused and dropped (logged)
+const FILE = join(ARCROOM_HOME, 'pending-writes.jsonl');
+const SENDING = `${FILE}.sending`;
+export const WRITES = new Set(['/v1/tasks/complete', '/v1/memory/remember', '/v1/code/note']);
+export const unreachable = (err) => /^could not reach /.test(err?.message ?? '');
+export function keepForLater(path, body, cwd) {
+    mkdirSync(ARCROOM_HOME, { recursive: true, mode: 0o700 });
+    appendFileSync(FILE, JSON.stringify({ path, body, cwd, at: new Date().toISOString() }) + '\n', { mode: 0o600 });
+}
+/** Sends the saves kept for later: one the API still can't be reached for stays; one it refuses is dropped and returned. */
+export async function sendLater(send = (cwd, path, body) => api(loadConfig(cwd), path, body)) {
+    if (!existsSync(SENDING)) {
+        if (!existsSync(FILE))
+            return { sent: 0, dropped: [] };
+        renameSync(FILE, SENDING); // saves made meanwhile go to a fresh file
+    }
+    const lines = readFileSync(SENDING, 'utf8').split('\n').filter(Boolean);
+    rmSync(SENDING);
+    let sent = 0;
+    const dropped = [];
+    for (const line of lines) {
+        let w;
+        try {
+            w = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        try {
+            await send(w.cwd, w.path, w.body);
+            sent++;
+        }
+        catch (err) {
+            if (unreachable(err))
+                appendFileSync(FILE, line + '\n', { mode: 0o600 });
+            else
+                dropped.push(`${w.path}: ${err.message}`);
+        }
+    }
+    return { sent, dropped };
+}