arcroom 0.0.3-beta → 0.0.5-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

@@ -1,10 +1,9 @@
-import { git } from './git.js';
+import { git, repoPath } from './git.js';
 import { existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { codeSetup, repoKey, repoPath } from './blind.js';
 import { api } from './home.js';
 import { sessionFile } from './loop.js';
-import { readTree } from './tree.js';
+import { codeSetup, readTree, repoKey } from './tree.js';
 // Code wing at prompt time: before the agent starts, the Room tells it what it knows about the folders this request
 // is about: a summary still true for the folder's current hash, or "changed since its summary", who is editing what
 // right now (on this branch or another), notes other agents left, and what teammates changed since the last prompt.
@@ -159,3 +158,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

@@ -1,13 +1,15 @@
 import { spawn } from 'node:child_process';
 import { appendFileSync, closeSync, existsSync, openSync, readFileSync, readSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { blindEvent, codeSetup, repoKey, repoPath } from './blind.js';
+import { repoPath } from './git.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';
+import { branches, codeSetup, repoKey, syncTree } from './tree.js';
 const SPOOL = join(ARCROOM_HOME, 'spool.jsonl');
 const SENDING = join(ARCROOM_HOME, 'spool.sending.jsonl');
 const STATE = join(ARCROOM_HOME, 'daemon-state.json');
@@ -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,22 +108,23 @@ 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.
+// Code wing: which repo, branch and folder an edit is in, cached per folder for a minute.
 const setups = new Map();
 function setupFor(cwd) {
     const hit = setups.get(cwd);
@@ -122,14 +146,12 @@ export function codeTag(e, s, branch) {
     const dir = node.includes('/') ? node.slice(0, node.lastIndexOf('/')) : '.';
     return { ...e, data: { ...e.data, code: { repo: repoKey(s), branch, node, dir, agent: e.data.agent ?? 'claude' } } };
 }
-/** Each event as it may leave this laptop: a Blind repo's with paths scrambled and contents dropped, an edit tagged. */
+/** Each event as it leaves this laptop: an edit tagged with where it is. */
 export function withCode(e, setup = setupFor) {
-    if (typeof e.cwd !== 'string')
+    if (typeof e.cwd !== 'string' || e.type !== 'tool.start')
         return e;
     const { s, branch } = setup(e.cwd);
-    if (s?.mode === 'blind')
-        return blindEvent(e, s);
-    return e.type === 'tool.start' ? codeTag(e, s, branch) : e;
+    return codeTag(e, s, branch);
 }
 const lastSync = new Map();
 async function syncRepo(cfg, cwd) {
@@ -163,6 +185,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 +222,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

@@ -1,6 +1,6 @@
 import { spawnSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
-import { delimiter, isAbsolute, join } from 'node:path';
+import { delimiter, isAbsolute, join, relative } from 'node:path';
 // Every git call ArcRoom makes runs inside a repo it did not write, often with no one watching (hooks, the daemon).
 // Two ways such a repo could run its own code through those calls, both closed here:
 //   - Windows starts a git.exe sitting in the working folder before the one on PATH: git is looked up on PATH once,
@@ -35,3 +35,24 @@ 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();
+}
+/** The repo's top folder, or undefined outside a git repo. */
+export const gitRoot = (cwd) => {
+    const r = git(['rev-parse', '--show-toplevel'], { cwd, timeout: 3000 });
+    return r.status === 0 ? r.stdout?.trim() : undefined;
+};
+/** A path (absolute, or relative to `from`) as a repo path: "src/billing/tax.ts", or undefined outside the repo. */
+export function repoPath(root, p, from = root) {
+    const rel = relative(root, isAbsolute(p) ? p : join(from, p)).replaceAll('\\', '/');
+    return rel.startsWith('..') || isAbsolute(rel) ? undefined : rel || '.';
+}

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). */