arcroom 0.0.3-beta → 0.0.4-beta

package/README.md

@@ -21,9 +21,9 @@ npx arcroom init --agent codex     # or cursor, opencode (experimental)
 
 ## What leaves your laptop
 
-Prompts (system reminders removed, secrets redacted, first 1,000 characters), file paths, search patterns, shell commands (first 1,000 characters), URLs and web queries, done-check results, git hashes of the files a turn touched, token counts, and what an agent saves on purpose with ArcRoom's tools. **Never file contents, tool output or edit diffs.** Secret files (`.env`, keys) are skipped.
+Prompts (system reminders removed, secrets redacted, first 1,000 characters), file paths, search patterns, shell commands (first 1,000 characters), URLs and web queries, done-check results, git hashes of the files a turn touched, token counts, and what an agent saves on purpose with ArcRoom's tools. **Never file contents, tool output or edit diffs.** A path to a secret file (`.env`, keys), or a command that names one, leaves only as `[secret file]`.
 
-Every upload waits first in `~/.arcroom/spool.jsonl`, so you can read it before it goes. `arcroom off` stops ArcRoom for one repo on this laptop; `arcroom on` starts it again.
+Every event passes through `~/.arcroom/spool.jsonl` on its way out and is sent within seconds; what was sent is kept for 7 days in `~/.arcroom/sent/`, and `arcroom sent` shows it. `arcroom off` stops ArcRoom for one repo on this laptop, including anything still queued for it; `arcroom on` starts it again.
 
 ## If the API is down
 
@@ -37,7 +37,11 @@ Hooks never block a session. Memory lookup gives up after 3 seconds, the prompt
 | `arcroom whoami` | who the key belongs to |
 | `arcroom doctor` | checks the key, the API, the hooks in this folder and the uploader, and prints the fix for each problem |
 | `arcroom off` / `arcroom on` | stop or restart ArcRoom for this repo |
-| `arcroom checks` / `arcroom checks approve <code>` | read and approve the done-checks in `.arcroom.json` |
+| `arcroom flush` | waits until everything queued was sent: the last step of a CI job (exits 1 if it could not) |
+| `arcroom sent [YYYY-MM-DD] [--all]` | what this laptop sent that day (kept 7 days), exactly as sent with `--all` |
+| `arcroom init --everywhere` | also cover every other clone and worktree of the repos you set up (Claude Code user settings) |
+| `arcroom uninstall [--all]` | take ArcRoom out of this project for every agent; `--all` also deletes `~/.arcroom` |
+| `arcroom checks` / `arcroom checks approve <code>` | read and approve the done-checks in `.arcroom.json` (in CI, where there is no terminal: set `ARCROOM_APPROVE_CHECKS=<code>` in the job's environment) |
 | `arcroom wrong [memo id] [reason]` | report a memory that was wrong |
 | `arcroom decide "<choice>" --why ...` | record a team decision |
 | `arcroom rule [--tag t] [--max-hits n] [--idle-days d]` | team rules for when memory expires |

package/dist/code.js

@@ -159,3 +159,35 @@ export function codeNoteBody(args, cwd) {
         ...(args.ttl_hours ? { ttl_hours: args.ttl_hours } : {}),
     };
 }
+/** Another agent's claim on this file (its edits claim a file for 10 minutes), as the reason an edit waits; else undefined. */
+export function clashNote(claims, rel, branch, now = new Date()) {
+    const c = (claims ?? []).find((c) => c?.k === rel);
+    if (!c)
+        return undefined;
+    const where = c.branch && c.branch !== branch ? `on ${c.branch}: a merge conflict if you both change it` : 'same branch';
+    return (`ArcRoom: ${short(c.by)}'s ${c.agent ?? 'agent'} is editing ${rel} right now (${minutes(c.since, now)} min, ${where}). ` +
+        'Check with them, or work on something else first. To edit it anyway, make this edit again.');
+}
+/**
+ * Before this session's first edit of a file: another agent editing that same file right now, as the reason the edit
+ * waits once (the agent sees it; the same edit again goes through). One lookup per file per session; any failure is no clash.
+ * ponytail: someone who starts on the file after your first edit shows up at your next prompt (the code map), not here
+ */
+export async function editClash(cfg, session, cwd, file, timeoutMs = 1000) {
+    if (typeof file !== 'string' || !cwd || !cfg.apiKey)
+        return undefined;
+    const s = codeSetup(cwd);
+    if (!s || s.mode !== 'standard')
+        return undefined;
+    const rel = repoPath(s.root, file, cwd);
+    if (!rel || rel === '.')
+        return undefined;
+    const seenFile = sessionFile(session, '.clash');
+    const seen = existsSync(seenFile) ? JSON.parse(readFileSync(seenFile, 'utf8')) : [];
+    if (seen.includes(rel))
+        return undefined;
+    writeFileSync(seenFile, JSON.stringify([...seen, rel].slice(-500)));
+    const branch = currentBranch(s.root);
+    const look = await api(cfg, '/v1/code/look', { repo: repoKey(s), branch, nodes: [dirOf(rel)], session }, timeoutMs).catch(() => undefined);
+    return clashNote(look?.claims, rel, branch);
+}

package/dist/daemon.js

@@ -4,8 +4,10 @@ import { join } from 'node:path';
 import { blindEvent, codeSetup, repoKey, repoPath } from './blind.js';
 import { prefetchCode } from './code.js';
 import { EDIT_TOOLS } from './done.js';
-import { api, ARCROOM_HOME, keyRefused, loadConfig } from './home.js';
+import { api, ARCROOM_HOME, isOff, keyRefused, loadConfig, offRepos } from './home.js';
 import { serveLookups } from './lookup.js';
+import { sendLater } from './pending.js';
+import { logSent } from './sent.js';
 import { redact, rememberSecrets } from './redact.js';
 import { branches, syncTree } from './tree.js';
 const SPOOL = join(ARCROOM_HOME, 'spool.jsonl');
@@ -18,7 +20,7 @@ const BATCH = 200; // events per upload
 const READ_MAX = 4 * 1024 * 1024; // bytes read per tick
 const IDLE_MS = 3000;
 /** Takes complete lines from the queue text: assigns each session's next seq and redacts secrets. */
-export function toBatch(text, seq, max = BATCH, shape = (e) => e) {
+export function toBatch(text, seq, max = BATCH, shape = (e) => e, off = offRepos()) {
     const next = { ...seq };
     const events = [];
     let consumed = 0;
@@ -37,6 +39,8 @@ export function toBatch(text, seq, max = BATCH, shape = (e) => e) {
         }
         if (e?.v !== 1)
             continue; // raw lines from the first hook version
+        if (isOff(e.cwd, off))
+            continue; // queued before `arcroom off`: never sent
         const n = next[e.session] ?? 0;
         next[e.session] = n + 1;
         rememberSecrets(e.cwd); // the second pass knows each project's .env values too
@@ -68,8 +72,27 @@ export function rotate(state, spool = SPOOL, sending = SENDING) {
     }
     return state;
 }
-/** Sends the next batch from the queue. The offset only moves after the server accepted it. */
-async function drainOnce(cfg) {
+/** Events grouped by the key their folder sends with (a repo can have its own key); each group is sent on its own. */
+export function byKey(events, cfgOf) {
+    const groups = new Map();
+    for (const e of events) {
+        const cfg = cfgOf(e.cwd);
+        const g = groups.get(cfg.apiKey) ?? { cfg, events: [] };
+        g.events.push(e);
+        groups.set(cfg.apiKey, g);
+    }
+    return [...groups.values()];
+}
+/** Sends the next batch from the queue. The offset only moves after the server accepted it (a resent event is ignored). */
+async function drainOnce(def) {
+    const cfgs = new Map();
+    const cfgOf = (cwd) => {
+        if (!cwd)
+            return def;
+        if (!cfgs.has(cwd))
+            cfgs.set(cwd, loadConfig(cwd));
+        return cfgs.get(cwd);
+    };
     const saved = readJson(STATE, { offset: 0, seq: {} });
     const state = rotate(saved);
     if (state !== saved)
@@ -85,19 +108,20 @@ async function drainOnce(cfg) {
     const { events, consumed, seq } = toBatch(text, state.seq, BATCH, withCode);
     if (consumed === 0)
         return 0;
-    if (events.length) {
-        const result = await api(cfg, '/v1/ingest', { events }, 30_000);
+    for (const g of byKey(events, cfgOf)) {
+        const result = await api(g.cfg, '/v1/ingest', { events: g.events }, 30_000);
         if (result.rejected)
-            log(`server rejected ${result.rejected} of ${events.length} events`);
+            log(`server rejected ${result.rejected} of ${g.events.length} events`);
+        logSent(g.events); // what left the laptop, as sent: arcroom sent
     }
     writeFileSync(STATE, JSON.stringify({ offset: state.offset + Buffer.byteLength(text.slice(0, consumed)), seq }));
     // a turn ended or a session started in a repo: send what changed in its tree (after the events, so claims land first)
     for (const cwd of new Set(events.filter((e) => e.type === 'turn.end' || e.type === 'run.start').map((e) => e.cwd).filter(Boolean)))
-        await syncRepo(cfg, String(cwd)).catch((err) => log(`tree sync: ${err}`));
+        await syncRepo(cfgOf(String(cwd)), String(cwd)).catch((err) => log(`tree sync: ${err}`));
     // a session started: its first prompt's code map, fetched now (not awaited: the queue keeps moving)
     for (const e of events)
         if (e.type === 'run.start' && e.cwd)
-            prefetchCode(cfg, String(e.cwd), String(e.session)).catch((err) => log(`prefetch: ${err}`));
+            prefetchCode(cfgOf(String(e.cwd)), String(e.cwd), String(e.session)).catch((err) => log(`prefetch: ${err}`));
     return events.length;
 }
 // Code wing (Standard): which repo, branch and folder an edit is in, cached per folder for a minute.
@@ -163,6 +187,11 @@ export async function daemon() {
             sent = await drainOnce(cfg);
             if (sent)
                 log(`sent ${sent} events`);
+            const later = await sendLater(); // agents' saves kept while the API could not be reached
+            if (later.sent)
+                log(`sent ${later.sent} saves kept while offline`);
+            for (const d of later.dropped)
+                log(`a save kept while offline was refused: ${d}`);
         }
         catch (err) {
             log(String(err)); // offline or server down: events stay queued, retried next tick
@@ -195,6 +224,19 @@ export function ensureDaemon(entry) {
         return;
     spawn(process.execPath, [entry, 'daemon'], { detached: true, stdio: 'ignore', windowsHide: true }).unref();
 }
+/** Bytes in the queue the daemon has not sent yet (the moved-aside file's rest, then the new queue). */
+export function unsent(state = readJson(STATE, { offset: 0, seq: {} }), spool = SPOOL, sending = SENDING) {
+    const size = (f) => (existsSync(f) ? statSync(f).size : 0);
+    return existsSync(sending) ? Math.max(0, size(sending) - state.offset) + size(spool) : Math.max(0, size(spool) - state.offset);
+}
+/** `arcroom flush`: the last step of a CI job. Waits until the daemon has sent everything queued; false after the timeout. */
+export async function flush(entry, timeoutMs = 60_000) {
+    ensureDaemon(entry);
+    for (const until = Date.now() + timeoutMs; Date.now() < until; await new Promise((r) => setTimeout(r, 500)))
+        if (!unsent())
+            return true;
+    return false;
+}
 /** Called from init: stops a running daemon so the next hook starts the updated one. */
 export function stopDaemon() {
     if (!isRunning())

package/dist/doctor.js

@@ -1,26 +1,12 @@
-import { existsSync, readFileSync, statSync } from 'node:fs';
+import { existsSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { isRunning } from './daemon.js';
 import { isApproved, loadChecks, readApprovals } from './done.js';
 import { api, apiUrl, ARCROOM_HOME, isOff, keyRefused, loadConfig } from './home.js';
-// where `arcroom init` wires each agent in a project
-const AGENT_FILES = [
-    ['Claude Code', join('.claude', 'settings.local.json')],
-    ['Codex', join('.codex', 'hooks.json')],
-    ['Cursor', join('.cursor', 'hooks.json')],
-    ['OpenCode', join('.opencode', 'plugins', 'arcroom.js')],
-];
-// the runtime under ~/.arcroom, or under ARCROOM_HOME when that is set
-const runtimePath = join(ARCROOM_HOME, 'runtime').replaceAll('\\', '/');
-const ours = (file) => {
-    if (!existsSync(file))
-        return false;
-    const text = readFileSync(file, 'utf8').replaceAll('\\\\', '/').replaceAll('\\', '/');
-    return text.includes('.arcroom/runtime') || text.includes(runtimePath);
-};
+import { AGENT_FILES, laptopWide, ours } from './scope.js';
 export async function doctor(cwd = process.cwd()) {
     const checks = [];
-    const cfg = loadConfig();
+    const cfg = loadConfig(cwd);
     if (!cfg.apiKey)
         return [{ ok: false, what: 'no key on this laptop', fix: 'arcroom init (key: web app, Settings → API keys)' }];
     checks.push({ ok: true, what: `key ${cfg.apiKey.slice(0, 8)}… in ${join(ARCROOM_HOME, 'config.json')}` });
@@ -49,7 +35,9 @@ export async function doctor(cwd = process.cwd()) {
     const wired = AGENT_FILES.filter(([, f]) => ours(join(cwd, f))).map(([agent]) => agent);
     checks.push(wired.length
         ? { ok: true, what: `this folder is set up for ${wired.join(', ')}` }
-        : { ok: false, what: 'no agent in this folder runs ArcRoom hooks', fix: 'arcroom init (or arcroom init --agent codex|cursor|opencode) here' });
+        : laptopWide(cwd)
+            ? { ok: true, what: 'laptop-wide hooks cover this repo (arcroom init --everywhere)' }
+            : { ok: false, what: 'no agent in this folder runs ArcRoom hooks', fix: 'arcroom init (or arcroom init --agent codex|cursor|opencode) here' });
     if (isOff(cwd))
         checks.push({ ok: 'warn', what: 'ArcRoom is switched off for this repo on this laptop', fix: 'arcroom on' });
     const spool = join(ARCROOM_HOME, 'spool.jsonl');

package/dist/done.js

@@ -2,8 +2,10 @@ import { createHash } from 'node:crypto';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { hashFiles } from './fresh.js';
+import { git } from './git.js';
 import { ARCROOM_HOME } from './home.js';
 import { sessionFile } from './loop.js';
+import { projectOf } from './session.js';
 // Finish line: on Stop, if this turn edited files, the project's done-checks (.arcroom.json "doneChecks") must have passed
 // since the last edit. The hook never runs them itself: it blocks the stop and asks the agent to run them with its own
 // Bash tool, so the agent's permission prompt shows every run (a test file or package script the agent just edited can
@@ -12,6 +14,8 @@ import { sessionFile } from './loop.js';
 // Checks are asked for only once the person approved these exact commands for this folder (`arcroom checks approve`):
 // a cloned repo, a pull request or an agent's edit that adds or changes them asks for nothing until then.
 export const EDIT_TOOLS = new Set(['Edit', 'Write', 'MultiEdit', 'NotebookEdit']);
+/** The tools a done-check can run in: Bash, and PowerShell on Windows. */
+export const SHELL_TOOLS = new Set(['Bash', 'PowerShell']);
 export const MAX_BLOCKS = 2;
 const MAX_PASSED = 50;
 const FILE_TOOLS = new Set(['Read', ...EDIT_TOOLS]);
@@ -22,15 +26,16 @@ const succeeded = (r) => typeof r === 'string'
     : !(r && typeof r === 'object' && (r.interrupted || r.is_error || r.isError || [r.exit_code, r.exitCode, r.returncode].some((c) => typeof c === 'number' && c !== 0)));
 /** True when this Bash command ran the check: as written, or last after `cd … &&` / `;`. */
 export const ranCheck = (command, check) => {
-    const c = check.trim();
-    return command === c || command.endsWith(`&& ${c}`) || command.endsWith(`; ${c}`);
+    const one = (s) => s.trim().replace(/\s+/g, ' '); // extra spaces don't make it a different command
+    const [cmd, c] = [one(command), one(check)];
+    return cmd === c || cmd.endsWith(`&& ${c}`) || cmd.endsWith(`; ${c}`);
 };
 /**
  * Records an edit when this tool call changes files, every file the turn reads or writes (for their hashes), and every
  * Bash command that succeeded since the last edit (a done-check the agent ran).
  */
 export function track(state, raw) {
-    if (raw.hook_event_name === 'PostToolUse' && raw.tool_name === 'Bash') {
+    if (raw.hook_event_name === 'PostToolUse' && SHELL_TOOLS.has(raw.tool_name)) {
         const command = String(raw.tool_input?.command ?? '').trim();
         const passed = state.passed ?? [];
         if (!command || command.length > 500 || passed.includes(command) || passed.length >= MAX_PASSED || !succeeded(raw.tool_response))
@@ -62,11 +67,13 @@ export function decide(pending, blocks) {
     return blocks < MAX_BLOCKS ? 'block' : 'partial';
 }
 export function blockReason(pending, cwd) {
-    return (`ArcRoom done-checks: before you stop, run ${pending.length > 1 ? 'each of these' : 'this'} with your Bash tool from ${cwd}, ` +
+    return (`ArcRoom done-checks: before you stop, run ${pending.length > 1 ? 'each of these' : 'this'} with your shell tool (Bash or PowerShell) from ${cwd}, ` +
         `exactly as written, and fix anything that fails:\n${pending.map((c) => `- \`${c}\``).join('\n')}`);
 }
+/** The repo's top folder: .arcroom.json lives there, so the checks hold in every subfolder and worktree. */
+const rootOf = (cwd) => git(['rev-parse', '--show-toplevel'], { cwd }).stdout?.trim() || cwd;
 export function loadChecks(cwd) {
-    const file = join(cwd, '.arcroom.json');
+    const file = join(rootOf(cwd), '.arcroom.json');
     if (!existsSync(file))
         return [];
     const checks = JSON.parse(readFileSync(file, 'utf8')).doneChecks;
@@ -83,21 +90,26 @@ export function readApprovals() {
         return {};
     }
 }
-/** True only when these exact commands were approved for this folder. */
-export const isApproved = (cwd, checks, approvals) => approvals[resolve(cwd)] === checksHash(checks);
+/** Approvals are per repo, so every clone, worktree and subfolder of it on this laptop shares one. */
+const repoOf = (cwd) => projectOf(rootOf(cwd));
+/** True only when these exact commands were approved for this repo (or, before approvals were per repo, this folder).
+ *  In CI there is no terminal to approve in: ARCROOM_APPROVE_CHECKS=<the code arcroom checks prints>, set in the job's own
+ *  environment (an agent cannot set it for the hook), approves the same exact commands. */
+export const isApproved = (cwd, checks, approvals, ci = process.env.ARCROOM_APPROVE_CHECKS) => [repoOf(cwd), resolve(cwd)].some((k) => approvals[k] === checksHash(checks)) ||
+    (!!ci && ci.length >= 8 && checksHash(checks).startsWith(ci));
 /** `arcroom checks approve <code>`: the person approves the folder's done-checks they were shown (`code` = the first
  *  8 characters of their hash, printed by `arcroom checks`); null when the file no longer holds those checks. */
 export function approveChecks(cwd, code) {
     const checks = loadChecks(cwd);
     if (code.length < 8 || !checksHash(checks).startsWith(code))
         return null;
-    const approvals = { ...readApprovals(), [resolve(cwd)]: checksHash(checks) };
+    const approvals = { ...readApprovals(), [repoOf(cwd)]: checksHash(checks) };
     mkdirSync(ARCROOM_HOME, { recursive: true, mode: 0o700 });
     writeFileSync(APPROVED, JSON.stringify(approvals, null, 2) + '\n', { mode: 0o600 });
     return checks;
 }
 const read = (file) => (existsSync(file) ? JSON.parse(readFileSync(file, 'utf8')) : { edited: false, blocks: 0 });
-/** PreToolUse / PostToolUse: remember what this turn edited, and the Bash commands that passed after that. */
+/** PreToolUse / PostToolUse: remember what this turn edited, and the shell commands that passed after that. */
 export function noteEdit(raw) {
     const file = sessionFile(String(raw.session_id), '.done');
     const state = read(file);

package/dist/events.js

@@ -1,5 +1,5 @@
 import { hostname } from 'node:os';
-import { redact, redactText } from './redact.js';
+import { redact, redactText, sensitiveFile } from './redact.js';
 const MAX = 4000; // ponytail: fixed per-field cap so one huge tool output can't bloat the queue; make configurable if reports need full outputs
 /** Keeps small values as they are; replaces big ones with a preview and their size, redacted before the cut. */
 export function clip(value) {
@@ -18,7 +18,9 @@ const KEEP = ['file_path', 'notebook_path', 'path', 'pattern', 'command', 'url',
 const SHORT = 1000; // prompts and commands; the server reads the first 300 (prompt) and 200 (command) chars
 // redacted before the cut, so a secret the cut splits is still found
 const short = (v) => (typeof v === 'string' ? redactText(v).slice(0, SHORT) : v);
-const metadata = (input) => Object.fromEntries(KEEP.filter((k) => input && typeof input === 'object' && input[k] !== undefined).map((k) => [k, k === 'command' ? short(input[k]) : input[k]]));
+// a path to a secret file (.env, keys) or a command that names one leaves only as "[secret file]"
+const kept = (k, v) => (sensitiveFile(v) ? '[secret file]' : k === 'command' ? short(v) : v);
+const metadata = (input) => Object.fromEntries(KEEP.filter((k) => input && typeof input === 'object' && input[k] !== undefined).map((k) => [k, kept(k, input[k])]));
 // what Claude Code adds to a prompt (<system-reminder> blocks) is not what the person typed
 const typed = (prompt) => short(String(prompt ?? '').replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '').trim());
 /** Maps one Claude Code hook payload to an ArcRoom run event. */
@@ -37,7 +39,9 @@ export function toArcroomEvent(raw, at = new Date()) {
             return { ...base, type: 'prompt', data: { prompt: typed(raw.prompt) } };
         case 'PreToolUse': {
             const ours = String(raw.tool_name).startsWith(OURS);
-            return { ...base, type: 'tool.start', data: { id: raw.tool_use_id, tool: raw.tool_name, input: clip(ours ? raw.tool_input : metadata(raw.tool_input)) } };
+            // a call made inside a subagent says which one, so its steps are not read as the main agent's
+            const subagent = raw.agent_id ? { subagent: String(raw.agent_type ?? raw.agent_id).slice(0, 80) } : {};
+            return { ...base, type: 'tool.start', data: { id: raw.tool_use_id, tool: raw.tool_name, input: clip(ours ? raw.tool_input : metadata(raw.tool_input)), ...subagent } };
         }
         case 'PostToolUse':
             return { ...base, type: 'tool.end', data: { id: raw.tool_use_id, tool: raw.tool_name, ...(String(raw.tool_name).startsWith(OURS) ? { output: clip(raw.tool_response) } : {}) } };

package/dist/fresh.js

@@ -1,17 +1,21 @@
 import { git } from './git.js';
 import { createHash } from 'node:crypto';
 import { readFileSync, realpathSync, statSync } from 'node:fs';
-import { extname, isAbsolute, join, relative, resolve } from 'node:path';
+import { basename, extname, isAbsolute, join, relative, resolve } from 'node:path';
 // Is a stored memory still true for this checkout? Steps keep the git blob hash of each file they touched (taken on
 // the laptop at the end of the turn; hashes only, no content). Before handing steps over, each file is looked up here:
 //   same hash   → as it was
 //   other hash  → changed since: kept, flagged so the agent checks before trusting it
-//   missing     → renamed if a file here has the saved hash (followed to its new path); otherwise deleted (dropped)
+//   missing     → renamed if a file here has the saved hash (followed to its new path), or moved and edited if exactly
+//                 one file here has its name (followed, flagged as changed); otherwise deleted (dropped)
 //                 when the task read it, or created by the task when it only wrote it (still a target)
 // More than half the files it read deleted: the steps are stale and nothing is handed over. All local, no network.
 /** Git's blob id for a file's bytes (the same id `git hash-object` prints), so it works with or without git. */
 export const blobHash = (bytes) => createHash('sha1').update(`blob ${bytes.length}\0`).update(bytes).digest('hex');
-const MAX_SCAN = 2000; // ponytail: rename search hashes candidate files; index blob ids instead if repos get huge
+/** A text file's bytes with Windows line ends as LF, so a Windows and a Mac checkout of it hash the same; a binary file
+ *  (one with a NUL byte) stays as it is. Every hash saved with steps or answers is taken over these bytes. */
+export const lf = (bytes) => (bytes.includes(0) ? bytes : Buffer.from(bytes.toString('latin1').replaceAll('\r\n', '\n'), 'latin1'));
+const MAX_SCAN = 2000; // files hashed when git's index has no match (no git, untracked files, CRLF committed)
 const MAX_READ = 5_000_000;
 /**
  * A path from stored memory (anyone with a workspace key can write it) as a file inside `cwd` that may be read, or
@@ -40,24 +44,39 @@ export function checkout(cwd) {
     const hash = (p) => {
         const file = localFile(cwd, p);
         try {
-            return file ? blobHash(readFileSync(file)) : undefined;
+            return file ? blobHash(lf(readFileSync(file))) : undefined;
         }
         catch {
             return undefined;
         }
     };
+    // git's index: every tracked file with its blob id, in one call and without opening a file, at any repo size
+    let index;
+    const tracked = () => (index ??= new Map((git(['ls-files', '-s', '-z'], { cwd, timeout: 5000 }).stdout ?? '').split('\0').flatMap((e) => {
+        const m = /^\d+ ([0-9a-f]{40,64}) \d\t([\s\S]+)$/.exec(e);
+        return m ? [[m[2], m[1]]] : [];
+    })));
     let files;
     const list = () => {
         if (files)
             return files;
-        const r = git(['ls-files', '--cached', '--others', '--exclude-standard'], { cwd, timeout: 1500 });
+        const r = git(['ls-files', '--cached', '--others', '--exclude-standard'], { cwd, timeout: 5000 });
         files = r.status === 0 ? (r.stdout ?? '').split('\n').filter(Boolean).slice(0, MAX_SCAN) : [];
         return files;
     };
     return {
         exists: (p) => !!localFile(cwd, p),
         hash,
+        sameName: (like) => {
+            const name = basename(like);
+            const hits = [...tracked().keys()].filter((p) => basename(p) === name && !!localFile(cwd, p));
+            return hits.length === 1 ? hits[0] : undefined;
+        },
         find: (want, like) => {
+            // a tracked file git already knows by this id, still the same on disk
+            for (const [p, id] of tracked())
+                if (id === want && hash(p) === want)
+                    return p;
             // same extension first (a move keeps it), then everything; only files that exist and are not huge
             const ext = extname(like);
             const pool = [...list().filter((f) => extname(f) === ext), ...list().filter((f) => extname(f) !== ext)];
@@ -96,9 +115,14 @@ export function freshen(steps, saved = {}, probe) {
                 changed.add(f);
             continue;
         }
-        const to = saved[f] && probe.find ? probe.find(saved[f], f) : undefined;
-        if (to && !named.has(to))
+        const same = saved[f] && probe.find ? probe.find(saved[f], f) : undefined;
+        // ponytail: moved-and-edited is found by its name only; one renamed and edited at once still reads as deleted
+        const to = same ?? probe.sameName?.(f);
+        if (to && !named.has(to)) {
             moved.set(f, to);
+            if (!same)
+                changed.add(to);
+        }
         else if (read.has(f))
             deleted.add(f);
         else
@@ -130,7 +154,7 @@ export function hashFiles(cwd, paths) {
         if (!rel || rel.startsWith('..'))
             continue;
         try {
-            out[rel] = blobHash(readFileSync(join(cwd, rel)));
+            out[rel] = blobHash(lf(readFileSync(join(cwd, rel))));
         }
         catch {
             /* deleted during the turn: nothing to remember */

package/dist/git.js

@@ -35,3 +35,14 @@ export function git(args, opts = {}) {
     const r = spawnSync(bin, [...SAFE, ...args], { encoding: 'utf8', windowsHide: true, ...opts });
     return { status: r.status, stdout: r.stdout };
 }
+/** Project id shared by everyone on the repo: its git remote without protocol/credentials/.git, else the folder path. */
+export function projectOf(cwd) {
+    const remote = git(['config', '--get', 'remote.origin.url'], { cwd }).stdout?.trim();
+    if (!remote)
+        return cwd.replaceAll('\\', '/').toLowerCase();
+    return remote
+        .replace(/^[a-z+]+:\/\/(?:[^@/]+@)?/i, '') // https://user:token@host/... -> host/...
+        .replace(/^[^@]+@([^:]+):/, '$1/') // git@host:owner/repo -> host/owner/repo
+        .replace(/\.git$/, '')
+        .toLowerCase();
+}

package/dist/home.js

@@ -1,6 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, isAbsolute, join, relative } from 'node:path';
+import { projectOf } from './git.js';
 import { redact } from './redact.js';
 /**
  * ArcRoom's folder: ~/.arcroom, or ARCROOM_HOME (tests, a second setup). A repo can set environment variables for the
@@ -35,10 +36,14 @@ export function setOff(root, off, file = OFF_FILE) {
 }
 // ArcRoom API (the Oracle server behind Caddy). A local API: arcroom init --url http://localhost:8787
 export const DEFAULT_URL = 'https://api.arcroomai.com';
-/** ~/.arcroom/config.json written by `arcroom init`. */
-export function loadConfig() {
+/** ~/.arcroom/config.json written by `arcroom init`; with `cwd`, the key of the repo it is in (its own, else the default). */
+export function loadConfig(cwd) {
     const file = join(ARCROOM_HOME, 'config.json');
-    return { url: DEFAULT_URL, apiKey: '', ...(existsSync(file) ? JSON.parse(readFileSync(file, 'utf8')) : {}) };
+    const saved = { url: DEFAULT_URL, apiKey: '', ...(existsSync(file) ? JSON.parse(readFileSync(file, 'utf8')) : {}) };
+    if (!cwd || !saved.repos || !Object.keys(saved.repos).length)
+        return saved; // no git call unless some repo has its own key
+    const own = saved.repos[projectOf(cwd)];
+    return own ? { ...saved, apiKey: own.apiKey, workspace: own.workspace } : saved;
 }
 const LOCAL = new Set(['localhost', '127.0.0.1', '[::1]']);
 /** Whether `url` points at this machine (a developer's local API). */

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' }] : []),
+                ...(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)