claude-overnight 1.16.15 → 1.17.0

package/QUICKSHEET_PLAYWRIGHT.md

@@ -0,0 +1,65 @@
+# Playwright Parallel Usage
+
+When running claude-overnight with parallel agents that use the Playwright MCP server, avoid lock conflicts and session cross-contamination.
+
+## Isolation Levels
+
+| Goal | Approach |
+|---|---|
+| Non-disruptive, no focus steal | Headless mode (default) |
+| Several agents in parallel, no shared cookies | Headless + each MCP server: `--isolated` (or `isolated: true`) |
+| Several agents, each with saved login | Headless + each MCP server: unique `userDataDir` or its own `--storage-state` file |
+| Anti-bot interception (CAPTCHA, Cloudflare) | Fall back to headed mode only when necessary |
+
+**Headless preferred by default.** Every headed browser launch becomes the foreground app on macOS, which is disruptive during long runs. Only fall back to headed when anti-bot detection (CAPTCHA, Cloudflare challenge, etc.) requires visible browser interaction.
+
+## MCP Server Configuration
+
+Add to your `settings.json` or `.claude/settings.local.json`:
+
+```json
+{
+  "mcpServers": {
+    "playwright-1": {
+      "command": "npx",
+      "args": ["@anthropic-ai/mcp-playwright@latest", "--isolated", "--headless"],
+      "env": {}
+    },
+    "playwright-2": {
+      "command": "npx",
+      "args": ["@anthropic-ai/mcp-playwright@latest", "--isolated", "--headless"],
+      "env": {}
+    }
+  }
+}
+```
+
+For saved logins, give each server its own `userDataDir`:
+
+```json
+{
+  "mcpServers": {
+    "playwright-agent-a": {
+      "command": "npx",
+      "args": ["@anthropic-ai/mcp-playwright@latest", "--headless", "--userDataDir", "/tmp/pw-agent-a"],
+      "env": {}
+    },
+    "playwright-agent-b": {
+      "command": "npx",
+      "args": ["@anthropic-ai/mcp-playwright@latest", "--headless", "--userDataDir", "/tmp/pw-agent-b"],
+      "env": {}
+    }
+  }
+}
+```
+
+## Context7 Documentation
+
+For the latest Playwright API docs and patterns:
+
+```bash
+npx ctx7@latest library playwright "parallel browser instances isolation"
+npx ctx7@latest docs <libraryId> "parallel browser instances"
+```
+
+**Note:** ctx7 requires authentication (`npx ctx7@latest login` or `CONTEXT7_API_KEY` env var). If unauthenticated, lookups will fail  -- agents should fall back to training data.

package/README.md

@@ -1,18 +1,18 @@
 # claude-overnight
 
-**A background lane for your Claude Max plan.** Runs a capped swarm of Claude Agent SDK sessions in isolated git worktrees — stops at a usage cap you set, so your interactive Claude Code always has headroom. Rate-limited? It waits. Crash? It resumes with full context.
+**A background lane for your Claude Max plan.** Runs a capped swarm of Claude Agent SDK sessions in isolated git worktrees  -- stops at a usage cap you set, so your interactive Claude Code always has headroom. Rate-limited? It waits. Crash? It resumes with full context.
 
 Your Max plan rate limits eat interactive coding time. One deep refactor and the 5-hour window is gone before lunch. `claude-overnight` runs background agent sessions up to the percentage cap you pick (90% is typical), leaving the rest free for your own Claude Code session. Hand it an objective and a session budget, walk away, review the diff when the run ends.
 
-Isolated by default. Every agent runs in its own git worktree on its own branch, so a misbehaving agent can't trash your working tree. You choose what agents can do before the run starts — no surprise escalation mid-flight. Unmerged branches are preserved for manual review, never discarded. Built on the [Claude Agent SDK](https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk) — not a Claude Code replacement, but a background lane that runs alongside it.
+Isolated by default. Every agent runs in its own git worktree on its own branch, so a misbehaving agent can't trash your working tree. You choose what agents can do before the run starts  -- no surprise escalation mid-flight. Unmerged branches are preserved for manual review, never discarded. Built on the [Claude Agent SDK](https://www.npmjs.com/package/@anthropic-ai/claude-agent-sdk)  -- not a Claude Code replacement, but a background lane that runs alongside it.
 
-Different shape from hosted agent harnesses like [Claude Managed Agents](https://platform.claude.com/docs/en/managed-agents/overview): instead of one agent in one cloud container billed separately, you get many parallel sessions on your own machine, in your real repo, against your own Max plan (or API key). Works with Claude Opus, Sonnet, and Haiku — or pair an Anthropic planner with a cheaper executor on Qwen, OpenRouter, or any Anthropic-compatible endpoint.
+Different shape from hosted agent harnesses like [Claude Managed Agents](https://platform.claude.com/docs/en/managed-agents/overview): instead of one agent in one cloud container billed separately, you get many parallel sessions on your own machine, in your real repo, against your own Max plan (or API key). Works with Claude Opus, Sonnet, and Haiku  -- or pair an Anthropic planner with a cheaper executor on Qwen, OpenRouter, or any Anthropic-compatible endpoint.
 
 ## Run on Qwen 3.6 Plus
 
-Hit your Claude Max plan limits? Running on a tight budget? Qwen 3.6 Plus via Alibaba Cloud's DashScope gateway is a drop-in executor that speaks the Anthropic Messages API — same client, same flow, pennies per run.
+Hit your Claude Max plan limits? Running on a tight budget? Qwen 3.6 Plus via Alibaba Cloud's DashScope gateway is a drop-in executor that speaks the Anthropic Messages API  -- same client, same flow, pennies per run.
 
-1. **Get an API key.** Sign up at [Alibaba Cloud](https://account.alibabacloud.com/login/login.htm?oauth_callback=https%3A%2F%2Fmodelstudio.console.alibabacloud.com%2Fap-southeast-1%3Ftab%3Ddashboard%23%2Fapi-key&clearRedirectCookie=1) — the link takes you straight to the API key dashboard.
+1. **Get an API key.** Sign up at [Alibaba Cloud](https://account.alibabacloud.com/login/login.htm?oauth_callback=https%3A%2F%2Fmodelstudio.console.alibabacloud.com%2Fap-southeast-1%3Ftab%3Ddashboard%23%2Fapi-key&clearRedirectCookie=1)  -- the link takes you straight to the API key dashboard.
 2. **Configure the provider.** Run `claude-overnight`, choose `Other…` on the executor step, and fill in:
 
    | Field | Value |
@@ -39,7 +39,7 @@ claude-overnight
 npm install -g claude-overnight
 ```
 
-Requires Node.js ≥ 20 and Claude authentication (`claude auth login` or `ANTHROPIC_API_KEY`). No Anthropic plan or key? See **Run on Qwen 3.6 Plus** above — a cheap, drop-in alternative.
+Requires Node.js ≥ 20 and Claude authentication (`claude auth login` or `ANTHROPIC_API_KEY`). No Anthropic plan or key? See **Run on Qwen 3.6 Plus** above  -- a cheap, drop-in alternative.
 
 ## Quick start
 
@@ -56,13 +56,13 @@ claude-overnight
 
 ② Budget [10]: 200
 
-④ Planner model (thinking, steering — use your strongest):
-  ● Opus — Opus 4.6 · Most capable
-  ○ Sonnet — Sonnet 4.6 · Best for everyday tasks
+④ Planner model (thinking, steering  -- use your strongest):
+  ● Opus  -- Opus 4.6 · Most capable
+  ○ Sonnet  -- Sonnet 4.6 · Best for everyday tasks
 
-⑤ Executor model (what runs the tasks — Qwen 3.6 Plus / OpenRouter / etc via Other…):
-  ● Sonnet — Sonnet 4.6 · Best for everyday tasks
-  ○ Opus — Opus 4.6 · Most capable
+⑤ Executor model (what runs the tasks  -- Qwen 3.6 Plus / OpenRouter / etc via Other…):
+  ● Sonnet  -- Sonnet 4.6 · Best for everyday tasks
+  ○ Opus  -- Opus 4.6 · Most capable
   ○ Other… · custom OpenAI/Anthropic-compatible endpoint
 
 ⑥ Usage cap:
@@ -89,58 +89,64 @@ claude-overnight
 ◆ Assessing... ✓ Done
 ```
 
-You interact once (objective, budget, model, review themes), then the rest runs unattended — thinking, planning, executing, reflecting, steering. Rate-limited? It waits and retries. Crash? Resume where you left off. Capped at usage limit? Pick up next time with full context preserved.
+You interact once (objective, budget, model, review themes), then the rest runs unattended  -- thinking, planning, executing, reflecting, steering. Rate-limited? It waits and retries. Crash? Resume where you left off. Capped at usage limit? Pick up next time with full context preserved.
 
 ## How it differs
 
 - vs **Claude Code**: many agents, no driver, capped so your Claude Code session keeps its headroom
-- vs **[Managed Agents](https://platform.claude.com/docs/en/managed-agents/overview)**: on your machine, against your Max plan, in your real git history — not a cloud container billed separately
+- vs **[Managed Agents](https://platform.claude.com/docs/en/managed-agents/overview)**: on your machine, against your Max plan, in your real git history  -- not a cloud container billed separately
 - vs **Cursor / Copilot / Cline**: asynchronous, off the keyboard
 
 ## Use cases
 
-- **Overnight refactors** — "Modernize the auth system" at budget 200.
-- **Batch feature implementation** — dozens of features from a task file, parallelized.
-- **Codebase-wide cleanups** — deduplicate, simplify, rename, normalize.
-- **Test generation at scale** — integration tests for every route or module.
-- **Documentation sprints** — API docs, READMEs, inline comments, changelogs.
-- **Framework migrations** — version upgrades, type annotations, config format swaps.
-- **Quality audits** — reflection waves surface architectural issues and code smells.
-- **Long research runs** — architect sessions explore a large codebase before any code lands.
+- **Overnight refactors**  -- "Modernize the auth system" at budget 200.
+- **Batch feature implementation**  -- dozens of features from a task file, parallelized.
+- **Codebase-wide cleanups**  -- deduplicate, simplify, rename, normalize.
+- **Test generation at scale**  -- integration tests for every route or module.
+- **Documentation sprints**  -- API docs, READMEs, inline comments, changelogs.
+- **Framework migrations**  -- version upgrades, type annotations, config format swaps.
+- **Quality audits**  -- reflection waves surface architectural issues and code smells.
+- **Long research runs**  -- architect sessions explore a large codebase before any code lands.
 
 Typical shape: one objective + a $20–$200 spend cap + walk away.
 
 ## How it works
 
-### 1. Thinking phase — parallel architect sessions
+### 1. Thinking phase  -- parallel architect sessions
 
 For budgets > 15, the tool launches **architect agents** that explore your codebase before any code is written. Each one gets a different research angle (architecture, data models, APIs, testing, etc.) and writes a structured design document. The number scales with budget: 5 for budget=50, 10 for budget=2000.
 
 ### 2. Task orchestration
 
-An orchestrator session reads all design documents and synthesizes concrete execution tasks — grounded in real files and patterns the architects found. The task plan is also written to a file for resilience — if orchestration is interrupted, partial results survive.
+An orchestrator session reads all design documents and synthesizes concrete execution tasks  -- grounded in real files and patterns the architects found. The task plan is also written to a file for resilience  -- if orchestration is interrupted, partial results survive.
 
 ### 3. Parallel execution waves
 
-Tasks run in parallel agent sessions (each in its own git worktree). After completing its task, each session automatically runs a **simplify pass** — reviewing its own `git diff` for code reuse opportunities, quality issues, and inefficiencies, then fixing them before the framework commits.
+Tasks run in parallel agent sessions (each in its own git worktree). After completing its task, each session automatically runs a **simplify pass**  -- reviewing its own `git diff` for code reuse opportunities, quality issues, and inefficiencies, then fixing them before the framework commits. This is done via the SDK's **session resume** mechanism: the same agent session continues with a follow-up prompt, so the agent's full context from its task is still available  -- no need to re-instruct or re-fill context.
 
-After each wave, steering assesses: "how good is this?" — not "what's missing?" It can:
+### 4. Post-wave review
+
+After each wave (flex mode, budget remaining), a dedicated **review agent** inspects the consolidated diff for issues the individual agents may have blind-spotted: missed reuse opportunities, copy-paste variations, leaky abstractions, efficiency regressions. Runs as a single-agent wave  -- one session reviews what the swarm just produced.
+
+### 5. Post-run final gate
+
+When the run completes (steering declares done), a final **comprehensive review** runs against the full `git diff main`. Checks architecture coherence, consistency with existing patterns, build integrity, and test pass. The last quality gate before the diff lands.
+
+### 6. Steering
+
+After each wave, steering assesses: "how good is this?"  -- not "what's missing?" It can:
 
 - **Execute** more tasks to build features, fix bugs, polish UX
 - **Reflect** by spinning up 1-2 review sessions for deep quality/architecture audits
 - **Declare done** when the vision is met at high quality
 
-### 4. Goal refinement and steering
-
-The tool starts with your broad objective but refines its definition of quality as it learns your codebase. Steering updates the goal after each wave. Late waves are informed by early discoveries.
-
-### 5. Three-layer context memory
+### Three-layer context memory
 
 Long runs stay sharp because steering maintains three layers of memory:
 
-- **Status** — a living project snapshot, updated every wave. Compressed, never truncated.
-- **Milestones** — strategic snapshots archived every ~5 waves. Long-term memory.
-- **Goal** — the evolving north star. What quality means for this codebase.
+- **Status**  -- a living project snapshot, updated every wave. Compressed, never truncated.
+- **Milestones**  -- strategic snapshots archived every ~5 waves. Long-term memory.
+- **Goal**  -- the evolving north star. What quality means for this codebase.
 
 ## Run history, resume, and knowledge carryforward
 
@@ -155,7 +161,7 @@ Every run gets its own folder in `.claude-overnight/runs/`. Nothing is ever over
       run.json, sessions/
 ```
 
-Any run that stops before the steering system declares the objective complete — capped at usage limit, Ctrl+C, crash, rate limit timeout, steering failure — is automatically resumable:
+Any run that stops before the steering system declares the objective complete  -- capped at usage limit, Ctrl+C, crash, rate limit timeout, steering failure  -- is automatically resumable:
 
 ```
   ⚠ Unfinished run
@@ -170,7 +176,7 @@ Any run that stops before the steering system declares the objective complete
 
 On resume: unmerged branches auto-merge, the wave loop continues, all context is preserved. Designs and reflections stay on disk until the objective is truly complete.
 
-If the thinking phase succeeds but orchestration crashes, the next run detects the orphaned design docs and reuses them — no re-running $9 worth of architect sessions:
+If the thinking phase succeeds but orchestration crashes, the next run detects the orphaned design docs and reuses them  -- no re-running $9 worth of architect sessions:
 
 ```
   ✓ Reusing 5 design docs (from prior attempt)
@@ -180,11 +186,11 @@ If the thinking phase succeeds but orchestration crashes, the next run detects t
     ...
 ```
 
-**Knowledge carries forward** — new runs inherit knowledge from completed previous runs. Thinking sessions and steering see what past runs built. Run 2 knows run 1 already built the auth system.
+**Knowledge carries forward**  -- new runs inherit knowledge from completed previous runs. Thinking sessions and steering see what past runs built. Run 2 knows run 1 already built the auth system.
 
-Add `.claude-overnight/` to your `.gitignore` (with the trailing slash — see below).
+Add `.claude-overnight/` to your `.gitignore` (with the trailing slash  -- see below).
 
-A separate, tiny `claude-overnight.log.md` is also written at the repo root on every run. It's human-readable, append-only, one block per run (objective, start/finish, cost, outcome, branch), and is designed to be **committed** — so even after `.claude-overnight/` is cleaned up you can still recover which prompt produced which commits. Use `.claude-overnight/` (with trailing slash) in your gitignore so this file isn't matched by accident.
+A separate, tiny `claude-overnight.log.md` is also written at the repo root on every run. It's human-readable, append-only, one block per run (objective, start/finish, cost, outcome, branch), and is designed to be **committed**  -- so even after `.claude-overnight/` is cleaned up you can still recover which prompt produced which commits. Use `.claude-overnight/` (with trailing slash) in your gitignore so this file isn't matched by accident.
 
 ## Task file and inline modes
 
@@ -228,20 +234,20 @@ claude-overnight "fix auth bug in src/auth.ts" "add tests for user model"
 |---|---|---|
 | `--budget=N` | `10` | Total agent sessions |
 | `--concurrency=N` | `5` | Parallel agents |
-| `--model=NAME` | prompted | Worker model — interactive picks planner + executor separately; `Other…` adds Qwen / OpenRouter / any Anthropic-compat endpoint. In non-interactive mode, a saved provider's model id is auto-resolved to the provider. |
+| `--model=NAME` | prompted | Worker model  -- interactive picks planner + executor separately; `Other…` adds Qwen / OpenRouter / any Anthropic-compat endpoint. In non-interactive mode, a saved provider's model id is auto-resolved to the provider. |
 | `--usage-cap=N` | unlimited | Stop at N% utilization |
 | `--allow-extra-usage` | off | Allow extra/overage usage (billed separately) |
-| `--extra-usage-budget=N` | — | Max $ for extra usage (implies --allow-extra-usage) |
+| `--extra-usage-budget=N` |  -- | Max $ for extra usage (implies --allow-extra-usage) |
 | `--timeout=SECONDS` | `900` | Inactivity timeout per agent (nudges at timeout, kills at 2×) |
-| `--no-flex` | — | Disable multi-wave steering |
-| `--dry-run` | — | Show planned tasks without running |
+| `--no-flex` |  -- | Disable multi-wave steering |
+| `--dry-run` |  -- | Show planned tasks without running |
 
 ## Task file fields
 
 | Field | Type | Default | Description |
 |---|---|---|---|
 | `tasks` | `(string \| {prompt, cwd?, model?})[]` | required | Tasks to run |
-| `objective` | `string` | — | High-level goal for steering |
+| `objective` | `string` |  -- | High-level goal for steering |
 | `flexiblePlan` | `boolean` | `false` | Enable multi-wave planning |
 | `model` | `string` | prompted | Worker model |
 | `concurrency` | `number` | `5` | Parallel agents |
@@ -252,12 +258,12 @@ claude-overnight "fix auth bug in src/auth.ts" "add tests for user model"
 
 ## Custom providers (Qwen, OpenRouter, any Anthropic-compatible endpoint)
 
-Planner and executor are picked separately — pair Opus-on-Anthropic for the planner/thinker with a cheaper model on another provider for the bulk of execution.
+Planner and executor are picked separately  -- pair Opus-on-Anthropic for the planner/thinker with a cheaper model on another provider for the bulk of execution.
 
 From the interactive picker, choose `Other…` on the planner or executor step:
 
 ```
-⑤ Executor model (what runs the tasks — Qwen 3.6 Plus / OpenRouter / etc via Other…):
+⑤ Executor model (what runs the tasks  -- Qwen 3.6 Plus / OpenRouter / etc via Other…):
   ○ Sonnet
   ○ Opus
   ● Other…
@@ -272,13 +278,43 @@ From the interactive picker, choose `Other…` on the planner or executor step:
 
 Saved providers live user-level at `~/.claude/claude-overnight/providers.json` (mode 0600) and show up automatically in every repo. No per-project config.
 
-**How routing works.** Each `query()` gets its own env override (`ANTHROPIC_BASE_URL` + `ANTHROPIC_AUTH_TOKEN`) — planner queries use the planner provider, executor queries use the executor provider. No global shell env, no proxy daemon, no `process.env` pollution between calls.
+**How routing works.** Each `query()` gets its own env override (`ANTHROPIC_BASE_URL` + `ANTHROPIC_AUTH_TOKEN`)  -- planner queries use the planner provider, executor queries use the executor provider. No global shell env, no proxy daemon, no `process.env` pollution between calls.
 
 **Pre-flight.** Before the swarm starts, each custom provider is pinged with a 1-turn auth check. Bad keys fail fast with `✗ executor preflight failed: ...` instead of N scattered mid-run errors.
 
 **Resume.** Provider ids are persisted in `run.json` and rehydrated on resume. If you deleted a provider between runs, resume refuses to start and tells you exactly which id is missing.
 
-**Non-interactive / CI.** `claude-overnight --model=qwen3.6-plus` auto-resolves the model id to a saved provider — no separate `--provider` flag.
+**Non-interactive / CI.** `claude-overnight --model=qwen3.6-plus` auto-resolves the model id to a saved provider  -- no separate `--provider` flag.
+
+## Parallel Playwright Testing
+
+When agents use the Playwright MCP server for testing, parallel instances conflict on browser locks and cookie state. Add multiple MCP entries to `settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "playwright-1": {
+      "command": "npx",
+      "args": ["@anthropic-ai/mcp-playwright@latest", "--isolated", "--headless"]
+    },
+    "playwright-2": {
+      "command": "npx",
+      "args": ["@anthropic-ai/mcp-playwright@latest", "--isolated", "--headless"]
+    }
+  }
+}
+```
+
+**Isolation levels:**
+
+| Goal | Approach |
+|---|---|
+| Non-disruptive, no focus steal | Headless mode (default) |
+| Parallel agents, no shared cookies | Headless + `--isolated` per MCP server |
+| Parallel agents, each with saved login | Headless + unique `userDataDir` or `--storage-state` per server |
+| Anti-bot interception (CAPTCHA, Cloudflare) | Drop `--headless` only when necessary |
+
+See `QUICKSHEET_PLAYWRIGHT.md` for full config examples.
 
 ## Spend caps and usage controls
 
@@ -286,8 +322,8 @@ Saved providers live user-level at `~/.claude/claude-overnight/providers.json` (
 
 By default, extra/overage usage is **blocked**. When your plan's rate limits are exhausted, the run stops cleanly and is resumable. You control this in the interactive prompt (step ⑤) or via CLI flags:
 
-- `--allow-extra-usage` — opt in to extra usage (billed separately)
-- `--extra-usage-budget=20` — allow up to $20 of extra usage, then stop
+- `--allow-extra-usage`  -- opt in to extra usage (billed separately)
+- `--extra-usage-budget=20`  -- allow up to $20 of extra usage, then stop
 
 ### Live controls during execution
 
@@ -299,11 +335,11 @@ Press these keys while agents are running:
 | `t` | Change usage cap threshold (0-100%) |
 | `q` | Graceful stop (press twice to force quit) |
 
-Changes take effect between waves — active agents finish their current task.
+Changes take effect between waves  -- active agents finish their current task.
 
 ### Multi-window usage display
 
-The usage bar cycles through all rate limit windows (5h, 7d, etc.) every 3 seconds, showing utilization per window. Usage info is shown during all phases — thinking, orchestration, steering, and execution.
+The usage bar cycles through all rate limit windows (5h, 7d, etc.) every 3 seconds, showing utilization per window. Usage info is shown during all phases  -- thinking, orchestration, steering, and execution.
 
 When using extra usage with a budget, a dedicated progress bar shows spend vs limit with color-coded fill (magenta → yellow → red).
 
@@ -311,14 +347,14 @@ When using extra usage with a budget, a dedicated progress bar shows spend vs li
 
 Built for unattended runs lasting hours or days.
 
-- **Smooth overage transition**: when extra usage is allowed, plan limit rejection is seamless — no dispatch blocking, agents continue into overage
-- **Interrupt + resume**: agents and planner queries that go silent are interrupted and resumed with full conversation context via SDK session resume — not killed and restarted from scratch
+- **Smooth overage transition**: when extra usage is allowed, plan limit rejection is seamless  -- no dispatch blocking, agents continue into overage
+- **Interrupt + resume**: agents and planner queries that go silent are interrupted and resumed with full conversation context via SDK session resume  -- not killed and restarted from scratch
 - **Hard block**: pauses until the rate limit window resets, then resumes
 - **Soft throttle**: slows dispatch at >75% utilization
 - **Extra usage guard**: detects overage billing and stops unless explicitly allowed
 - **Cooldown between phases**: waits for rate limit reset after thinking before starting orchestration
 - **Retry with backoff**: transient errors (429, overloaded) retry automatically
-- **Usage cap**: set a ceiling, active agents finish, no new ones start — run is resumable
+- **Usage cap**: set a ceiling, active agents finish, no new ones start  -- run is resumable
 - **Planner retries**: steering and orchestration retry on rate limits (30s/60s/120s backoff) with full context
 
 ## Git worktrees and branch merging

package/dist/bin.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 // Tiny launcher: prints a splash the instant node is ready, then dynamically
 // imports the real entrypoint. Loading `@anthropic-ai/claude-agent-sdk` and the
-// rest of the module graph takes several seconds on a cold cache — without
+// rest of the module graph takes several seconds on a cold cache  -- without
 // this, the terminal sits black that whole time. index.ts stops the splash
 // via `globalThis.__coStopSplash` as soon as its header is about to print.
 const argv = process.argv.slice(2);

package/dist/cli.d.ts

@@ -30,7 +30,7 @@ export declare function appendPasteToSegments(segs: InputSegment[], text: string
 export declare function backspaceSegments(segs: InputSegment[]): void;
 /**
  * Read a line from the user with bracketed-paste awareness.
- * Pasted multi-line text stays in the buffer as a single block — only a typed
+ * Pasted multi-line text stays in the buffer as a single block  -- only a typed
  * Enter submits. Falls back to cooked readline when stdin isn't a TTY.
  */
 export declare function ask(question: string): Promise<string>;

package/dist/cli.js

@@ -58,11 +58,11 @@ export async function fetchModels(timeoutMs = 10_000) {
             // Silent: callers fall back to a text prompt with the current value as default.
         }
         else if (isAuthError(err)) {
-            console.error(chalk.red("\n  Authentication failed — check your API key or run: claude auth\n"));
+            console.error(chalk.red("\n  Authentication failed  -- check your API key or run: claude auth\n"));
             process.exit(1);
         }
         else {
-            console.warn(chalk.yellow(`\n  Could not fetch models: ${String(err.message || err).slice(0, 80)} — continuing with defaults`));
+            console.warn(chalk.yellow(`\n  Could not fetch models: ${String(err.message || err).slice(0, 80)}  -- continuing with defaults`));
         }
         return [];
     }
@@ -72,7 +72,7 @@ export async function fetchModels(timeoutMs = 10_000) {
 // When the terminal is in bracketed paste mode, pasted content is wrapped with
 // \x1B[200~ ... \x1B[201~ so we can distinguish typed Enter from pasted newlines.
 // Multi-line or long pastes are stored as opaque segments and shown as a compact
-// [Pasted +N lines] placeholder while editing — the full text is substituted on submit.
+// [Pasted +N lines] placeholder while editing  -- the full text is substituted on submit.
 export const PASTE_START = "\x1B[200~";
 export const PASTE_END = "\x1B[201~";
 export const PASTE_PLACEHOLDER_MAX = 80;
@@ -150,7 +150,7 @@ function stripAnsi(s) {
 // ── Interactive primitives ──
 /**
  * Read a line from the user with bracketed-paste awareness.
- * Pasted multi-line text stays in the buffer as a single block — only a typed
+ * Pasted multi-line text stays in the buffer as a single block  -- only a typed
  * Enter submits. Falls back to cooked readline when stdin isn't a TTY.
  */
 export function ask(question) {