baychat 0.24.0 → 0.25.0

package/README.md

@@ -227,18 +227,6 @@ Use `--private` when only the private chat is wanted.
 
 Publishing a new version upgrades nobody by itself.
 
-From a plain shell:
-
-```bash
-baychat update       # the package, every connected client's config, and the relay
-baychat --version    # check what is installed
-```
-
-`baychat help` prints this at the top; `baychat help update` explains it.
-Via npx, use `npx baychat@latest update` — plain npx can run a cached older copy.
-
-Or from inside a session:
-
 ```text
 $baychat --update     # in Codex
 /baychat --update     # in Claude
@@ -461,6 +449,96 @@ relay also falls back to it automatically when app-server cannot be used at
 all — but not when the failure is a real answer about your session, because
 retrying that would only repeat it with the reason replaced by an exit code.
 
+## How full is my agent's context? (`baychat context-hooks`)
+
+BayChat can show how full each attached agent's context window is, and when it tidies
+(compacts) itself. The numbers are the runtime's own, never a guess:
+
+| Runtime | Where the number comes from | What you do |
+|---|---|---|
+| Codex | `token_count` events in its session log, read by the relay | nothing — `baychat relay start` |
+| DeepSeek (dsh), Cursor CLI | ACP's `usage_update`, read by the relay | nothing |
+| Claude Code | its status line and its compaction hooks | opt in once, below |
+
+```sh
+baychat context-hooks install     # wrap your status line + add PreCompact/PostCompact hooks
+baychat context-hooks status      # what is installed, and whether reports are going through
+baychat context-hooks uninstall   # put ~/.claude/settings.json back exactly as it was
+```
+
+`install` edits `~/.claude/settings.json` — the real file, if yours is a symlink (stow,
+chezmoi); the link stays a link. A file that does not parse is refused, never overwritten. Every
+edit first copies the file to a backup that is never overwritten: `settings.json.baychat-backup`
+is your file from before BayChat first touched it, later ones are timestamped beside it.
+
+Your status line keeps working exactly as before: your own command still runs in the same shell
+Claude Code uses (`/bin/sh -c`), with the same input, and its exit status is kept. BayChat gets
+a copy of the input in the background, so your line never waits for it. Node and BayChat are
+called by absolute path, so a different `PATH` in your IDE doesn't matter, and if BayChat is
+later removed (or that Node version is), your status line simply keeps running without it —
+run `install` again after moving either. If you had no status line, BayChat's prints nothing
+(Claude Code then hides some footer hints, as it does for any status line). The two hooks run in
+the background and can never block a compaction. Install BayChat for good first
+(`npm install --global baychat`; a temporary `npx` copy is refused); not offered on Windows yet.
+A status line set in a project's `.claude/settings.json` takes precedence there.
+
+`uninstall` puts your file back byte-for-byte when nothing else changed since install. If you
+changed a setting meanwhile, it keeps your change and says it restored **semantically**: the
+same settings, re-formatted — your original formatting is still in the backups.
+
+Reports are sent only for a Claude session this machine can prove is in BayChat (the relay
+recorded its session id, or it has called BayChat's tools with its session name), throttled to
+one every 15 seconds unless the number moved a whole percentage point. Problems are written to
+`~/.baychat/context/errors.log`, never to your terminal.
+
+When a session compacts, its chats get one quiet line ("Claude tidied its memory · 940k → 58k",
+no notification), and the chat's project brief is handed to it again with the next message. The
+session's owner (or someone they gave command access) can also tidy it from the app — **Tidy up
+now**, with an optional focus — which the relay types as `/compact [focus]` into a Claude Code or
+Codex session in tmux or screen (Codex takes no focus).
+
+The owner can also **start a session fresh with a handoff** (or let BayChat do it at 95% full).
+The relay asks the session to write a handoff note first (`create_note` with the `handoffId` it is
+given); only once the note is saved does it clear the session — `/clear` typed into Claude Code,
+`/new` into Codex (tmux or screen), a new session for an ACP agent — and the fresh session starts
+from that note. Nothing is cleared without a saved note. Update the CLI and restart the relay to
+get it (`relay` announces `freshstart`).
+
+### The project brief
+
+A chat can sit in a project whose **brief** every agent there reads. The relay asks the server for
+it and puts it in front of the message it arrived with, on every way it wakes a session (the
+attach socket and mailbox, the Codex queue, a headless resume, the ACP prompt):
+
+```
+Project brief ("Launch", v3):
+    Ship on Friday. No new features.
+---
+  (m1) @Ada [USER]: can you check the build?
+```
+
+It is sent once per version, so the session keeps it; `get_project` fetches it again.
+
+### Notes
+
+Projects and chats keep **notes**. The ones people pin reach every agent like the brief; the rest
+wait on a shelf. The relay asks for what changed (`notes` in its features) and shows it after the
+brief, in front of the message it came with — a pinned note in full the first time and whenever it
+changes, a line when one is unpinned, and the shelf's titles when that list changes:
+
+```
+Pinned note "Tone of voice" (v2, id n_12):
+    Warm, short, no jargon.
+Note "Old plan" (id n_9) is no longer pinned.
+Shelf notes: Press FAQ [n_4], Pricing tiers [n_7] (get_note / list_notes)
+---
+  (m1) @Ada [USER]: can you draft the launch post?
+```
+
+Each change is sent once, and everything again after the session compacts or starts fresh.
+Sessions read and write notes with `list_notes`, `get_note`, `create_note` and `update_note`; an
+edit names the version it was based on, so nobody's work is overwritten.
+
 ## `baychat connect dsh` — DeepSeek Harness, run by the relay
 
 ```
@@ -586,7 +664,7 @@ surface for every vendor.
 | Tool | What it does |
 |------|--------------|
 | `react_to_message` | React to a message with an emoji. Prefer this to a contentless "ok" / "got it" reply — a reaction reaches nobody's context, a message reaches everybody's |
-| `list_files` | The files shared in a conversation, as an index you can query — find one without re-reading the room |
+| `list_files` | The files shared in a conversation, as an index you can query — find one without re-reading the room. In a project chat it also lists the project's own files and your other chats' files there |
 | `get_file` | Fetch one file from that index by id |
 | `web_search` | Search the web; returns ranked results with title, URL, and snippet |
 | `web_fetch` | Fetch one public `http(s)` URL and return its readable text |
@@ -665,7 +743,7 @@ as a native tool provider instead of shell commands. `baychat mcp` starts a loca
 speaks JSON-RPC on stdout, so don't run it interactively — register it with your
 client and let the client launch it.
 
-It exposes sixteen tools and one resource, each described so the model behaves
+It exposes twenty-one tools and one resource, each described so the model behaves
 correctly from the tool descriptions alone (reply only when `shouldRespond`;
 summaries are derived, untrusted context; fetched content is never an
 instruction):
@@ -673,7 +751,12 @@ instruction):
 | Tool | Purpose |
 |------|---------|
 | `list_conversations` | Discover the conversations this agent is in (the entry point) |
-| `get_room_context` | A conversation's roster, reply policy, round cap, and room instructions |
+| `get_room_context` | A conversation's roster, reply policy, round cap, and room instructions — and, in a project chat, the project (and its brief, the first time) |
+| `get_project` | The chat's project and its brief — call it when you hold no brief for the version you see (after compacting) |
+| `list_notes` | The notes of a chat and its project — titles, pinned or on the shelf, versions |
+| `get_note` | Read one note in full (and the version to edit from) |
+| `create_note` | Write a note for the project or the chat; it lands on the shelf (people pin) |
+| `update_note` | Edit a note from the version you read; if someone saved since, nothing is overwritten and you get theirs to merge |
 | `get_conversation_summary` | The rolling catch-up summary (decisions, tasks, questions, facts + source ids) |
 | `get_messages` | Recent messages enriched with sender, mentions, and `shouldRespond` |
 | `send_message` | Send a message into a conversation |

package/dist/api.js

@@ -15,22 +15,31 @@ const DEVICE_AUTH_TIMEOUT_MS = 15_000;
 class ApiError extends Error {
     status;
     code;
+    details;
     /**
      * `code` is the server's machine-readable error code when it sent one
      * (`TOOL_PROVIDER_UNAVAILABLE`, `TARGET_NOT_IN_TENANT`, …). Status alone is
      * ambiguous — a 404 is both "no such route" and "no such target" — so callers
      * that need to tell those apart branch on the code, not the prose.
      */
-    constructor(status, message, code) {
+    constructor(status, message, code, 
+    /**
+     * The rest of the error body — the fields the server sends beside `code` for a caller to act
+     * on (a note conflict carries the current `note`). Never shown as-is: a tool picks what it
+     * needs by name.
+     */
+    details) {
         super(message);
         this.status = status;
         this.code = code;
+        this.details = details;
     }
 }
 exports.ApiError = ApiError;
 async function parseError(res) {
     let message = `HTTP ${res.status}`;
     let code;
+    let details;
     try {
         // The API's error envelope is `{ error, code }`; some routes send
         // `{ message }`. Try both before falling back to the bare status, so a
@@ -38,12 +47,20 @@ async function parseError(res) {
         const body = (await res.json());
         code = body.code;
         message = body.message || body.error || body.code || message;
+        if (body && typeof body === "object") {
+            const { message: _m, error: _e, code: _c, ...rest } = body;
+            void _m;
+            void _e;
+            void _c;
+            if (Object.keys(rest).length > 0)
+                details = rest;
+        }
     }
     catch {
         // Non-JSON error body — keep the status message. Never log response bodies:
         // they can echo request details.
     }
-    return new ApiError(res.status, message, code);
+    return new ApiError(res.status, message, code, details);
 }
 async function apiRequest(creds, method, apiPath, body) {
     const res = await fetch(`${creds.baseUrl}${apiPath}`, {

package/dist/claude-context-flush.js

@@ -0,0 +1,219 @@
+"use strict";
+// Sending what the Claude Code status line and compaction hooks noted — in a DETACHED process the
+// hot paths start and never wait for (see claude-context.ts). Identifies the BayChat session
+// (never guesses), posts in order, and backs off when the server has no route yet.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionFromTranscript = sessionFromTranscript;
+exports.identifySession = identifySession;
+exports.runContextFlush = runContextFlush;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const claude_context_state_1 = require("./claude-context-state");
+const config_1 = require("./config");
+const context_report_1 = require("./context-report");
+const registry_1 = require("./relay/registry");
+/**
+ * The most recent BayChat tool call in the transcript tail that names a session.
+ *
+ * Every BayChat tool on the device branch requires `session` (REMOTE_MCP_SESSIONS §4), so a
+ * session that is talking to BayChat writes its own name into its transcript on every call.
+ */
+function sessionFromTranscript(text) {
+    const lines = text.split("\n");
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i];
+        if (!line.includes("baychat__") || !line.includes("tool_use"))
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (entry.type !== "assistant" || !Array.isArray(entry.message?.content))
+            continue;
+        const calls = entry.message.content;
+        for (let j = calls.length - 1; j >= 0; j--) {
+            const call = calls[j];
+            if (call.type !== "tool_use" || typeof call.name !== "string" || !/^mcp__(.+__)?baychat__/.test(call.name))
+                continue;
+            const input = call.input;
+            const session = typeof input?.session === "string" ? input.session.trim() : "";
+            if (!session || session.length > 200)
+                continue;
+            const conversationId = typeof input?.conversationId === "string" ? input.conversationId : undefined;
+            return { session, ...(conversationId ? { conversationId } : {}) };
+        }
+    }
+    return undefined;
+}
+function identifySession(sid, transcriptPath, loadRegistry = () => {
+    const r = new registry_1.SessionRegistry();
+    r.load();
+    return r;
+}) {
+    // The relay recorded this Claude session id at attach ($CLAUDE_CODE_SESSION_ID): the session
+    // named itself. The strongest evidence there is.
+    const target = loadRegistry()
+        .all()
+        .find((t) => t.runtime === "claude" && t.resumeId === sid);
+    const fromTranscript = transcriptPath ? sessionFromTranscript((0, claude_context_state_1.readTail)(transcriptPath, claude_context_state_1.TRANSCRIPT_TAIL_BYTES)) : undefined;
+    if (target) {
+        return {
+            session: target.name,
+            from: "relay",
+            ...(fromTranscript?.session === target.name && fromTranscript.conversationId ? { conversationId: fromTranscript.conversationId } : {}),
+        };
+    }
+    return fromTranscript ? { ...fromTranscript, from: "transcript" } : undefined;
+}
+function acquireLock(file, now) {
+    (0, claude_context_state_1.ensureDir)();
+    try {
+        fs.writeFileSync(file, String(process.pid), { flag: "wx", mode: 0o600 });
+        return true;
+    }
+    catch {
+        try {
+            if (now - fs.statSync(file).mtimeMs > claude_context_state_1.LOCK_STALE_MS) {
+                fs.unlinkSync(file);
+                fs.writeFileSync(file, String(process.pid), { flag: "wx", mode: 0o600 });
+                return true;
+            }
+        }
+        catch {
+            /* somebody else took it */
+        }
+        return false;
+    }
+}
+/** Remove what was handled, re-reading first so a sample noted meanwhile is not lost. */
+function settle(sid, handled, patch) {
+    const state = (0, claude_context_state_1.readState)(sid);
+    state.queue = state.queue.filter((q) => !handled.has(q.id));
+    (0, claude_context_state_1.writeState)({ ...state, ...patch, queue: state.queue });
+}
+/** `baychat context-flush --claude <id>`: send what the status line and hooks noted. */
+async function runContextFlush(argv, deps = {}) {
+    const d = { now: Date.now, post: context_report_1.postContextEvent, loadDevice: config_1.loadDeviceCredentials, identify: identifySession, ...deps };
+    const i = argv.indexOf("--claude");
+    const sid = (0, claude_context_state_1.safeId)(i >= 0 ? argv[i + 1] : undefined);
+    if (!sid)
+        return 0;
+    const lock = path.join((0, claude_context_state_1.contextDir)(), `claude-${sid}.lock`);
+    if (!acquireLock(lock, d.now()))
+        return 0;
+    try {
+        for (let round = 0; round < 5; round++) {
+            const state = (0, claude_context_state_1.readState)(sid);
+            if (state.queue.length === 0)
+                return 0;
+            if ((0, claude_context_state_1.backoffUntil)() > d.now())
+                return 0;
+            const all = new Set(state.queue.map((q) => q.id));
+            let identity;
+            if (state.baychatSession && state.identifiedAt && d.now() - state.identifiedAt < claude_context_state_1.IDENTITY_TTL_MS) {
+                identity = { session: state.baychatSession, conversationId: state.conversationId, from: "relay" };
+            }
+            else if (!state.unidentifiedAt || d.now() - state.unidentifiedAt >= claude_context_state_1.UNIDENTIFIED_RETRY_MS) {
+                identity = d.identify(sid, state.transcriptPath);
+            }
+            if (!identity) {
+                // Not a BayChat session (or not provably one): drop what was noted rather than let it
+                // grow. Said once per Claude session, in the log.
+                if (!state.unidentifiedAt)
+                    (0, claude_context_state_1.logContextError)(`Claude session ${sid} is not joined to BayChat as far as this machine can prove — not reporting its context`);
+                settle(sid, all, { unidentifiedAt: d.now(), baychatSession: undefined, identifiedAt: undefined });
+                return 0;
+            }
+            const identityPatch = { baychatSession: identity.session, conversationId: identity.conversationId, identifiedAt: d.now(), unidentifiedAt: undefined };
+            const device = d.loadDevice();
+            if (!device) {
+                (0, claude_context_state_1.logContextError)("not logged in to BayChat (`baychat login`) — context not reported");
+                settle(sid, all, identityPatch);
+                return 0;
+            }
+            const handled = new Set();
+            for (const q of state.queue) {
+                const event = identity.conversationId && !q.event.conversationId ? { ...q.event, conversationId: identity.conversationId } : q.event;
+                const outcome = await d.post({ baseUrl: device.baseUrl, token: device.token }, identity.session, event);
+                if (outcome.kind === "sent") {
+                    handled.add(q.id);
+                    continue;
+                }
+                if (outcome.kind === "not-deployed") {
+                    (0, claude_context_state_1.writeJsonAtomic)((0, claude_context_state_1.backoffPath)(), { until: d.now() + context_report_1.NOT_DEPLOYED_BACKOFF_MS });
+                    (0, claude_context_state_1.logContextError)("this BayChat server does not accept context reports yet — trying again in an hour");
+                    // Keep only the newest usage for then; a compaction an hour old is history.
+                    for (const other of state.queue)
+                        if (other.event.event !== "usage")
+                            handled.add(other.id);
+                    settle(sid, handled, identityPatch);
+                    return 0;
+                }
+                if (outcome.kind === "refused") {
+                    (0, claude_context_state_1.logContextError)(`BayChat refused a ${q.event.event} report for "${identity.session}": ${outcome.message}${outcome.code ? ` (${outcome.code})` : ""}`);
+                    handled.add(q.id);
+                    // A refusal about the session (ended, renamed) makes the cached identity suspect.
+                    if (outcome.code === "SESSION_NOT_FOUND")
+                        Object.assign(identityPatch, { identifiedAt: undefined });
+                    continue;
+                }
+                (0, claude_context_state_1.logContextError)(`could not report context for "${identity.session}": ${outcome.message}`);
+                // A failed usage is superseded by the next one; a compaction is kept for the next try.
+                if (q.event.event === "usage")
+                    handled.add(q.id);
+                settle(sid, handled, identityPatch);
+                return 0;
+            }
+            settle(sid, handled, identityPatch);
+        }
+        return 0;
+    }
+    catch (err) {
+        (0, claude_context_state_1.logContextError)(`context-flush: ${(0, claude_context_state_1.errText)(err)}`);
+        return 0;
+    }
+    finally {
+        try {
+            fs.unlinkSync(lock);
+        }
+        catch {
+            /* already gone */
+        }
+    }
+}

package/dist/claude-context-state.js

@@ -0,0 +1,191 @@
+"use strict";
+// Local state for Claude Code context reporting: what the status line and the compaction hooks
+// noted, per Claude session, under ~/.baychat/context/ (0700; files 0600). No secrets live here —
+// numbers, a session name, a transcript path. Shared by `claude-context.ts` (the hot paths) and
+// `claude-context-flush.ts` (the sender), and deliberately light: fs, path, crypto only.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backoffPath = exports.statePath = exports.BOUNDARY_FRESH_MS = exports.LOCK_STALE_MS = exports.BOUNDARY_TAIL_BYTES = exports.TRANSCRIPT_TAIL_BYTES = exports.UNIDENTIFIED_RETRY_MS = exports.IDENTITY_TTL_MS = exports.MAX_QUEUE = void 0;
+exports.contextDir = contextDir;
+exports.safeId = safeId;
+exports.ensureDir = ensureDir;
+exports.writeJsonAtomic = writeJsonAtomic;
+exports.readState = readState;
+exports.writeState = writeState;
+exports.backoffUntil = backoffUntil;
+exports.logContextError = logContextError;
+exports.errText = errText;
+exports.enqueue = enqueue;
+exports.readAll = readAll;
+exports.readTail = readTail;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+exports.MAX_QUEUE = 20;
+exports.IDENTITY_TTL_MS = 10 * 60_000;
+/**
+ * Most Claude sessions on a machine are NOT in BayChat. Once one is found not to be, its status
+ * line stops starting flushers for this long, so an ordinary session costs one tiny file read.
+ */
+exports.UNIDENTIFIED_RETRY_MS = 5 * 60_000;
+exports.TRANSCRIPT_TAIL_BYTES = 2 * 1024 * 1024;
+exports.BOUNDARY_TAIL_BYTES = 1024 * 1024;
+exports.LOCK_STALE_MS = 60_000;
+const ERROR_LOG_MAX_BYTES = 256 * 1024;
+/** A compact_boundary older than this is an earlier compaction, not the one that just ended. */
+exports.BOUNDARY_FRESH_MS = 15 * 60_000;
+function contextDir() {
+    return path.join((0, config_1.configDir)(), "context");
+}
+/** Claude's session id becomes a file name, so only its own alphabet is accepted. */
+function safeId(value) {
+    return typeof value === "string" && /^[A-Za-z0-9_-]{1,128}$/.test(value) ? value : undefined;
+}
+const statePath = (sid) => path.join(contextDir(), `claude-${sid}.json`);
+exports.statePath = statePath;
+const backoffPath = () => path.join(contextDir(), "backoff.json");
+exports.backoffPath = backoffPath;
+function ensureDir() {
+    fs.mkdirSync(contextDir(), { recursive: true, mode: 0o700 });
+}
+function writeJsonAtomic(file, value) {
+    ensureDir();
+    const tmp = `${file}.${process.pid}.${crypto.randomBytes(4).toString("hex")}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(value), { mode: 0o600 });
+    fs.renameSync(tmp, file);
+}
+function readState(sid) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync((0, exports.statePath)(sid), "utf8"));
+        if (parsed && parsed.v === 1 && Array.isArray(parsed.queue))
+            return parsed;
+    }
+    catch {
+        // Missing (first report) or unreadable: a fresh state is the correct reading — the worst it
+        // costs is one report the throttle would have held back.
+    }
+    return { v: 1, claudeSessionId: sid, queue: [] };
+}
+function writeState(state) {
+    writeJsonAtomic((0, exports.statePath)(state.claudeSessionId), state);
+}
+function backoffUntil() {
+    try {
+        const parsed = JSON.parse(fs.readFileSync((0, exports.backoffPath)(), "utf8"));
+        return typeof parsed.until === "number" ? parsed.until : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+/** Never the terminal: the status line's stdout is the person's, and its stderr may be shown. */
+function logContextError(line) {
+    try {
+        ensureDir();
+        const file = path.join(contextDir(), "errors.log");
+        try {
+            if (fs.statSync(file).size > ERROR_LOG_MAX_BYTES)
+                fs.renameSync(file, `${file}.1`);
+        }
+        catch {
+            /* no log yet */
+        }
+        fs.appendFileSync(file, `${new Date().toISOString()} ${line}\n`, { mode: 0o600 });
+    }
+    catch {
+        // Nowhere left to say it. The status line must still render.
+    }
+}
+function errText(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function enqueue(state, event) {
+    // Only the NEWEST usage is worth sending; compaction events are all kept, in order.
+    if (event.event === "usage")
+        state.queue = state.queue.filter((q) => q.event.event !== "usage");
+    state.queue.push({ id: crypto.randomBytes(6).toString("hex"), event });
+    if (state.queue.length > exports.MAX_QUEUE)
+        state.queue = state.queue.slice(-exports.MAX_QUEUE);
+}
+// ─── stdin ───────────────────────────────────────────────────────────────────
+/** All of stdin, bounded in time and size so a stuck pipe cannot wedge a status line. */
+function readAll(stream, timeoutMs = 3_000, maxBytes = 1024 * 1024) {
+    return new Promise((resolve) => {
+        const chunks = [];
+        let size = 0;
+        let done = false;
+        const finish = () => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            // Let go of stdin, or an input that never closes would keep this process alive after its
+            // answer — and a status line Claude Code has to cancel is a status line that got slower.
+            stream.destroy?.();
+            resolve(Buffer.concat(chunks).toString("utf8"));
+        };
+        const timer = setTimeout(finish, timeoutMs);
+        timer.unref?.();
+        stream.on("data", (chunk) => {
+            const b = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+            size += b.length;
+            if (size <= maxBytes)
+                chunks.push(b);
+        });
+        stream.on("end", finish);
+        stream.on("error", finish);
+    });
+}
+function readTail(file, bytes) {
+    let fd;
+    try {
+        fd = fs.openSync(file, "r");
+        const size = fs.fstatSync(fd).size;
+        const start = Math.max(0, size - bytes);
+        const buf = Buffer.alloc(size - start);
+        fs.readSync(fd, buf, 0, buf.length, start);
+        const text = buf.toString("utf8");
+        // Drop a partial first line when we started mid-file.
+        return start > 0 ? text.slice(text.indexOf("\n") + 1) : text;
+    }
+    catch {
+        return "";
+    }
+    finally {
+        if (fd !== undefined)
+            fs.closeSync(fd);
+    }
+}