claude-code-infinite 1.0.21 → 1.0.24

package/README.md

@@ -17,10 +17,27 @@ follows it down to the original messages.
 * **Search across every session.** Claude can find what was decided, tried or ruled out in any of
   your past sessions, by exact words or by meaning, filtered by project and date
 * **Browse each session's MemTree** in your browser, from the link `ccc` prints in the terminal
-* **Replaces `/compact` without losing the thread.** In a blind-graded benchmark, MemTree matched
-  full-context Claude Code and beat Claude Code's built-in `/compact` by 20 points
-  ([details](#long-session-benchmark))
+* **Never loses anything vs Claude Code.** Sessions are sent word for word until near the context
+  limit; past it, MemTree matched full context (69 vs 69) and beat `/compact` by 20 ([benchmark](#long-session-benchmark))
 * **Unlimited-length sessions**, with relevant past information recalled automatically
+* **A local proxy, so no slowdown.** Requests go straight from your machine to Anthropic and
+  MemTree indexes in the background; only the occasional compression step, when a session
+  outgrows the context budget, waits on MemTree
+
+The magic starts past the context limit. Keep one session going for days and it learns how you
+work: your priorities, the nuances of your projects, your company and your environment. Where
+`/compact` would wipe that detail, MemTree keeps it, so the thread becomes an expert in you. Let it
+orchestrate dozens of subagents on your behalf.
+
+> [!IMPORTANT]
+> Requires a Claude Pro or Max subscription.
+
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/crizCraig/claude-code-infinite/main/docs/images/benchmark-dark.svg">
+    <img width="600" alt="Long-session benchmark, judged score out of 100: Claude Code Infinite 69, full context 69, /compact 49" src="https://raw.githubusercontent.com/crizCraig/claude-code-infinite/main/docs/images/benchmark-light.svg">
+  </picture>
+</p>
 
 ## Search across sessions
 
@@ -67,14 +84,11 @@ tokens; `/compact`'s exclude the one-time `/compact` step. This is one task fami
 
 * [node.js 20.3 or newer](https://nodejs.org/en/download/)
 * [Claude Code (the terminal version)](https://code.claude.com/docs/en/quickstart)
-* **Claude Subscription** - optional but highly recommended as this offers up to 1000x cost savings vs Anthropic's API pricing
+* **A Claude Pro or Max subscription**
 
-## Setup
+<sub>Also works with an Anthropic API key, but that's far costlier than Pro or Max.</sub>
 
-> [!TIP]
-> No Claude subscription? Use an Anthropic API key exactly as with vanilla Claude Code
-> (`ANTHROPIC_API_KEY` or a Console login). `ccc` forwards it unchanged to api.anthropic.com, and
-> you pay Anthropic per token.
+## Setup
 
 1. Install (Node ≥ 20.3; no git needed)
   ```bash
@@ -96,6 +110,40 @@ The tool supports multiple environments (this selects the MemTree compression AP
 
 Each environment maintains its own separate API key.
 
+## Commands
+
+Type these inside a `ccc` session (the `ccc:` prefix is optional). `ccc` answers them
+locally, so they cost no model turn.
+
+| Command | What it does |
+| --- | --- |
+| `/ccc:memtree` | Lists the MemTree commands and links your usage dashboard. |
+| `/ccc:memtree-view` | Shows the link to this session's MemTree page. |
+| `/ccc:memtree-compact [tokens]` | Compacts the session on your next message (to half the budget, or a target such as `400k`) and keeps the compressed history. |
+| `/ccc:memtree-compact off` | Goes back to sending the conversation whole. |
+
+From a shell or script (no session needed):
+
+| Command | What it does |
+| --- | --- |
+| `ccc link <session-id>` | Prints the session's newest MemTree page URL on stdout, one line and nothing else. `--json` prints `{session_id, url, tree, updated_at}` instead (`updated_at` is the session's last activity). Exit status 0 printed, 1 no saved key or the server could not be reached (5 s timeout), 2 bad invocation, 3 the session has no MemTree yet (or no session with that id on your key; stderr says which). Only your own sessions (those of your saved key) are found. `ccc staging link` / `ccc local link` use that environment's key. |
+| `ccc fetch <memtree-url>` | Prints one of your MemTree pages as JSON, using your saved key. |
+
+Environment variables, set when launching `ccc`:
+
+| Variable | What it does |
+| --- | --- |
+| `CCC_COMPACT_TARGET=500k` | Compaction target for every session (useful for headless `-p` runs); `off` starts every session with compaction off. |
+| `CCC_MEMTREE_MCP=0` | Turns off the `memtree` MCP tools ([details](#memory-tools)), in interactive and headless (`-p`) runs. |
+| `CCC_MEMTREE_LINK` | Where the MemTree link appears: `turn` (default, end of a turn with a new page), `message` (under every reply), `stop` (end of every turn), `success` (only after an optimized turn), or `off`. |
+| `CCC_AUTO_COMPACT=1` | Restores Claude Code's own auto-compaction setting ([details](#claude-code-auto-compaction)). |
+| `CCC_NO_UPDATE_CHECK=1` | Turns off the update check, and with it automatic updates ([details](#upgrading)). |
+| `CCC_DISABLE_AUTOUPDATE=1` | Keeps the update notice but never installs ([details](#automatic-updates)). |
+| `CCC_NO_DIAGNOSTICS=1` | Turns off diagnostics ([details](#diagnostics)). So do `DO_NOT_TRACK=1`, Claude Code's `DISABLE_TELEMETRY=1` or `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1`, and `"diagnostics": false` in `~/.claude-code-infinite/config.json`. |
+
+Links are clickable in terminals that support OSC 8 hyperlinks (iTerm2, Ghostty, WezTerm,
+kitty, VS Code, JetBrains, Windows Terminal); elsewhere you get the plain URL.
+
 ## Claude Code auto-compaction
 
 `ccc` disables Claude Code's automatic conversation compaction for the Claude process it launches. MemTree manages the context sent to the model, so letting Claude Code independently summarize the full local transcript can compact a conversation MemTree already reduced. Manual `/compact` remains available.
@@ -105,6 +153,13 @@ above a fixed 100k-token threshold, even when the active model has a 1M window
 and auto-compaction is disabled. `ccc` suppresses that resume-time
 recommendation as well; it does not disable the manual `/compact` command.
 
+With auto-compaction off, Claude Code still refuses a request itself, without
+sending it, once its own estimate reaches the window minus 23k (977k on a 1M
+window). MemTree compresses at 900k, so a single large tool round could reach that
+refusal before `ccc` ever saw the request. `ccc` sets
+`CLAUDE_CODE_BLOCKING_LIMIT_OVERRIDE` (unless you exported your own) so such a
+request reaches the proxy, which compresses it mid-turn.
+
 A session whose last response reached the verified local refusal threshold
 (for example one sent whole while MemTree was unavailable) would otherwise be
 refused locally with "Context limit reached" on every prompt after a resume.
@@ -141,28 +196,45 @@ Claude Code ──▶ localhost proxy (ccc)
 - Anthropic requests go directly from the local proxy to api.anthropic.com using the authentication Claude Code supplied. PolyChat never sees that credential or Anthropic traffic.
 - If MemTree is unreachable, slow, or your MemTree plan needs payment, `ccc` degrades to a transparent passthrough so your session is never interrupted.
 
-### Inline notices
+### Diagnostics
 
-In interactive sessions, `ccc` reports these MemTree states as display-only lines in Claude Code:
+`ccc` sends a few diagnostics to MemTree so we can see why a session fails to start or stalls:
 
-- `✓ MemTree · conversation optimized · ~813k → 408k tokens`, with the session's newest completed MemTree page on its own line below it and a blank line before the answer, when a compressed turn reflects new indexing (MemTree's index covers more of the conversation than before) or a newly finished MemTree page. The before-count is `ccc`'s size estimate for the request that would otherwise have been sent (MemTree's `usage.raw_prompt_tokens` when `ccc` has none); the after-count is Anthropic's reported compressed input, estimated from bytes until usage arrives. Counts under a million are whole thousands, larger ones one decimal (`1.3m`). Without both counts, or when the result is not smaller, the line reads just `✓ MemTree · conversation optimized`. The line is green when terminal color is available, and plain when `NO_COLOR` or a monochrome terminal is configured. `ccc` uses the standard ANSI green foreground sequence and Node's capability detection, so the same path works in ANSI terminals on macOS/Linux and supported Windows consoles.
-- `⚠ MemTree degraded — this turn ran uncompressed` when a blocking compression call fails or times out.
-- `⚠ MemTree is off — payment required…` once when compression and indexing are disabled for payment.
-- `• MemTree` with the page on its own line below it, once at the end of a user turn, when the turn used a MemTree index whose link has not been shown yet (the first one of the session, then each newly finished index), unless the turn's success line already showed it. The line comes from the `Stop` hook, so it lands after the turn's last message. When MemTree passed the conversation through whole because it already fits the model's budget, the label line reads `• MemTree · /memtree-compact to compact session`. The URL always gets a line to itself, so a long link does not wrap the label or note. The displayed link follows the server's newest completed tree for this session, preserving its pinned namespace and own/served selection. If that lookup is unavailable, it falls back to the compression page; that page can show a completed prefix while its own tree builds. Open it in a browser, read it as JSON with `ccc fetch <url>`, or, from an agent inside the session, `GET $ANTHROPIC_BASE_URL/memtree/<short id>.json` on the loopback proxy without handling the key. Every MemTree call carries Claude Code's session id, so `GET $ANTHROPIC_BASE_URL/memtree/sessions/<session id>.json` lists every page from one session, newest first (the session id is the `--resume` id and the name of the transcript under `~/.claude/projects/`). `/memtree` lists the MemTree commands. Type `/memtree-view` at any time to print the session's latest link. Both also end with a `• Usage` link to your usage dashboard on polychat (`/usage` on the same host as MemTree: `https://app.polychat.co/usage` in production, the staging or local host otherwise); it opens only with your browser signed in to polychat as the same account. `/memtree-compact` is MemTree's replacement for Claude Code's `/compact`: your next message is sent compressed to half the budget (or `/memtree-compact 400k` for another target), and from then on the session follows the compaction rules under [How it works](#how-it-works) with that target. `/memtree-compact off` goes back to sending the conversation whole. `CCC_COMPACT_TARGET=500k` sets the target of every compaction for every session from launch, for benchmarks and headless (`-p`) runs, where the slash command is unavailable; it does not compact by itself, the budget still decides when, and `/memtree-compact off` still turns compaction off for one session. `CCC_COMPACT_TARGET=off` starts every session in the `/memtree-compact off` state instead (`/memtree-compact [N]` still turns it back on). `ccc` answers these commands locally, so they cost no model turn and nothing is added to the conversation; the compaction setting lasts for the life of the `ccc` process. When a session starts and already has a page, which in practice means a resumed one (`ccc --resume`, or `/resume` inside a running session), its latest link is shown right away: `ccc` remembers the newest page per session in `~/.claude-code-infinite/memtree-links.json` (most recent 200 sessions) and a `SessionStart` hook prints it. `CCC_MEMTREE_LINK` changes where the link appears: `turn` (default), `message` (under every finished assistant message, green when the index is new, dim otherwise), `stop` (every turn, on `Stop`), `success` (only on the line below `✓ MemTree · conversation optimized`), or `off`.
+- versions (ccc, Claude Code, Node), how ccc was installed (npm, npx, linked), OS and CPU
+  architecture, terminal type and locale;
+- lifecycle events (first run, sign-in prompt shown, key accepted or rejected, session start,
+  the MemTree-paused notice shown, update hint or background update result);
+- errors as codes, status numbers, sizes and timings (an Anthropic 401, a MemTree 402, a
+  compression timeout).
 
-The newest-tree lookup runs in the background with a 60-second cache, at most eight outstanding fetches, and one 10-second deadline across at most 32 finder pages. `/memtree-view` and resume hooks wait at most 2.5 seconds. Servers with the finder session-ID search (polychat `0202eaa` and later, including reviewed `c67cadb`) use `/v1/memtree/sessions?q=<id>`, following cursors and accepting only the exact session ID. A missing endpoint falls back to the compression page and is not retried for 30 minutes. The older exact route `/usage/memtree/sessions/<id>.json` accepts the bearer key, but excludes index-only calls and does not report completed trees, so it cannot supply this link. No verified server version provides a suitable exact newest-completed-tree lookup yet.
+Never sent: your prompts or any conversation content, file paths, project or repository names,
+hostnames, usernames, environment values, keys or tokens, or error message text. Each event is
+checked against a fixed allowlist on your machine before it is queued, and again by the server.
+They are tied to your MemTree key when you have one, otherwise to a random install id in
+`~/.claude-code-infinite/install_id`. Sending is batched in the background and never slows a
+request; a failed send is dropped.
 
-`/memtree-view` (and the usage link of `/memtree`) emits OSC 8 hyperlinks only when the ccc proxy has a TTY and detects iTerm2 3.1+ (`TERM_PROGRAM=iTerm.app` plus its version), JetBrains (`TERMINAL_EMULATOR=JetBrains-JediTerm`), Ghostty, WezTerm, VS Code, kitty, or Windows Terminal (`WT_SESSION`). Detection happens in the proxy, before hook output is relayed through pipes. `NO_COLOR`, dumb/unknown terminals, tmux/screen, and non-TTY output get a plain URL. Apple Terminal also gets the full visible URL for its normal URL handling. The success and Stop notices retain their visible URLs, and a late lookup cannot repeat the same page already linked by that turn's success notice.
+Turn diagnostics off with any of: `CCC_NO_DIAGNOSTICS=1`, `"diagnostics": false` in
+`~/.claude-code-infinite/config.json`, `DO_NOT_TRACK=1`, or Claude Code's own
+`DISABLE_TELEMETRY=1` / `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1`.
 
-**The end of a session.** MemTree indexes once about 10k new tokens build up, and each index call carries a request's messages, so a session's last turns, including the reply it ended with (often where a PR was opened), would never be indexed. `ccc` therefore sends one final index call per session: the main conversation plus that last reply, read from Claude Code's transcript, flagged so MemTree indexes the tail even below its minimum (at most once per conversation per 30 minutes; two conversations with an identical first message share that allowance). It goes out 10 minutes after a turn ends with no new request, or at exit for the 3 most recent sessions, inside the 2-second background drain; `-p` and non-TTY runs, which have no `Stop` hook, get it at exit. A failure is logged and never changes `ccc`'s exit code. Until then, `read_lines` with `"tail": true` reads the messages after the tree verbatim. When `ccc` runs inside another Claude Code session, the inner Claude Code writes no transcript unless `CLAUDE_CODE_FORCE_SESSION_PERSISTENCE=1` is set; without it the final index still covers everything through the last request, just not the final reply.
+### Memory tools
 
-`ccc` installs a minimal session-only Claude Code plugin using the repeatable `--plugin-dir` option. Its `MessageDisplay` hook changes only what the terminal renders and never alters stored assistant content; a `Stop` hook supplies a fallback for tool-only responses. That fallback may be saved by Claude Code as non-model hook UI metadata, but it is excluded from resumed model and recap requests. Notices are never added to model context, and Anthropic responses are left untouched with one exception: the hidden recap request Claude Code sends when you come back to an idle session gets a final `• MemTree` / `<url>` text block, so the recap ends with the link (not added when `CCC_MEMTREE_LINK=off`). Claude Code keeps that recap as a UI-only system entry, never as conversation content, and the block is skipped when it would push the recap past Claude Code's 400-character cap, and `-p`/non-TTY output is left unchanged. Legacy marker cleanup remains for transcripts created by older `ccc` releases. The payment state can also produce a separate terminal warning at startup.
+Every `ccc` session, interactive or headless (`-p` and non-TTY runs), gets a small MCP server, `memtree`, with four read-only tools (see [Search across sessions](#search-across-sessions)): `mcp__memtree__search` (`query`; optional `tree`, `"current"` for this session or omitted for all of your sessions; `mode` `text` (default, free) or `vector` (meaning, first page charged); `project`, `since`, `until`, `cursor`, `limit` (default 10, at most 50)), `mcp__memtree__read_node` (`node`, an address `<tree>#<id>` from search, or `id` with optional `tree`: summary, path from the root, children, leaf line range), `mcp__memtree__read_lines` (a leaf's `node`, or `block`, `start`, `end` with optional `tree`: exact transcript lines, at most 400 lines / 40k characters per call) (with `tail: true` instead, the newest messages after the tree that are not indexed yet) and `mcp__memtree__list` (your sessions, most recently active first; `since`, `until`, `project`, `q`, `cursor`, `limit`). Other sessions' trees are named explicitly by reference and authorized by your MemTree key. This session's tree (`tree: "current"`, or no `tree` on `read_node`/`read_lines`) is the one the current request was served from: the server asks the `ccc` proxy for `GET $ANTHROPIC_BASE_URL/memtree/current?session=<id>` (only that session's compression source page, or its stored source page on resume; `current.json?session=<id>` returns the page itself). Completed pages are cached. If the proxy temporarily serves an older prefix while a newer tree is indexing, the tools reuse that prefix during a 45-second cooldown, then check the page again. `ccc` registers it with `--mcp-config=<temp file>`, which keeps working under `--strict-mcp-config`, and pre-allows the four read-only tools; `CCC_MEMTREE_MCP=0` turns it off. The MCP process requires `CLAUDE_CODE_SESSION_ID` and checks that both the pointer and page belong to it. If Claude Code retains an MCP process with an old session ID after `/clear` or a session switch, reconnect the MCP server with the current session ID; it cannot infer a new identity from another session using the proxy. Your own choices win: if your `--mcp-config` already names a server `memtree`, `ccc` adds and pre-allows nothing (if it runs `ccc memtree-mcp`, or `ccc staging memtree-mcp`, the tools work as usual); `--allowedTools` lists are added together, so yours is kept and only the four memtree tools are pre-allowed; tools named by `--disallowedTools` (one tool, `mcp__memtree`, or `mcp__memtree__*`) are neither pre-allowed nor advertised. With `--continue`, Claude Code starts MCP servers under a new session id before it switches to the continued session, so this session's tree fails closed (`list` and searches across sessions still work); use `--resume <id>` instead. Whenever the tools are configured, compress calls carry `x-memtree-tools: search,read_node,read_lines,list` so MemTree tells the model how to use them.
 
-Claude Code currently displays the original assistant text instead of `MessageDisplay` replacements while verbose mode is enabled. Turn verbose mode off to see the inline MemTree line.
+### Headless / agents
 
-### Memory tools
+`ccc -p` works like `claude -p`, so an agent or orchestrator can drive it. Keep one Claude Code session per long-lived agent and resume it on every call, so MemTree keeps compacting and indexing one growing conversation:
 
-Interactive `ccc` sessions also get a small MCP server, `memtree`, with four read-only tools (see [Search across sessions](#search-across-sessions)): `mcp__memtree__search` (`query`; optional `tree`, `"current"` for this session or omitted for all of your sessions; `mode` `text` (default, free) or `vector` (meaning, first page charged); `project`, `since`, `until`, `cursor`, `limit` (default 10, at most 50)), `mcp__memtree__read_node` (`node`, an address `<tree>#<id>` from search, or `id` with optional `tree`: summary, path from the root, children, leaf line range), `mcp__memtree__read_lines` (a leaf's `node`, or `block`, `start`, `end` with optional `tree`: exact transcript lines, at most 400 lines / 40k characters per call) (with `tail: true` instead, the newest messages after the tree that are not indexed yet) and `mcp__memtree__list` (your sessions, most recently active first; `since`, `until`, `project`, `q`, `cursor`, `limit`). Other sessions' trees are named explicitly by reference and authorized by your MemTree key. This session's tree (`tree: "current"`, or no `tree` on `read_node`/`read_lines`) is the one the current request was served from: the server asks the `ccc` proxy for `GET $ANTHROPIC_BASE_URL/memtree/current?session=<id>` (only that session's compression source page, or its stored source page on resume; `current.json?session=<id>` returns the page itself). Completed pages are cached. If the proxy temporarily serves an older prefix while a newer tree is indexing, the tools reuse that prefix during a 45-second cooldown, then check the page again. `ccc` registers it with `--mcp-config=<temp file>`, which keeps working under `--strict-mcp-config`, and pre-allows the four read-only tools; `CCC_MEMTREE_MCP=0` turns it off. The MCP process requires `CLAUDE_CODE_SESSION_ID` and checks that both the pointer and page belong to it. If Claude Code retains an MCP process with an old session ID after `/clear` or a session switch, reconnect the MCP server with the current session ID; it cannot infer a new identity from another session using the proxy. Print (`-p`) and non-TTY runs get it only when their own `--mcp-config` names a server `memtree` run by `ccc memtree-mcp` (add `--allowedTools mcp__memtree__search,mcp__memtree__read_node,mcp__memtree__read_lines,mcp__memtree__list`). Whenever the tools are configured, compress calls carry `x-memtree-tools: search,read_node,read_lines,list` so MemTree tells the model how to use them.
+```bash
+ccc -p --resume <session-id> --output-format json "…"
+```
+
+Start the session with `ccc -p --session-id <uuid> "…"` (or take `session_id` from the first JSON result). Never run two `ccc` processes on one session at the same time: both would append to the same transcript. Headless runs have the [memory tools](#memory-tools) with no extra flags (`CCC_MEMTREE_MCP=0` turns them off; they can read all of the sessions your MemTree key owns, so give each user of a shared agent platform their own key). Stdout carries only Claude Code's output, so `--output-format json` and `stream-json` parse as with `claude`; `ccc`'s own lines (banner, mode, request log path) go to stderr. `--mcp-config` takes several values, so pass your own as `--mcp-config=<file>` or put the prompt before it; otherwise it swallows a prompt that follows it.
+
+To show an agent's memory after a run, `ccc link "$sid"` prints the session's newest MemTree page URL (exit 3 when it has no tree yet). It can trail the run by one call: a `-p` run's newest tree is built as it exits.
+
+The full guide for agent platforms (setup, output parsing, memory tools, tree links, older versions) is [docs/headless.md](docs/headless.md).
 
 ## How it works
 
@@ -173,7 +245,7 @@ Interactive `ccc` sessions also get a small MCP server, `memtree`, with four rea
 
 When you send a message, we retrieve relevant details and summaries from the prior messages in your thread. These details and summaries populate a **memory message**. Following the memory message, we append a compressed version of your recent message history. The resulting context-window is dramatically smaller, allowing Claude to process your request with much greater efficacy, lower latency, and reduced cost.
 
-**Compaction keeps a stable prefix.** While a conversation fits the model's budget (800k tokens for Opus 5.5), it is sent whole. When a request reaches the budget, `ccc` compresses it once, to half the budget (or your `/memtree-compact N`), and keeps those compressed bytes as the session's prefix. Every later request, human turns included, is that same prefix followed by the messages that came after it, verbatim, with no compression call (MemTree still indexes in the background). Because the prefix does not change, Anthropic reads it from the prompt cache on every turn after the one that compacted, instead of writing the whole compressed context again. `ccc` compresses again only when prefix plus newer turns reach the budget (measured from the size Anthropic reported for the previous request, plus an estimate for what was added), or when the messages the prefix stands for change (rewind, edit, fork, `/clear`). If that recompression fails, the turn is sent on the old prefix rather than the whole history. The prefix is also kept on disk, one file per session under `~/.claude-code-infinite/stable-prefixes/` (mode 600 in a private directory, at most 64 sessions and 256 MB, oldest dropped first), so the first turn after `ccc --resume` rides it instead of waiting on a fresh compression. A stored prefix belongs to the MemTree backend and key that wrote it (identified by a hash, never the key itself) and is never used with another. It is used only if the resumed history still matches what it replaced; a main-thread history that no longer matches discards it, while side requests (such as Claude Code's web-search helper) leave it alone. Only the main thread's prefix is stored, never a subagent's. The budget is the one MemTree reports for the model; until the server reports one, `ccc` uses 80% of the model's context window. `CCC_BUDGET_TOKENS=60k` overrides it for testing. Every `requests.jsonl` line carries the `pid` of the `ccc` process that wrote it, which tells apart concurrent sessions sharing the log. The same rule holds inside a tool loop, so a long single turn (a headless `-p` run, or a long agentic loop) is compacted as it grows rather than only when you next type: each tool request under the budget goes out with no compression call, the one that reaches it is compressed once and becomes the stable prefix, and later tool requests and your next message ride that prefix until it reaches the budget again. `requests.jsonl` shows the `compaction` of each main-thread human turn and of every tool turn (budget, its source, the size estimate, and the reason for a compaction: `budget`, `prefix-mismatch`, `manual` or `target-change`); a human turn sent on the stable prefix is `turnType: "followup-prefix"`, a tool turn `tool-memory` (on its route) or `tool-prefix` (on the prefix directly), and a tool turn that compacted `tool-recompressed`.
+**Compaction keeps a stable prefix.** While a conversation fits the model's budget (900k tokens for Opus 5.5, where plain Claude Code would auto-compact at 967k), it is sent whole. When a request reaches the budget, `ccc` compresses it once, to half the budget (or your `/memtree-compact N`), and keeps those compressed bytes as the session's prefix. Every later request, human turns included, is that same prefix followed by the messages that came after it, verbatim, with no compression call (MemTree still indexes in the background). Because the prefix does not change, Anthropic reads it from the prompt cache on every turn after the one that compacted, instead of writing the whole compressed context again. `ccc` compresses again only when prefix plus newer turns reach the budget (measured from the size Anthropic reported for the previous request, plus an estimate for what was added), or when the messages the prefix stands for change (rewind, edit, fork, `/clear`). If that recompression fails, the turn is sent on the old prefix rather than the whole history. The prefix is also kept on disk, one file per session under `~/.claude-code-infinite/stable-prefixes/` (mode 600 in a private directory, at most 64 sessions and 256 MB, oldest dropped first), so the first turn after `ccc --resume` rides it instead of waiting on a fresh compression. A stored prefix belongs to the MemTree backend and key that wrote it (identified by a hash, never the key itself) and is never used with another. It is used only if the resumed history still matches what it replaced; a main-thread history that no longer matches discards it, while side requests (such as Claude Code's web-search helper) leave it alone. Only the main thread's prefix is stored, never a subagent's. The budget is the one MemTree reports for the model; until the server reports one, `ccc` uses 90% of the context window on Opus 5.5, Opus 5, Opus 4.8 and Fable 5 and 5.1 with a 1M window, and 80% otherwise. `CCC_BUDGET_TOKENS=60k` overrides it for testing. Every `requests.jsonl` line carries the `pid` of the `ccc` process that wrote it, which tells apart concurrent sessions sharing the log. The same rule holds inside a tool loop, so a long single turn (a headless `-p` run, or a long agentic loop) is compacted as it grows rather than only when you next type: each tool request under the budget goes out with no compression call, the one that reaches it is compressed once and becomes the stable prefix, and later tool requests and your next message ride that prefix until it reaches the budget again. `requests.jsonl` shows the `compaction` of each main-thread human turn and of every tool turn (budget, its source, the size estimate, and the reason for a compaction: `budget`, `prefix-mismatch`, `manual` or `target-change`); a human turn sent on the stable prefix is `turnType: "followup-prefix"`, a tool turn `tool-memory` (on its route) or `tool-prefix` (on the prefix directly), and a tool turn that compacted `tool-recompressed`.
 
 That compressed context stays in force for the rest of the turn: the tool loop it kicks off, and the matching Count Tokens calls, are routed through the same compressed prefix. The Count Tokens part matters — Claude Code sizes its context from those replies, so counting the uncompressed history would make it auto-compact a conversation memory had already shrunk. A mismatched or resumed conversation shape drops the route rather than grafting one session's prefix onto another.
 
@@ -258,27 +330,40 @@ For `ccc --resume <id>`, an automatic, best-effort repair can unblock a transcri
 
 ## Releasing
 
-Releases are staged by GitHub Actions through npm Trusted Publishing (OIDC), so no npm
-token, passkey or browser is needed to build and upload them, and each one is approved by a
-maintainer before it goes live:
-
-1. On a clean `main`, run `./publish.sh` (or `./publish.sh minor` / `major`). It builds,
-   checks that `dist/` is committed, runs `npm version`, and pushes the commit and the
-   `vX.Y.Z` tag.
-2. The tag push runs [`.github/workflows/publish.yml`](.github/workflows/publish.yml): `npm ci`,
-   the test suite with `NO_COLOR=1` and with `FORCE_COLOR=1`, a check that the rebuilt
-   `dist/` matches the commit and that the tag equals `package.json`'s version, then
-   `npm stage publish --provenance`.
-3. Approve the staged version (2FA) on
-   [npmjs.com](https://www.npmjs.com/package/claude-code-infinite) under the **Staged
-   Packages** tab, or with `npm stage list claude-code-infinite` and
-   `npm stage approve <stage-id>`. Until then it is not installable.
-
-The trusted publisher on npmjs.com is bound to the workflow file name `publish.yml` with no
-GitHub environment, and allows only staged publishing; renaming the workflow breaks it.
-`./publish.sh --local` is the fallback: it publishes directly from your machine with npm web
-auth, then pushes the commit and tag; the workflow still tests that tag but skips staging,
-since the version is already published.
+Releases are published by GitHub Actions through npm Trusted Publishing (OIDC): no npm
+token, passkey or staging step. Each one waits for approval of the `npm` GitHub environment
+(reviewer: crizCraig). That approval is a GitHub permission: anything holding a maintainer's
+GitHub token with `repo` scope (including an agent using `gh`) can grant it, so keep such
+tokens out of untrusted sessions.
+
+1. [release-please](https://github.com/googleapis/release-please) keeps a **Release x.y.z**
+   pull request open on `main` ([`.github/workflows/release.yml`](.github/workflows/release.yml)).
+   It bumps `package.json`, `package-lock.json` and `.release-please-manifest.json` and adds
+   a `CHANGELOG.md` entry, and it updates itself on every push to `main`.
+2. Merge it when you want to release. release-please then tags `vX.Y.Z`, creates the GitHub
+   release and starts [`.github/workflows/publish.yml`](.github/workflows/publish.yml) on the
+   tag. That checks that the tagged commit is on `main` and that the tag equals
+   `package.json`'s version, runs the full CI matrix (`ci.yml`), and checks that the committed
+   `dist/` matches a fresh build.
+3. Approve the `npm` environment (one tap in the GitHub mobile app, or **Review deployments**
+   on the run). The job then runs `npm publish --provenance --access public`.
+
+Commits: release-please only opens the PR, and only lists a commit in the changelog, for
+conventional prefixes: `feat:`, `fix:`, `perf:`, `refactor:`, `revert:` or `deps:` (a scope
+is fine, e.g. `fix(exit): ...`). Other subjects such as `Exit: ...` or `README: ...` are
+allowed and ship in the release, but are not listed. Every release is a patch bump. For a
+minor or major release, or to release with no listed commit, push an empty commit:
+
+```bash
+git commit --allow-empty -m "chore: release 1.1.0" -m "Release-As: 1.1.0"
+```
+
+The trusted publisher on npmjs.com is bound to the workflow file `publish.yml` and the GitHub
+environment `npm`; renaming either breaks publishing. `./publish.sh --local [patch|minor|major]`
+is the emergency path: from a `main` that matches `origin/main`, it publishes directly from
+your machine with npm web auth, then pushes the release commit (including the release-please
+manifest) and the tag in one atomic push, and creates the GitHub release.
+publish.yml still tests that tag but skips publishing, since the version is already on npm.
 
 ## Troubleshooting
 

package/dist/claude-env.d.ts

@@ -17,9 +17,22 @@
  * DISABLE_AUTO_COMPACT. Suppress that ccc-inappropriate recommendation with an
  * effectively unreachable finite threshold; manual `/compact` remains available.
  *
+ * With auto-compaction off, Claude Code still refuses a request itself once
+ * its own estimate (last reported usage plus the new messages) reaches the
+ * window minus 23k (977k on a 1M window; 2.1.302, measured) and never sends
+ * it: "Prompt is too long", and every later message is refused the same way.
+ * MemTree compresses at a budget near the window (900k), so one large tool
+ * round could otherwise strand a session there before ccc sees the request.
+ * CLAUDE_CODE_BLOCKING_LIMIT_OVERRIDE lifts that refusal: the request reaches
+ * the proxy, which compresses it mid-turn or, failing that, refuses it with
+ * its own bounded retry/400. A value the user already exported is kept.
+ *
  * `CCC_AUTO_COMPACT=1` is an escape hatch: remove ccc's override and let the
- * user's native Claude Code setting decide whether auto-compaction is enabled.
+ * user's native Claude Code setting decide whether auto-compaction is enabled
+ * (Claude Code's own limits then apply unchanged).
  */
+/** Claude Code's local refusal limit under ccc: effectively never reached. */
+export declare const UNREACHABLE_BLOCKING_LIMIT = "1000000000";
 export declare function claudeChildEnv(parentEnv: NodeJS.ProcessEnv, anthropicBaseUrl: string): NodeJS.ProcessEnv;
 /**
  * Keep the proxy's MemTree budget in lockstep with Claude Code's own context

package/dist/claude-env.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"claude-env.d.ts","sourceRoot":"","sources":["../src/claude-env.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,CAC5B,SAAS,EAAE,MAAM,CAAC,UAAU,EAC5B,gBAAgB,EAAE,MAAM,GACvB,MAAM,CAAC,UAAU,CAoBnB;AAOD;;;;GAIG;AACH,wBAAgB,oCAAoC,CAClD,SAAS,EAAE,MAAM,CAAC,UAAU,GAC3B,OAAO,CAET"}
+{"version":3,"file":"claude-env.d.ts","sourceRoot":"","sources":["../src/claude-env.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,8EAA8E;AAC9E,eAAO,MAAM,0BAA0B,eAAe,CAAC;AAEvD,wBAAgB,cAAc,CAC5B,SAAS,EAAE,MAAM,CAAC,UAAU,EAC5B,gBAAgB,EAAE,MAAM,GACvB,MAAM,CAAC,UAAU,CAuBnB;AAOD;;;;GAIG;AACH,wBAAgB,oCAAoC,CAClD,SAAS,EAAE,MAAM,CAAC,UAAU,GAC3B,OAAO,CAET"}

package/dist/claude-env.js

@@ -17,9 +17,22 @@
  * DISABLE_AUTO_COMPACT. Suppress that ccc-inappropriate recommendation with an
  * effectively unreachable finite threshold; manual `/compact` remains available.
  *
+ * With auto-compaction off, Claude Code still refuses a request itself once
+ * its own estimate (last reported usage plus the new messages) reaches the
+ * window minus 23k (977k on a 1M window; 2.1.302, measured) and never sends
+ * it: "Prompt is too long", and every later message is refused the same way.
+ * MemTree compresses at a budget near the window (900k), so one large tool
+ * round could otherwise strand a session there before ccc sees the request.
+ * CLAUDE_CODE_BLOCKING_LIMIT_OVERRIDE lifts that refusal: the request reaches
+ * the proxy, which compresses it mid-turn or, failing that, refuses it with
+ * its own bounded retry/400. A value the user already exported is kept.
+ *
  * `CCC_AUTO_COMPACT=1` is an escape hatch: remove ccc's override and let the
- * user's native Claude Code setting decide whether auto-compaction is enabled.
+ * user's native Claude Code setting decide whether auto-compaction is enabled
+ * (Claude Code's own limits then apply unchanged).
  */
+/** Claude Code's local refusal limit under ccc: effectively never reached. */
+export const UNREACHABLE_BLOCKING_LIMIT = "1000000000";
 export function claudeChildEnv(parentEnv, anthropicBaseUrl) {
     const childEnv = {
         ...parentEnv,
@@ -36,6 +49,9 @@ export function claudeChildEnv(parentEnv, anthropicBaseUrl) {
     }
     else {
         childEnv.DISABLE_AUTO_COMPACT = "1";
+        if (!childEnv.CLAUDE_CODE_BLOCKING_LIMIT_OVERRIDE) {
+            childEnv.CLAUDE_CODE_BLOCKING_LIMIT_OVERRIDE = UNREACHABLE_BLOCKING_LIMIT;
+        }
     }
     return childEnv;
 }

package/dist/claude-env.js.map

@@ -1 +1 @@
-{"version":3,"file":"claude-env.js","sourceRoot":"","sources":["../src/claude-env.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,cAAc,CAC5B,SAA4B,EAC5B,gBAAwB;IAExB,MAAM,QAAQ,GAAsB;QAClC,GAAG,SAAS;QACZ,kBAAkB,EAAE,gBAAgB;QACpC,wCAAwC,EAAE,GAAG;QAC7C,kCAAkC,EAAE,YAAY;KACjD,CAAC;IAEF,gEAAgE;IAChE,OAAO,QAAQ,CAAC,gBAAgB,CAAC;IAEjC,IAAI,SAAS,CAAC,gBAAgB,KAAK,GAAG,EAAE,CAAC;QACvC,oEAAoE;QACpE,iCAAiC;QACjC,OAAO,QAAQ,CAAC,oBAAoB,CAAC;IACvC,CAAC;SAAM,CAAC;QACN,QAAQ,CAAC,oBAAoB,GAAG,GAAG,CAAC;IACtC,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,SAAS,cAAc,CAAC,KAAyB;IAC/C,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,KAAK,CAAC;IACtC,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC;AACzE,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,oCAAoC,CAClD,SAA4B;IAE5B,OAAO,CAAC,cAAc,CAAC,SAAS,CAAC,8BAA8B,CAAC,CAAC;AACnE,CAAC"}
+{"version":3,"file":"claude-env.js","sourceRoot":"","sources":["../src/claude-env.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,8EAA8E;AAC9E,MAAM,CAAC,MAAM,0BAA0B,GAAG,YAAY,CAAC;AAEvD,MAAM,UAAU,cAAc,CAC5B,SAA4B,EAC5B,gBAAwB;IAExB,MAAM,QAAQ,GAAsB;QAClC,GAAG,SAAS;QACZ,kBAAkB,EAAE,gBAAgB;QACpC,wCAAwC,EAAE,GAAG;QAC7C,kCAAkC,EAAE,YAAY;KACjD,CAAC;IAEF,gEAAgE;IAChE,OAAO,QAAQ,CAAC,gBAAgB,CAAC;IAEjC,IAAI,SAAS,CAAC,gBAAgB,KAAK,GAAG,EAAE,CAAC;QACvC,oEAAoE;QACpE,iCAAiC;QACjC,OAAO,QAAQ,CAAC,oBAAoB,CAAC;IACvC,CAAC;SAAM,CAAC;QACN,QAAQ,CAAC,oBAAoB,GAAG,GAAG,CAAC;QACpC,IAAI,CAAC,QAAQ,CAAC,mCAAmC,EAAE,CAAC;YAClD,QAAQ,CAAC,mCAAmC,GAAG,0BAA0B,CAAC;QAC5E,CAAC;IACH,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,SAAS,cAAc,CAAC,KAAyB;IAC/C,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,KAAK,CAAC;IACtC,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC;AACzE,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,oCAAoC,CAClD,SAA4B;IAE5B,OAAO,CAAC,cAAc,CAAC,SAAS,CAAC,8BAA8B,CAAC,CAAC;AACnE,CAAC"}

package/dist/cli-args.d.ts

@@ -5,6 +5,20 @@ export interface WrapperArgs {
 }
 /** Whether Claude's own print mode was requested before its `--` separator. */
 export declare function isPrintInvocation(args: string[]): boolean;
+/** ccc's own subcommands, which start no Claude session. */
+declare const SUBCOMMANDS: readonly ["fetch", "memtree-mcp", "link"];
+export type CccEnvironment = "production" | "staging" | "local";
+/** The environment a leading `local`/`staging` word selects (else production). */
+export declare function environmentOf(args: readonly string[]): CccEnvironment;
+/**
+ * A ccc subcommand and its arguments: the first word, or the word after
+ * `local`/`staging` (`ccc staging memtree-mcp` is the same server as
+ * `ccc memtree-mcp`; the environment is the proxy's, from its base URL).
+ */
+export declare function subcommandArgs(args: readonly string[]): {
+    name: (typeof SUBCOMMANDS)[number];
+    args: string[];
+} | undefined;
 /**
  * Consume ccc's own flags only before the conventional `--` separator. Values
  * after it are literal Claude arguments/prompts, even when they look like ccc
@@ -29,4 +43,5 @@ export declare function compactTargetFromEnv(raw: string | undefined, parseToken
     value: number | null | undefined;
     warning?: string;
 };
+export {};
 //# sourceMappingURL=cli-args.d.ts.map

package/dist/cli-args.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli-args.d.ts","sourceRoot":"","sources":["../src/cli-args.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,+EAA+E;AAC/E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAMzD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,WAAW,CAmB5D;AAED,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,GAAG,KAAK,CAAC;AACnF,eAAO,MAAM,uBAAuB,EAAE,SAAS,oBAAoB,EAMlE,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,MAAM,GAAG,SAAS,GACxB,oBAAoB,GAAG,SAAS,CAKlC;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,EACjD,SAAS,EAAE,MAAM,GAChB;IAAE,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAWxD"}
+{"version":3,"file":"cli-args.d.ts","sourceRoot":"","sources":["../src/cli-args.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,+EAA+E;AAC/E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAMzD;AAED,4DAA4D;AAC5D,QAAA,MAAM,WAAW,2CAA4C,CAAC;AAG9D,MAAM,MAAM,cAAc,GAAG,YAAY,GAAG,SAAS,GAAG,OAAO,CAAC;AAEhE,kFAAkF;AAClF,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,cAAc,CAErE;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,SAAS,MAAM,EAAE,GACtB;IAAE,IAAI,EAAE,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,SAAS,CAIpE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,WAAW,CAmB5D;AAED,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,GAAG,KAAK,CAAC;AACnF,eAAO,MAAM,uBAAuB,EAAE,SAAS,oBAAoB,EAMlE,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,MAAM,GAAG,SAAS,GACxB,oBAAoB,GAAG,SAAS,CAKlC;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,EACjD,SAAS,EAAE,MAAM,GAChB;IAAE,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAWxD"}

package/dist/cli-args.js

@@ -8,6 +8,23 @@ export function isPrintInvocation(args) {
     }
     return false;
 }
+/** ccc's own subcommands, which start no Claude session. */
+const SUBCOMMANDS = ["fetch", "memtree-mcp", "link"];
+const ENVIRONMENT_WORDS = ["local", "staging"];
+/** The environment a leading `local`/`staging` word selects (else production). */
+export function environmentOf(args) {
+    return args[0] === "local" ? "local" : args[0] === "staging" ? "staging" : "production";
+}
+/**
+ * A ccc subcommand and its arguments: the first word, or the word after
+ * `local`/`staging` (`ccc staging memtree-mcp` is the same server as
+ * `ccc memtree-mcp`; the environment is the proxy's, from its base URL).
+ */
+export function subcommandArgs(args) {
+    const start = ENVIRONMENT_WORDS.includes(args[0] ?? "") ? 1 : 0;
+    const name = SUBCOMMANDS.find((command) => command === args[start]);
+    return name ? { name, args: args.slice(start + 1) } : undefined;
+}
 /**
  * Consume ccc's own flags only before the conventional `--` separator. Values
  * after it are literal Claude arguments/prompts, even when they look like ccc

package/dist/cli-args.js.map

@@ -1 +1 @@
-{"version":3,"file":"cli-args.js","sourceRoot":"","sources":["../src/cli-args.ts"],"names":[],"mappings":"AAMA,+EAA+E;AAC/E,MAAM,UAAU,iBAAiB,CAAC,IAAc;IAC9C,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,IAAI,GAAG,KAAK,IAAI;YAAE,OAAO,KAAK,CAAC;QAC/B,IAAI,GAAG,KAAK,IAAI,IAAI,GAAG,KAAK,SAAS;YAAE,OAAO,IAAI,CAAC;IACrD,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAc;IAC7C,MAAM,UAAU,GAAa,EAAE,CAAC;IAChC,IAAI,eAAe,GAAG,IAAI,CAAC;IAC3B,IAAI,KAAK,GAAG,KAAK,CAAC;IAElB,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,IAAI,eAAe,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;YACpC,eAAe,GAAG,KAAK,CAAC;YACxB,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YACrB,SAAS;QACX,CAAC;QACD,IAAI,eAAe,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;YACzC,KAAK,GAAG,IAAI,CAAC;YACb,SAAS;QACX,CAAC;QACD,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACvB,CAAC;IAED,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC;AAC/B,CAAC;AAGD,MAAM,CAAC,MAAM,uBAAuB,GAAoC;IACtE,MAAM;IACN,SAAS;IACT,MAAM;IACN,SAAS;IACT,KAAK;CACN,CAAC;AAEF;;;;GAIG;AACH,MAAM,UAAU,2BAA2B,CACzC,KAAyB;IAEzB,MAAM,UAAU,GAAG,KAAK,EAAE,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IAC/C,OAAQ,uBAA6C,CAAC,QAAQ,CAAC,UAAU,IAAI,EAAE,CAAC;QAC9E,CAAC,CAAE,UAAmC;QACtC,CAAC,CAAC,SAAS,CAAC;AAChB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAClC,GAAuB,EACvB,WAAiD,EACjD,SAAiB;IAEjB,IAAI,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;IACrD,IAAI,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;QAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;IACtD,MAAM,MAAM,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;IAChC,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,GAAG,SAAS,EAAE,CAAC;QAC/C,OAAO;YACL,KAAK,EAAE,SAAS;YAChB,OAAO,EAAE,oCAAoC,GAAG,2CAA2C,SAAS,GAAG,IAAI,IAAI;SAChH,CAAC;IACJ,CAAC;IACD,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;AAC3B,CAAC"}
+{"version":3,"file":"cli-args.js","sourceRoot":"","sources":["../src/cli-args.ts"],"names":[],"mappings":"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"}

package/dist/cli-lifecycle.d.ts

@@ -14,4 +14,8 @@ export interface SignalShutdownActions {
  * Dependencies are injected so this policy can be tested without process.exit.
  */
 export declare function createSignalShutdownHandler(actions: SignalShutdownActions): (signal: ShutdownSignal) => void;
+/** Resolves once `text` is handed to the OS (or the write fails); never rejects. */
+export declare function writeStdout(text: string, stream?: Pick<NodeJS.WriteStream, "write">): Promise<void>;
+/** Waits for `pending` at most `ms`; a bound for cleanup that must not hang exit. */
+export declare function settleWithin(pending: Promise<unknown>, ms: number): Promise<void>;
 //# sourceMappingURL=cli-lifecycle.d.ts.map

package/dist/cli-lifecycle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli-lifecycle.d.ts","sourceRoot":"","sources":["../src/cli-lifecycle.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,SAAS,CAAC;AAElD,4EAA4E;AAC5E,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,MAAM,CAGhE;AAED,6EAA6E;AAC7E,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,GAAG,IAAI,EACnB,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,IAAI,GAC5B,MAAM,CAGR;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAAC;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,qBAAqB,GAC7B,CAAC,MAAM,EAAE,cAAc,KAAK,IAAI,CASlC"}
+{"version":3,"file":"cli-lifecycle.d.ts","sourceRoot":"","sources":["../src/cli-lifecycle.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,SAAS,CAAC;AAElD,4EAA4E;AAC5E,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,MAAM,CAGhE;AAED,6EAA6E;AAC7E,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,GAAG,IAAI,EACnB,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,IAAI,GAC5B,MAAM,CAGR;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAAC;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,qBAAqB,GAC7B,CAAC,MAAM,EAAE,cAAc,KAAK,IAAI,CASlC;AAED,oFAAoF;AACpF,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,MAAM,GAAE,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,OAAO,CAAkB,GACzD,OAAO,CAAC,IAAI,CAAC,CAQf;AAED,qFAAqF;AACrF,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAQjF"}

package/dist/cli-lifecycle.js

@@ -27,4 +27,22 @@ export function createSignalShutdownHandler(actions) {
             actions.forceExit(code);
     };
 }
+/** Resolves once `text` is handed to the OS (or the write fails); never rejects. */
+export function writeStdout(text, stream = process.stdout) {
+    return new Promise((resolve) => {
+        try {
+            stream.write(text, () => resolve());
+        }
+        catch {
+            resolve();
+        }
+    });
+}
+/** Waits for `pending` at most `ms`; a bound for cleanup that must not hang exit. */
+export function settleWithin(pending, ms) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, ms);
+        pending.then(() => { clearTimeout(timer); resolve(); }, () => { clearTimeout(timer); resolve(); });
+    });
+}
 //# sourceMappingURL=cli-lifecycle.js.map

package/dist/cli-lifecycle.js.map

@@ -1 +1 @@
-{"version":3,"file":"cli-lifecycle.js","sourceRoot":"","sources":["../src/cli-lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,IAAI,WAAW,EAAE,MAAM,SAAS,CAAC;AAInD,4EAA4E;AAC5E,MAAM,UAAU,iBAAiB,CAAC,MAAsB;IACtD,MAAM,YAAY,GAAG,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACjD,OAAO,OAAO,YAAY,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;AACnE,CAAC;AAED,6EAA6E;AAC7E,MAAM,UAAU,gBAAgB,CAC9B,IAAmB,EACnB,MAA6B;IAE7B,IAAI,IAAI,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAC/B,OAAO,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;AACzD,CAAC;AAQD;;;;GAIG;AACH,MAAM,UAAU,2BAA2B,CACzC,OAA8B;IAE9B,IAAI,QAAQ,GAAG,CAAC,CAAC;IACjB,OAAO,CAAC,MAAM,EAAE,EAAE;QAChB,QAAQ,EAAE,CAAC;QACX,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QACxB,MAAM,IAAI,GAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;QACvC,IAAI,QAAQ,KAAK,CAAC;YAAE,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;;YACtC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC,CAAC;AACJ,CAAC"}
+{"version":3,"file":"cli-lifecycle.js","sourceRoot":"","sources":["../src/cli-lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,IAAI,WAAW,EAAE,MAAM,SAAS,CAAC;AAInD,4EAA4E;AAC5E,MAAM,UAAU,iBAAiB,CAAC,MAAsB;IACtD,MAAM,YAAY,GAAG,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACjD,OAAO,OAAO,YAAY,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;AACnE,CAAC;AAED,6EAA6E;AAC7E,MAAM,UAAU,gBAAgB,CAC9B,IAAmB,EACnB,MAA6B;IAE7B,IAAI,IAAI,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAC/B,OAAO,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;AACzD,CAAC;AAQD;;;;GAIG;AACH,MAAM,UAAU,2BAA2B,CACzC,OAA8B;IAE9B,IAAI,QAAQ,GAAG,CAAC,CAAC;IACjB,OAAO,CAAC,MAAM,EAAE,EAAE;QAChB,QAAQ,EAAE,CAAC;QACX,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QACxB,MAAM,IAAI,GAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;QACvC,IAAI,QAAQ,KAAK,CAAC;YAAE,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;;YACtC,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC,CAAC;AACJ,CAAC;AAED,oFAAoF;AACpF,MAAM,UAAU,WAAW,CACzB,IAAY,EACZ,SAA4C,OAAO,CAAC,MAAM;IAE1D,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QAC7B,IAAI,CAAC;YACH,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC;QACtC,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC;AAED,qFAAqF;AACrF,MAAM,UAAU,YAAY,CAAC,OAAyB,EAAE,EAAU;IAChE,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QAC7B,MAAM,KAAK,GAAG,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;QACtC,OAAO,CAAC,IAAI,CACV,GAAG,EAAE,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EACzC,GAAG,EAAE,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAC1C,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC"}