@bastani/atomic 0.8.31-alpha.1 → 0.8.31-alpha.3

package/CHANGELOG.md

@@ -4,20 +4,32 @@
 
 ### Added
 
-- Added configurable context-window support for models that declare `contextWindowOptions`, including explicit `--context-window` CLI/settings control, a GitHub Copilot CLI-style `/model`-flow picker (numbered `Default`/`Long context` tiers with token counts), session replay, SDK/runtime/RPC APIs, and docs while preserving each model's scalar default context window. For GitHub Copilot, context windows are measured in **input (prompt) tokens** (consistent with every other provider) and derived **dynamically from GitHub's live CAPI model catalog** (`GET /models`) instead of a hardcoded model list: Atomic resolves each model's input budget as `max_prompt_tokens || max_context_window_tokens || 128_000` and, for tiered models, exposes the per-tier input budgets (`token_prices.<tier>.context_max`) as a selectable default/long window — gated on the user actually having the GitHub Copilot provider and cached on disk for 30 minutes (for example `github-copilot/gpt-5.5` resolves to `272k` default / `922k` long, and the Claude/Gemini long-context models to `200k` default / `936k` long). Atomic raises the local budget and sends `X-GitHub-Api-Version: 2026-06-01`, while GitHub applies the long-context billing tier server-side by prompt token count. Long-context Copilot requests consume more AI credits and require Copilot long-context/usage-based billing entitlement; offline, unauthenticated, or non-Copilot sessions leave the built-in window untouched and show no picker; custom providers and explicit model overrides can still expose their own selectable windows ([#1409](https://github.com/bastani-inc/atomic/issues/1409)).
+- Added configurable context-window support for models that declare `contextWindowOptions`, including explicit `--context-window` CLI/settings control, a GitHub Copilot CLI-style `/model`-flow picker (numbered `Default`/`Long context` tiers with token counts), session replay, SDK/runtime/RPC APIs, and docs while preserving each model's scalar default context window. For GitHub Copilot, context windows are measured in **input (prompt) tokens** (consistent with every other provider) and derived **dynamically from GitHub's live CAPI model catalog** (`GET /models`) instead of a hardcoded model list: Atomic resolves each model's input budget as `max_prompt_tokens || max_context_window_tokens || 128_000` and, for tiered models, exposes a selectable default window (`token_prices.default.context_max`) plus a long window set to the model's full `max_context_window_tokens` (retaining `max_prompt_tokens` as the internal effective compaction/overflow budget) — gated on the user actually having the GitHub Copilot provider and cached on disk for 30 minutes (for example `github-copilot/gpt-5.5` exposes `272k` default / `1.05m` long, and the Claude/Gemini long-context models `200k` default / `1m` long). Atomic raises the local budget and sends `X-GitHub-Api-Version: 2026-06-01`, while GitHub applies the long-context billing tier server-side by prompt token count. Long-context Copilot requests consume more AI credits and require Copilot long-context/usage-based billing entitlement; offline, unauthenticated, or non-Copilot sessions leave the built-in window untouched and show no picker; custom providers and explicit model overrides can still expose their own selectable windows ([#1409](https://github.com/bastani-inc/atomic/issues/1409)).
 - Exported context-window helper functions and types from the package root, including parser/formatter/normalizer/selection utilities and the `Model<Api>` augmentation for `contextWindowOptions`/`defaultContextWindow`, so SDK consumers can use the public API without importing internal source paths ([#1409](https://github.com/bastani-inc/atomic/issues/1409)).
-- Added RPC mode runtime context-window commands so headless clients can read supported token budgets with `get_available_context_windows` and select the active runtime budget with `set_context_window` without persisting `defaultContextWindow` settings ([#1409](https://github.com/bastani-inc/atomic/issues/1409)).
+- Added RPC mode runtime context-window commands so headless clients can read supported token budgets with `get_available_context_windows` and select the active runtime budget with `set_context_window` without persisting context-window settings ([#1409](https://github.com/bastani-inc/atomic/issues/1409)).
+- Added upstream pi v0.79.7 automatic theme mode support so `/settings` can choose separate light and dark themes and follow terminal color-scheme changes.
+- Exported the upstream `CONFIG_DIR_NAME` constant and edit diff helpers (`generateDiffString`, `generateUnifiedPatch`, and `EditDiffResult`) from the public SDK entrypoint so extensions can avoid hardcoded project config paths and reuse edit-style diff rendering.
 
 ### Changed
 
-- Changed built-in GitHub Copilot context windows to be measured in **input (prompt) tokens** (matching every other provider) and derived from GitHub's live CAPI model catalog (`GET /models`, cached 30 minutes, gated on the Copilot provider) instead of a hardcoded long-context model list, so newly added/removed Copilot models and retiered windows are reflected automatically without shipping a stale snapshot. Each model's window now resolves to `max_prompt_tokens || max_context_window_tokens || 128_000`, and tiered models expose their per-tier input budgets (`token_prices.<tier>.context_max`) as the selectable default/long windows (e.g. `gpt-5.5` 272k/922k, Claude/Gemini 200k/936k) — replacing the previous input+output totals — while preserving custom provider entries and explicit `models.json` overrides and relying on GitHub's API-version header and server-side tier selection rather than payload fields or model-id variants ([#1409](https://github.com/bastani-inc/atomic/issues/1409)).
+- Changed the GitHub Copilot **long-context tier to advertise the model's full context window** (`max_context_window_tokens`, for example `github-copilot/gpt-5.5` `1.05m`, and `github-copilot/claude-opus-4.8`/`github-copilot/gemini-3.1-pro-preview` `1m`) instead of GitHub's prompt-token cap, so Copilot models report and display the same window as the native `openai/*` and `anthropic/*` providers (the chat footer denominator now shows the full window). GitHub's lower server-side input cap (`max_prompt_tokens`, e.g. `922k`/`936k`, which equals `max_context_window_tokens − max_output_tokens`) is now parsed and carried as an internal effective input budget (`Model.maxInputTokens`, exposed via the new `getEffectiveInputBudget()` helper): auto-compaction thresholds and the Copilot overflow-recovery guard run against that budget while the picker/footer show the full window. As a result, a prompt that reaches the real prompt cap is now compacted-and-retried automatically (previously the long window equalled the cap), and the friendly “enable long-context/usage-based billing / server-cap” hint fires only when GitHub rejects a prompt *below* the cap (a genuine entitlement/tier drop) rather than at the cap. Sparse catalog payloads without `max_context_window_tokens` still fall back to the long-context prompt threshold, and the on-disk Copilot catalog cache schema version was bumped so existing caches refetch the new windows ([#1409](https://github.com/bastani-inc/atomic/issues/1409)).
+- Changed built-in GitHub Copilot context windows to be measured in **input (prompt) tokens** (matching every other provider) and derived from GitHub's live CAPI model catalog (`GET /models`, cached 30 minutes, gated on the Copilot provider) instead of a hardcoded long-context model list, so newly added/removed Copilot models and retiered windows are reflected automatically without shipping a stale snapshot. Each model's window now resolves to `max_prompt_tokens || max_context_window_tokens || 128_000`, and tiered models expose a selectable default window (`token_prices.default.context_max`) plus a long window set to the model's full `max_context_window_tokens` (e.g. `gpt-5.5` 272k/1.05m, Claude/Gemini 200k/1m), with `max_prompt_tokens` retained as the internal effective compaction/overflow budget — while preserving custom provider entries and explicit `models.json` overrides and relying on GitHub's API-version header and server-side tier selection rather than payload fields or model-id variants ([#1409](https://github.com/bastani-inc/atomic/issues/1409)).
 - Bumped the bundled upstream pi runtime libraries `@earendil-works/pi-agent-core`, `@earendil-works/pi-ai`, and `@earendil-works/pi-tui` from `^0.79.4` to `^0.79.6` so Atomic's installed pi runtime packages pick up upstream v0.79.5/v0.79.6 provider, model, thinking-payload, and shared TUI compatibility fixes; no Atomic coding-agent source changes were made for upstream coding-agent-only marked export or fetch-override behavior in this dependency sync ([#1413](https://github.com/bastani-inc/atomic/issues/1413)).
+- Synced Atomic's coding-agent fork with upstream pi v0.79.7, including the new self-only default for bare `atomic update` (`atomic update --all` restores the previous all-packages behavior), automatic light/dark theme settings, configured project config directory labels, extension example updates, model-search parity, tree navigator horizontal panning, and the latest user-facing docs.
+- Bumped the bundled upstream pi runtime libraries `@earendil-works/pi-agent-core`, `@earendil-works/pi-ai`, and `@earendil-works/pi-tui` from `^0.79.6` to `^0.79.7` so Atomic inherits upstream v0.79.7 TUI color-scheme, Warp image, generated model catalog, and agent-core fixes.
+- Reserved `/` in theme names for automatic light/dark theme settings.
+- Replaced the bundled `browser` skill / `browse` CLI with the `playwright-cli` skill and `playwright-cli` command across `@bastani/atomic`, and bundled the new `effective-liteparse` document-extraction skill. The builtin `ralph`, `goal`, and `open-claude-design` workflows and the `debugger`/`codebase-online-researcher` subagents now drive browsers via `playwright-cli`; `open-claude-design`'s deterministic setup step ensures `playwright-cli` (`npm install -g @playwright/cli@latest`) and renames its `browse_cli_status` output to `playwright_cli_status`; and `ralph` now records a `playwright-cli` QA end-to-end proof video (`qa_video_path`) for UI-applicable/full-stack changes, references it in the implementation notes, and attaches or links it to the final pull request when `create_pr=true`. Updated the user-facing docs (workflows, SDK bash-policy examples, quickstart skills, README) to match.
+
 
 ### Fixed
 
+- Fixed RPC unknown-command errors to include the request id so RPC clients do not hang waiting for a response.
+- Fixed `/model` autocomplete and model-selection searches to match provider/model queries regardless of whether the provider or model token is typed first.
+- Fixed the tree navigator to horizontally pan deep entries so the selected item remains readable.
+- Fixed long-context selection for GitHub Copilot's rounded 1M model names: requesting `1m` now selects the advertised full context window when the catalog exposes it, and otherwise resolves to the largest advertised long-context window at or below the request (for example `936k` for sparse catalog payloads) instead of falling back to the short `200k` tier. Interactive/context-picker persistence now writes the effective selected budget to per-model `defaultContextWindows["provider/modelId"]` settings instead of the global `defaultContextWindow` fallback, so Copilot-specific prompt caps such as `936k`/`922k` do not leak into Anthropic, Cursor, or other providers on restart. Legacy/stale global `defaultContextWindow` values from earlier builds are now treated as optional fallbacks and ignored without warning when unsupported by the active model.
 - Fixed a GitHub Copilot context-window warning on restart: after selecting a long-context window (e.g. `claude-opus-4.8` → `936k`) and reopening Atomic, startup validated the persisted selection before the (async, auth-gated) Copilot catalog loaded, so the model still looked limited to its default window and Atomic warned “Context window 936k is not supported… Supported values: 200k” and reset the choice. The model registry now seeds the Copilot context-window catalog synchronously from its on-disk cache at construction (ignoring the refresh TTL, gated on a `github-copilot` credential), so a returning user's selection is recognized immediately while the live refresh still runs in the background ([#1409](https://github.com/bastani-inc/atomic/issues/1409)).
-- Fixed context-window startup, session-switch, settings, and RPC edge cases: unknown provider fallback models no longer inherit selectable context-window options from provider defaults, fatal startup diagnostics no longer persist `defaultContextWindow`, `AgentSession.setModel()` preserves an incoming target model's explicit selected context window, model-switch paths that change effective context windows now notify listeners via `context_window_changed`, the interactive context-window picker keys selection on raw token counts so colliding formatted labels never change which window is selected, RPC `set_model` returns the effective post-switch session model, and explicit startup `contextWindow` selections are journaled even when they equal the model scalar default ([#1409](https://github.com/bastani-inc/atomic/issues/1409)).
-- Fixed `AgentSession.setContextWindow()` so bare SDK/runtime calls update the active session, append `context_window_change`, and emit `context_window_changed` without persisting `defaultContextWindow`; callers must pass `{ persistDefault: true }` to update settings ([#1409](https://github.com/bastani-inc/atomic/issues/1409)).
+- Fixed context-window startup, session-switch, settings, and RPC edge cases: unknown provider fallback models no longer inherit selectable context-window options from provider defaults, fatal startup diagnostics no longer persist context-window settings, `AgentSession.setModel()` preserves an incoming target model's explicit selected context window, model-switch paths that change effective context windows now notify listeners via `context_window_changed`, the interactive context-window picker keys selection on raw token counts so colliding formatted labels never change which window is selected, RPC `set_model` returns the effective post-switch session model, and explicit startup `contextWindow` selections are journaled even when they equal the model scalar default ([#1409](https://github.com/bastani-inc/atomic/issues/1409)).
+- Fixed `AgentSession.setContextWindow()` so bare SDK/runtime calls update the active session, append `context_window_change`, and emit `context_window_changed` without persisting settings; callers must pass `{ persistDefault: true }` to update the active model's `defaultContextWindows["provider/modelId"]` setting ([#1409](https://github.com/bastani-inc/atomic/issues/1409)).
 - Fixed `packages/coding-agent` source-CLI subprocess tests (`session-id-readonly`, `startup-session-name`, `stdout-cleanliness`) crashing with `ERR_MODULE_NOT_FOUND` (for example `src/core/tools/oversized-tool-result.js`) when the Vitest worker pool runs under Node. They now launch the TypeScript source CLI with Bun explicitly via a `bunExecutable()` helper (matching `context-window-cli`/`rpc-context-window`) instead of assuming `process.execPath` is Bun, so the package test suite is portable across environments. The repo-wide `.js`->`.ts` source-import convention and shipped `dist/` are unchanged ([#1419](https://github.com/bastani-inc/atomic/issues/1419)).
 
 ## [0.8.30] - 2026-06-17

package/README.md

@@ -385,15 +385,16 @@ atomic install ssh://git@github.com/user/repo@v1    # tag or commit
 atomic remove npm:@foo/atomic-tools
 atomic uninstall npm:@foo/atomic-tools          # alias for remove
 atomic list
-atomic update                               # update Atomic and packages (skips pinned packages)
+atomic update                               # update Atomic only
+atomic update --all                         # update Atomic and packages
 atomic update --extensions                  # update packages only
 atomic update --self                        # update Atomic only
 atomic update --self --force                # reinstall Atomic even if current
-atomic update npm:@foo/atomic-tools             # update one package
+atomic update npm:@foo/atomic-tools         # update one package
 atomic config                               # enable/disable extensions, skills, prompts, themes
 ```
 
-Packages install to `~/.atomic/agent/git/` (git) or global npm. Use `-l` for project-local installs (`.atomic/git/`, `.atomic/npm/`; legacy `.pi/git/` and `.pi/npm/` are compatibility fallbacks). Git packages install dependencies with `npm install --omit=dev` by default, so runtime deps must be listed under `dependencies`; when `npmCommand` is configured, git packages use plain `install` for compatibility with wrappers. If you use a Node version manager and want package installs to reuse a stable npm context, set `npmCommand` in `settings.json`, for example `["mise", "exec", "node@20", "--", "npm"]`.
+Packages install to `~/.atomic/agent/git/` (git) or global npm. Use `-l` for project-local installs (`.atomic/git/`, `.atomic/npm/`; legacy `.pi/git/` and `.pi/npm/` are compatibility fallbacks). Git `@ref` values are pinned tags or commits; pinned packages are skipped by `atomic update --extensions` and `atomic update --all`, so use `atomic install git:host/user/repo@new-ref` to move an existing package to a new ref. Git packages install dependencies with `npm install --omit=dev` by default, so runtime deps must be listed under `dependencies`; when `npmCommand` is configured, git packages use plain `install` for compatibility with wrappers. If you use a Node version manager and want package installs to reuse a stable npm context, set `npmCommand` in `settings.json`, for example `["mise", "exec", "node@20", "--", "npm"]`.
 
 Create a package by adding an app-name manifest key to `package.json` (`atomic` for this package). The legacy `pi` key is still accepted as a backwards-compatible shim:
 
@@ -480,16 +481,17 @@ atomic [options] [@files...] [messages...]
 ### Package Commands
 
 ```bash
-atomic install <source> [-l]     # Install package, -l for project-local
-atomic remove <source> [-l]      # Remove package
-atomic uninstall <source> [-l]   # Alias for remove
-atomic update [source|self|atomic]   # Update Atomic and packages (skips pinned packages)
+atomic install <source> [-l]         # Install package, -l for project-local
+atomic remove <source> [-l]          # Remove package
+atomic uninstall <source> [-l]       # Alias for remove
+atomic update [source|self|atomic]   # Update Atomic only, or one package source
+atomic update --all                  # Update Atomic and packages
 atomic update --extensions           # Update packages only
 atomic update --self                 # Update Atomic only
 atomic update --self --force         # Reinstall Atomic even if current
-atomic update --extension <src>  # Update one package
-atomic list                      # List installed packages
-atomic config                    # Enable/disable package resources
+atomic update --extension <src>      # Update one package
+atomic list                          # List installed packages
+atomic config                        # Enable/disable package resources
 ```
 
 ### Modes

package/dist/builtin/cursor/CHANGELOG.md

@@ -4,7 +4,7 @@
 
 ### Changed
 
-- Published a synchronized Atomic 0.8.31-alpha.1 prerelease; no functional Cursor provider changes were made after 0.8.30.
+- Published a synchronized Atomic 0.8.31-alpha.3 prerelease; no functional Cursor provider changes were made after 0.8.30.
 
 ## [0.8.30] - 2026-06-17
 

package/dist/builtin/cursor/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/cursor",
-  "version": "0.8.31-alpha.1",
+  "version": "0.8.31-alpha.3",
   "private": true,
   "description": "Experimental first-party Atomic extension for Cursor OAuth, model discovery, and streaming provider registration.",
   "contributors": [
@@ -40,7 +40,7 @@
     }
   },
   "dependencies": {
-    "@bastani/atomic-natives": "0.8.31-alpha.1",
+    "@bastani/atomic-natives": "0.8.31-alpha.3",
     "@bufbuild/protobuf": "^2.0.0"
   }
 }

package/dist/builtin/intercom/CHANGELOG.md

@@ -6,7 +6,7 @@ All notable changes to the `pi-intercom` extension will be documented in this fi
 
 ### Changed
 
-- Aligned the intercom extension peer dependency with upstream pi TUI `^0.79.6` so coordination UI surfaces consume the latest shared TUI compatibility fixes; no intercom extension code changes were made for this metadata sync ([#1413](https://github.com/bastani-inc/atomic/issues/1413)).
+- Aligned the intercom extension peer dependency with upstream pi TUI `^0.79.7` so coordination UI surfaces consume the latest shared TUI color-scheme, Warp image capability, and compatibility fixes; no intercom extension code changes were made for this metadata sync ([#1413](https://github.com/bastani-inc/atomic/issues/1413)).
 
 ## [0.8.30] - 2026-06-17
 

package/dist/builtin/intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/intercom",
-  "version": "0.8.31-alpha.1",
+  "version": "0.8.31-alpha.3",
   "private": true,
   "description": "Atomic extension providing a private coordination channel between parent and child agent sessions. Fork of: https://github.com/nicobailon/pi-intercom",
   "contributors": [
@@ -39,7 +39,7 @@
   },
   "peerDependencies": {
     "@bastani/atomic": "*",
-    "@earendil-works/pi-tui": "^0.79.6"
+    "@earendil-works/pi-tui": "^0.79.7"
   },
   "peerDependenciesMeta": {
     "@bastani/atomic": {

package/dist/builtin/mcp/CHANGELOG.md

@@ -9,7 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
-- Aligned the MCP extension peer dependencies with upstream pi AI/TUI `^0.79.6` so MCP-backed sessions can use the host's latest provider, model, thinking-payload, and shared TUI compatibility fixes; no MCP extension code changes were made for this metadata sync ([#1413](https://github.com/bastani-inc/atomic/issues/1413)).
+- Aligned the MCP extension peer dependencies with upstream pi AI/TUI `^0.79.7` so MCP-backed sessions can use the host's latest provider catalog, model-search, theme/color-scheme, Warp image capability, and shared TUI compatibility fixes; no MCP extension code changes were made for this metadata sync ([#1413](https://github.com/bastani-inc/atomic/issues/1413)).
 
 ## [0.8.30] - 2026-06-17
 

package/dist/builtin/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/mcp",
-  "version": "0.8.31-alpha.1",
+  "version": "0.8.31-alpha.3",
   "private": true,
   "description": "Atomic extension that adapts MCP (Model Context Protocol) servers into the coding agent. Fork of: https://github.com/nicobailon/pi-mcp-adapter",
   "contributors": [
@@ -32,8 +32,8 @@
   },
   "peerDependencies": {
     "@bastani/atomic": "*",
-    "@earendil-works/pi-ai": "^0.79.6",
-    "@earendil-works/pi-tui": "^0.79.6",
+    "@earendil-works/pi-ai": "^0.79.7",
+    "@earendil-works/pi-tui": "^0.79.7",
     "zod": "^3.25.0 || ^4.0.0"
   },
   "peerDependenciesMeta": {

package/dist/builtin/subagents/CHANGELOG.md

@@ -2,9 +2,18 @@
 
 ## [Unreleased]
 
+### Added
+
+- Added the `playwright-cli` builtin skill (browser automation, end-to-end UI checks, screenshots, reviewable video recording, and Playwright test workflows) and the `effective-liteparse` builtin skill (fast, local, model-free text/table/value extraction from PDF, DOCX, PPTX, XLSX, and image files via the `lit` CLI).
+
 ### Changed
 
-- Aligned the subagents extension peer dependencies with upstream pi `^0.79.6` runtime packages (`@earendil-works/pi-agent-core`, `@earendil-works/pi-ai`, and `@earendil-works/pi-tui`) so child sessions can use the host's latest provider, model, thinking-payload, and shared TUI compatibility fixes; no subagents extension code changes were made for this metadata sync ([#1413](https://github.com/bastani-inc/atomic/issues/1413)).
+- Changed the `debugger` and `codebase-online-researcher` subagents to load the `playwright-cli` skill and drive the `playwright-cli` command for JS-heavy, auth-gated, or interactive web work instead of the removed `browser` skill / `browse` CLI.
+- Aligned the subagents extension peer dependencies with upstream pi `^0.79.7` runtime packages (`@earendil-works/pi-agent-core`, `@earendil-works/pi-ai`, and `@earendil-works/pi-tui`) so child sessions can use the host's latest provider catalog, RPC id handling, model-search, theme/color-scheme, Warp image capability, and shared TUI compatibility fixes; no subagents extension code changes were made for this metadata sync ([#1413](https://github.com/bastani-inc/atomic/issues/1413)).
+
+### Removed
+
+- Removed the bundled `browser` skill and all references to its `browse` CLI in favor of the `playwright-cli` skill and `playwright-cli` command.
 
 ## [0.8.30] - 2026-06-17
 

package/dist/builtin/subagents/agents/codebase-online-researcher.md

@@ -4,7 +4,7 @@ description: Online research for up-to-date documentation and library-source kno
 tools: read, grep, find, ls, bash, web_search, fetch_content, get_search_content
 model: openai/gpt-5.5:low
 fallbackModels: openai-codex/gpt-5.5:low, github-copilot/gpt-5.5:low, anthropic/claude-opus-4-8:low, github-copilot/claude-opus-4.7:low
-skills: browser
+skills: playwright-cli
 ---
 
 You are an expert research specialist focused on finding accurate, relevant information from authoritative sources — including open-source library internals with GitHub permalinks. You have three web tools available:
@@ -13,11 +13,11 @@ You are an expert research specialist focused on finding accurate, relevant info
 - `fetch_content` — fetch a specific URL and return clean reader-mode text/markdown (HTML pages, GitHub issues/PRs, Stack Overflow, npm, arXiv, Reddit, Wikipedia, JSON endpoints, PDFs, RSS/Atom, YouTube). `fetch_content` on a GitHub repo URL also clones the repo locally under `/tmp/atomic-github-repos/<owner>/<repo>` and returns the file tree. Prefer this over a raw HTTP fetch.
 - `get_search_content` — fetch the underlying content for the most promising results of a previous `web_search` in one call.
 
-For JS-heavy or auth-gated pages, load the `browser` skill and invoke its `browse` CLI through `bash`.
+For JS-heavy or auth-gated pages, load the `playwright-cli` skill and drive its `playwright-cli` command through `bash`.
 
 <EXTREMELY_IMPORTANT>
 - PREFER `fetch_content` for static pages; it's faster and cheaper than spinning up a real browser.
-- Reach for the `browser` skill's `browse` CLI via `bash` ONLY when a real DOM/JS is required.
+- Reach for the `playwright-cli` skill's `playwright-cli` command via `bash` ONLY when a real DOM/JS is required.
 - ALWAYS check `research/web/` for a recent cached copy before fetching anything new.
 - EVERY code-related claim about an open-source library needs a GitHub **permalink with a full commit SHA** — branch links break when code changes.
 </EXTREMELY_IMPORTANT>
@@ -39,7 +39,7 @@ When fetching any external page, apply these techniques in order. They produce p
 1. **`fetch_content <url>` first.** Returns clean reader-mode text/markdown for nearly every well-formed page (and handles PDFs and JSON). Try it before anything else.
 2. **Check `/llms.txt`.** Many modern docs sites publish an AI-friendly index at `/llms.txt` (spec: [llmstxt.org](https://llmstxt.org/llms.txt)). `fetch_content https://<site>/llms.txt` often links directly to the most relevant pages in plain text, saving a round-trip through the full site.
 3. **Request Markdown via `Accept: text/markdown`.** Sites behind Cloudflare with [Markdown for Agents](https://developers.cloudflare.com/fundamentals/reference/markdown-for-agents/) return pre-converted Markdown when you set the header. Use `bash` with `curl <url> -H "Accept: text/markdown"` (look for `content-type: text/markdown` and the `x-markdown-tokens` header).
-4. **Fall back to a real browser.** Load the `browser` skill and drive its `browse` CLI through `bash` to render and interact with JS-heavy or auth-gated pages.
+4. **Fall back to a real browser.** Load the `playwright-cli` skill and drive its `playwright-cli` command through `bash` to render and interact with JS-heavy or auth-gated pages.
 
 ## Library Source Research with Permalinks
 
@@ -151,12 +151,12 @@ When you receive a research query:
 2. **Check the local cache first**. Look in `research/web/` for existing documents on the topic. If a recent (still-relevant) copy exists, cite it before re-fetching.
 3. **Execute strategic searches**.
     - Identify the authoritative source (e.g. the library's official docs site, its GitHub repo, its release notes).
-    - Apply the Web Fetch Strategy: `fetch_content <url>` → `/llms.txt` → `Accept: text/markdown` → `browser` fallback.
+    - Apply the Web Fetch Strategy: `fetch_content <url>` → `/llms.txt` → `Accept: text/markdown` → `playwright-cli` fallback.
     - Use multiple query variations to capture different perspectives via `web_search`.
     - Use `get_search_content` to bulk-fetch the underlying content of the top results of a `web_search` in one shot.
     - For source repositories, prefer raw GitHub URLs (`https://raw.githubusercontent.com/<owner>/<repo>/<ref>/<path>`) over the HTML UI. For library internals, clone via `fetch_content` and use `grep`/`read` + permalinks.
 4. **Fetch and analyze content**.
-    - Use `fetch_content <url>` (or the browser skill's `browse` CLI via `bash` when interactivity is required) to pull the full content of promising sources.
+    - Use `fetch_content <url>` (or the playwright-cli skill's `playwright-cli` command via `bash` when interactivity is required) to pull the full content of promising sources.
     - Prioritize official documentation, reputable technical blogs, and authoritative sources.
     - Extract specific quotes and sections relevant to the query.
     - Note publication dates to ensure currency of information.
@@ -275,7 +275,7 @@ For library-source answers, every code claim should look like the citation examp
 ## Search Efficiency
 
 - Check `research/web/` for an existing copy before fetching anything new.
-- Start by fetching the authoritative source (`fetch_content <url>` → `/llms.txt` → `Accept: text/markdown` → `browser`) rather than search-engine-style exploration.
+- Start by fetching the authoritative source (`fetch_content <url>` → `/llms.txt` → `Accept: text/markdown` → `playwright-cli`) rather than search-engine-style exploration.
 - Use `fetch_content` (or `get_search_content` after a `web_search`) to pull full content from the most promising 3-5 web pages.
 - Reuse already-cloned repos under `/tmp/atomic-github-repos/` instead of re-cloning.
 - If initial results are insufficient, refine search terms and try again.
@@ -298,4 +298,4 @@ For library-source answers, every code claim should look like the citation examp
 | Page returns 403 / bot block   | Gemini fallback triggers automatically; no action needed if Gemini is configured.                              |
 | `web_search` fails             | Check provider config; try explicit `provider: "gemini"` if a Perplexity key is missing.                       |
 
-Remember: you are the user's expert guide to technical research. Lean on `fetch_content` first with the `/llms.txt` → `Accept: text/markdown` → `browser` fallback chain to efficiently pull authoritative content, clone open-source repos when implementation evidence is needed, store anything reusable under `research/web/`, and deliver comprehensive, up-to-date answers with exact citations and GitHub permalinks. Answer directly — skip preamble like "I'll help you with…" and go straight to findings.
+Remember: you are the user's expert guide to technical research. Lean on `fetch_content` first with the `/llms.txt` → `Accept: text/markdown` → `playwright-cli` fallback chain to efficiently pull authoritative content, clone open-source repos when implementation evidence is needed, store anything reusable under `research/web/`, and deliver comprehensive, up-to-date answers with exact citations and GitHub permalinks. Answer directly — skip preamble like "I'll help you with…" and go straight to findings.

package/dist/builtin/subagents/agents/debugger.md

@@ -4,7 +4,7 @@ description: Debug errors, test failures, and unexpected behavior. Use PROACTIVE
 tools: read, grep, find, ls, bash, web_search, fetch_content, get_search_content
 model: openai/gpt-5.5:xhigh
 fallbackModels: openai-codex/gpt-5.5:xhigh, github-copilot/gpt-5.5:xhigh, anthropic/claude-opus-4-8:xhigh, github-copilot/claude-opus-4.7:xhigh
-skills: tdd, browser, tmux
+skills: tdd, playwright-cli, tmux
 ---
 
 You are tasked with debugging and identifying errors, test failures, and unexpected behavior in the codebase. Your goal is to identify root causes and generate a report detailing the issues and proposed fixes, so another agent can implement the solutions you suggest.
@@ -13,13 +13,13 @@ You are tasked with debugging and identifying errors, test failures, and unexpec
 
 - `tdd` — load the TDD skill before creating or modifying any tests.
 - `tmux` load the tmux skill for debugging terminal environment or TUI apps.
-- `browser` — load the browser skill for debugging web apps. Assume the `browse` CLI is installed; if it fails, follow the skill setup (`which browse || npm install -g browse`) or use `npx browse`.
+- `playwright-cli` — load the playwright-cli skill for debugging web apps. If the `playwright-cli` command is missing, install it per the skill (`npx --no-install playwright-cli --version` || `npm install -g @playwright/cli@latest`); install a browser with `npx playwright install chromium` if one is missing.
 - `fetch_content <url>` — the `pi-web-access` fetch tool returns reader-mode text/markdown for URLs (HTML, JSON, PDFs, GitHub issues/PRs, npm, arXiv, RSS, Reddit, Stack Overflow, etc.). Prefer it over a real browser when you only need page content.
 - `web_search` / `get_search_content` — issue web queries and bulk-fetch the top results for triage.
-- `browse` (via `bash` after loading the `browser` skill) — full Chromium when you need JS execution, auth, or interactive actions. Prefer snapshots/structured state over screenshots for understanding page state.
+- `playwright-cli` (via `bash` after loading the playwright-cli skill) — full Chromium when you need JS execution, auth, or interactive actions. Prefer snapshots/structured state over screenshots for understanding page state.
 
 <EXTREMELY_IMPORTANT>
-- PREFER `fetch_content <url>` for static content. Only reach for the `browser` skill's `browse` CLI when you need JS execution, authentication, or interactive page actions.
+- PREFER `fetch_content <url>` for static content. Only reach for the `playwright-cli` skill when you need JS execution, authentication, or interactive page actions.
 - ALWAYS `tdd` BEFORE creating or modifying any tests.
 - NEVER suppress a failing test to make it pass. Reproduce the failure first; only then fix the underlying defect.
 </EXTREMELY_IMPORTANT>
@@ -45,7 +45,7 @@ When you need to consult docs, forums, or issue trackers, apply these techniques
 1. **`fetch_content <url>` first.** The fetch tool returns clean reader-mode text/markdown for HTML, GitHub issues/PRs, Stack Overflow, npm, arXiv, RSS, Wikipedia, Reddit, JSON endpoints, and PDFs — no browser needed.
 2. **Check `/llms.txt`.** Many modern docs sites publish an AI-friendly index at `/llms.txt` (spec: [llmstxt.org](https://llmstxt.org/llms.txt)). Try `fetch_content https://<site>/llms.txt` before anything else; it often links directly to the most relevant pages in plain text.
 3. **`Accept: text/markdown` header.** Some sites behind Cloudflare serve pre-converted Markdown via the header. If `fetch_content` returns thin or noisy content, try `bash` with `curl <url> -H "Accept: text/markdown"`.
-4. **Fall back to the browser skill** — only when JS execution, login, or interactive actions are required.
+4. **Fall back to the playwright-cli skill** — only when JS execution, login, or interactive actions are required.
 
 ## Workflow
 
@@ -77,7 +77,7 @@ Debugging process:
 - Form and test hypotheses
 - Add strategic debug logging or drive the project's own debugger (`bun --inspect`, `node --inspect-brk`, `python -m pdb`, etc.) through `bash` instead of `print` spam
 - Inspect variable state by capturing it through the project's debugger session in `bash` or by writing a short repro script
-- Use the web research order above (`fetch_content <url>` → `/llms.txt` → `Accept: text/markdown` → browser) to look up external library docs, error messages, Stack Overflow threads, and GitHub issues
+- Use the web research order above (`fetch_content <url>` → `/llms.txt` → `Accept: text/markdown` → playwright-cli) to look up external library docs, error messages, Stack Overflow threads, and GitHub issues
 
 For each issue, provide:
 

package/dist/builtin/subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/subagents",
-  "version": "0.8.31-alpha.1",
+  "version": "0.8.31-alpha.3",
   "private": true,
   "description": "Atomic extension for delegating tasks to subagents with chains, parallel execution, and TUI clarification. Fork of: https://github.com/nicobailon/pi-subagents",
   "contributors": [
@@ -38,9 +38,9 @@
   },
   "peerDependencies": {
     "@bastani/atomic": "*",
-    "@earendil-works/pi-agent-core": "^0.79.6",
-    "@earendil-works/pi-ai": "^0.79.6",
-    "@earendil-works/pi-tui": "^0.79.6"
+    "@earendil-works/pi-agent-core": "^0.79.7",
+    "@earendil-works/pi-ai": "^0.79.7",
+    "@earendil-works/pi-tui": "^0.79.7"
   },
   "peerDependenciesMeta": {
     "@bastani/atomic": {

package/dist/builtin/subagents/skills/effective-liteparse/SKILL.md

@@ -0,0 +1,118 @@
+---
+name: effective-liteparse
+description: Use this skill whenever a task involves a document file (PDF, DOCX, PPTX, XLSX, or image) and you need to read it or pull text, tables, or specific values out of it — to answer a question about its contents, look up a figure, or extract data. Provides fast, local, model-free extraction via the `lit` CLI with disciplined, low-cost search patterns.
+compatibility: Requires Node 18+ and `@llamaindex/liteparse` (`npm i -g @llamaindex/liteparse`, verify `lit --version`). LibreOffice for Office files; ImageMagick for images. The bundled search.py helper needs `uv`.
+license: MIT
+metadata:
+  author: LlamaIndex
+  version: "1.0.0"
+---
+
+# Effective LiteParse
+
+Extract text from documents locally with the `lit` CLI — a fast, model-free parser. This skill is
+about using it **cheaply**: each `lit parse` re-runs full extraction, and every line you dump into
+the conversation is paid for on every subsequent turn. The patterns below come from analyzing real
+agent traces where the same PDF was parsed up to **9 times** and single image reads cost
+**140k+ characters** of context. Don't repeat those mistakes.
+
+## The golden rule: parse ONCE to a file, then search the file
+
+`lit parse` re-extracts the whole document every time you call it. Re-parsing per search is the #1
+waste seen in traces. Parse a document exactly once, to a temp file, then run all your searches
+against that file:
+
+```bash
+# ONE TIME, per document. --no-ocr for born-digital PDFs (almost all reports) — much faster.
+lit parse "/abs/path/doc.pdf" --format text --no-ocr -o /tmp/doc.txt && wc -l /tmp/doc.txt
+```
+
+Then search the file with cheap shell tools — **never** re-run `lit parse` to search again.
+
+## Search discipline — minimize ROUND-TRIPS, then keep results small
+
+Every Bash call is a full model round-trip (latency + re-read of context). The biggest waste after
+parsing is a **serial** loop: grep → look → grep again → `sed` to read the window → grep again. In
+traces this doubled the turn count versus just reading the doc. Two rules fix it:
+
+**1. Get context in the SAME command — don't grep then `sed`.** Use `grep -C` so the surrounding
+lines come back with the hit. This removes the follow-up `sed` turn for the common case:
+
+```bash
+grep -n -i -C4 "total assets" /tmp/doc.txt | head -40      # location AND its window, one turn
+```
+
+Only fall back to `sed -n 'A,Bp'` when you already know the exact line and need a *wider* window
+than `-C` gave you.
+
+**2. Batch independent lookups into ONE command.** When a question needs several distinct facts
+(e.g. emissions *and* revenue), don't spend one turn per term. Probe them together with labels:
+
+```bash
+for q in "carbon intensity" "scope 1" "total revenue"; do \
+  echo "=== $q ==="; grep -n -i -C3 "$q" /tmp/doc.txt | head -25; done
+```
+
+Then keep results small:
+
+- **Always bound output** with `head` and use `-n` for line numbers.
+- **Don't fan out blindly.** Aim to resolve a question in ≤3 search commands. If two targeted greps
+  don't pin it down, switch to `search.py` (below) — don't keep firing keyword variations one per turn.
+- Prefer **Bash `grep`/`sed` on the saved file over the Read and Grep tools** — fewer round-trips and
+  you control output size precisely.
+
+## Ranked search when keywords are uncertain (bundled helper)
+
+When two targeted greps haven't pinned the answer, **stop greping** — don't iterate keyword variants
+one turn at a time. Run the bundled BM25 ranker ONCE to surface the most relevant line-windows in a
+single command:
+
+```bash
+./.claude/skills/effective-liteparse/scripts/search.py /tmp/doc.txt -q "materiality assessment priority topics" -k 8 -e 5
+```
+
+`-k` = number of matches, `-e` = lines of context around each (so the window comes back inline — no
+follow-up `sed` turn). It returns ranked windows with line numbers. Use a rich natural-language query
+(several synonyms in one string), not a single keyword. This replaces a long chain of speculative greps.
+
+## Born-digital vs scanned
+
+- **Born-digital PDF** (real text layer — nearly all corporate/finance/ESG reports): always pass
+  `--no-ocr`. It's much faster and the text is identical. Leaving OCR on wastes time.
+- **Scanned PDF / image**: drop `--no-ocr`. If the value is missing or digits look wrong, read the
+  page visually (see below) rather than trusting OCR.
+
+## Reading a page visually — last resort, ONE screenshot, modest DPI
+
+Screenshots are the most expensive thing you can put in context: a single high-DPI page PNG ran
+**~140k characters** in one trace, and agents often rendered the same page twice (default + hi-res).
+
+Only screenshot when text/tables genuinely can't answer the question (dense multi-column tables,
+figures, charts). Then:
+
+- Render **one** page at a time with `--target-pages "N"` (note: it's `--target-pages`, NOT `--pages`).
+- Use **modest DPI (~150–200)**. Do not start at 300+; do not re-render the same page at higher DPI
+  unless the text is actually illegible.
+
+```bash
+lit screenshot "/abs/path/doc.pdf" --target-pages "13" --dpi 150 -o /tmp/shots/   # then Read the PNG
+```
+
+## Many questions about the same document
+
+Parsing once to a file already covers this: keep the `/tmp/doc.txt` and reuse it across every
+question instead of re-parsing.
+
+## Don't waste turns on preamble
+
+Skip `lit --version`, `ls -la`, and `lit … --help` unless something actually failed. Go straight to
+the parse. Core flags you need:
+
+`--format text|json` · `--no-ocr` · `--target-pages "1-5,10"` · `--dpi <n>` (default 150) ·
+`--ocr-language <iso>`. Use `--format json` only when you need bounding boxes/layout — it's much
+larger; still search it, never load it whole.
+
+## Setup
+
+PDFs work out of the box. If `lit` is missing: `npm i -g @llamaindex/liteparse`. Office docs need
+LibreOffice; images need ImageMagick (both auto-converted to PDF).

package/dist/builtin/subagents/skills/effective-liteparse/scripts/search.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env -S uv run --script
+# /// script
+# requires-python = ">=3.13"
+# dependencies = [
+#   "bm25s>=0.3.9,<1",
+#   "aiofiles>=25.1.0,<26",
+# ]
+# ///
+import argparse
+import asyncio
+from typing import TypedDict, cast
+
+import aiofiles
+import bm25s
+
+
+class LineRecord(TypedDict):
+    index: int
+    content: str
+
+
+def _chunk(content: str) -> list[LineRecord]:
+    return [{"index": i, "content": c} for (i, c) in enumerate(content.splitlines())]
+
+
+def _expand(corpus: list[LineRecord], match: LineRecord, n: int) -> str:
+    idx = match["index"]
+    start = max(0, idx - n)
+    end = min(len(corpus) - 1, idx + n)
+    return f"Lines {start} - {end}\n\n\n" + "\n".join(
+        [c["content"] for c in corpus[start : end + 1]]
+    )
+
+
+def _retrieve(
+    corpus: list[LineRecord], query: str, top_k: int | None, expand: int = 0
+) -> list[tuple[str, float]]:
+    corpus_tokens = bm25s.tokenize([c["content"] for c in corpus])
+    retriever = bm25s.BM25(corpus=corpus)
+    retriever.index(corpus_tokens)
+    query_tokens = bm25s.tokenize(query)
+    docs, scores = retriever.retrieve(query_tokens, k=top_k or 10)
+
+    results: list[tuple[str, float]] = []
+    for doc, score in zip(docs[0].tolist(), scores[0].tolist()):
+        window = _expand(corpus, doc, expand) if expand > 0 else [doc]
+        results.append((cast(str, window), score))
+    return results
+
+
+def _chunk_and_retrieve(
+    content: str, query: str, top_k: int | None, expand_n: int
+) -> list[tuple[str, float]]:
+    corpus = _chunk(content)
+    return _retrieve(corpus, query, top_k, expand_n)
+
+
+async def process_chunk(
+    content: bytes, query: str, top_k: int | None, expand_n: int
+) -> list[tuple[str, float]]:
+    loop = asyncio.get_event_loop()
+    return await loop.run_in_executor(
+        None,
+        _chunk_and_retrieve,
+        content.decode("utf-8"),
+        query,
+        top_k,
+        expand_n,
+    )
+
+
+async def read_and_process(
+    file_path: str, query: str, top_k: int | None, expand_n: int | None
+) -> list[str]:
+    tasks: list[asyncio.Task[list[tuple[str, float]]]] = []
+    async with asyncio.TaskGroup() as tg:
+        async with aiofiles.open(file_path, "rb") as f:
+            # read 64KB chunks
+            while chunk := await f.read(65536):
+                tasks.append(
+                    tg.create_task(process_chunk(chunk, query, top_k, expand_n or 5))
+                )
+    results = [task.result() for task in tasks]
+    flattened = [r for result in results for r in result if r[1] >= 0.5]
+    flattened.sort(key=lambda x: x[1], reverse=True)
+    n = top_k or 10
+    return [f[0] for f in flattened][:n]
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("file_path", help="Path to the text file to search")
+    parser.add_argument(
+        "-q", "--query", help="Keyword-based query to search for", required=True
+    )
+    parser.add_argument(
+        "-k",
+        "--top-k",
+        help="Top K matches to retrieve. Defaults to 10.",
+        required=False,
+        type=int,
+        default=None,
+    )
+    parser.add_argument(
+        "-e",
+        "--expand",
+        help="Expand the matched content by N lines (before and after). Defaults to 5",
+        required=False,
+        type=int,
+        default=None,
+    )
+    args = parser.parse_args()
+    results = asyncio.run(
+        read_and_process(args.file_path, args.query, args.top_k, args.expand)
+    )
+    if results:
+        separator = "\n" + "─" * 60 + "\n"
+        for i, r in enumerate(results):
+            print(f"Match #{i}")
+            print(r.rstrip("\n").lstrip("\n"))
+            if i < len(results) - 1:
+                print(separator)
+    else:
+        print("No relevant matches found")
+
+
+if __name__ == "__main__":
+    main()