@counterposition/skill-pi 0.87.1 → 1.0.0

package/skills/pi/references/sdk.md

@@ -30,10 +30,15 @@ session.subscribe((event) => {
   }
 });
 
-await session.prompt("What files are in the current directory?");
+try {
+  await session.prompt("What files are in the current directory?");
+  console.log(session.getLastAssistantText());
+} finally {
+  session.dispose();
+}
 ```
 
-Run with `npx tsx my-script.ts`.
+Run with `npx tsx my-script.ts` (or Node's built-in type stripping). `prompt()` resolves when the run finishes, including automatic retries. `session.dispose()` aborts active work, invalidates extension contexts, and removes listeners. Checked against Pi v1.0.0: [sdk.md](https://github.com/earendil-works/pi/blob/v1.0.0/packages/coding-agent/docs/sdk.md), [SDK examples](https://github.com/earendil-works/pi/tree/v1.0.0/packages/coding-agent/examples/sdk).
 
 **Breaking (Pi 0.80.8):** `ModelRuntime` replaced the old `AuthStorage`/`ModelRegistry` pair as the SDK model/auth facade. `CreateAgentSessionOptions.authStorage` and `modelRegistry` are gone — pass the async `modelRuntime` instead. `AuthStorage` is no longer exported; use `ModelRuntime` (or a custom pi-ai `CredentialStore`), or `readStoredCredential()` for one-off reads of `auth.json`. `ModelRegistry` still exists only as the synchronous extension-facing compatibility facade, and its `refresh()` is now `Promise<void>`.
 
@@ -44,23 +49,29 @@ import {
   createAgentSession,
   DefaultResourceLoader,
   defineTool,
+  getAgentDir,
   ModelRuntime,
   SessionManager,
 } from "@earendil-works/pi-coding-agent";
 import { getBuiltinModel } from "@earendil-works/pi-ai/providers/all";
 ```
 
+**Lightweight model construction (pi-ai 0.99.2):** `@earendil-works/pi-ai/models` builds model collections and providers without loading TypeBox, the built-in catalogs, or provider SDKs; use it in startup-sensitive code that brings its own models.
+
 **pi-ai 0.80.0 API move:** the old global API (`getModel`, `getModels`, `getProviders`, `stream`, `complete`, `completeSimple`, `registerApiProvider`, `getEnvApiKey`, ...) moved off the `@earendil-works/pi-ai` root entrypoint to `@earendil-works/pi-ai/compat` (a deprecated shim slated for removal). For built-in model lookup use `getBuiltinModel(provider, modelId)` from `@earendil-works/pi-ai/providers/all`, or the provider-factory API (`createModels()` / `Models.getModel()`). Extensions loaded by Pi are unaffected at runtime — the extension loader aliases the pi-ai root to the compat superset — but standalone SDK scripts and typechecked extension sources must use the new paths. The selective `@earendil-works/pi-ai/base` / `@earendil-works/pi-agent-core/base` entrypoints introduced in 0.79.8 were removed again in 0.80.0.
 
 ## Core Options
 
 ```typescript
 const cwd = "/path/to/project";
+const agentDir = getAgentDir();
 const modelRuntime = await ModelRuntime.create();
+const resourceLoader = new DefaultResourceLoader({ cwd, agentDir });
+await resourceLoader.reload();   // a loader you pass in is not reloaded for you
 
 const { session } = await createAgentSession({
   cwd,
-  agentDir: "~/.pi/agent",
+  agentDir,
   modelRuntime,
   model: getBuiltinModel("anthropic", "claude-opus-4-8"),
   thinkingLevel: "medium",  // off | minimal | low | medium | high | xhigh | max
@@ -69,7 +80,7 @@ const { session } = await createAgentSession({
   ],
   tools: ["read", "bash", "edit", "write"],
   customTools: [/* defineTool(...) entries */],
-  resourceLoader: new DefaultResourceLoader(),
+  resourceLoader,
   sessionManager: SessionManager.inMemory(),
 });
 ```
@@ -80,12 +91,61 @@ Notes:
 - Pi 0.68.0 changed the SDK `tools` option from `Tool[]` to a `string[]` allowlist of built-in, extension, and custom tool names. Use `noTools: "builtin"` to disable built-ins while keeping extension/custom tools enabled, or `noTools: "all"` for none.
 - `customTools` accepts `ToolDefinition[]`. Build them with `defineTool({...})` for full TypeScript inference.
 - The `create*Tool(cwd)` factories still exist for code that needs explicit `AgentTool` instances (e.g. when wiring tools into pi-agent-core directly), but they are no longer the value passed to `createAgentSession({ tools })`.
-- `DefaultResourceLoader` loads extensions, skills, prompt templates, themes, and context files. Replace it to drive resource discovery from custom sources (and it must implement `loadProjectContextFiles()` if you want `AGENTS.md`/`CLAUDE.md` discovery; that helper is also exported standalone).
+- `DefaultResourceLoader` requires `{ cwd, agentDir }` and loads extensions, skills, prompt templates, themes, and context files. Replace it to drive resource discovery from custom sources (and it must implement `loadProjectContextFiles()` if you want `AGENTS.md`/`CLAUDE.md` discovery; that helper is also exported standalone).
 - **Breaking (Pi 0.87.0):** pi-agent-core's `shouldStopAfterTurn` option was removed (it was never a `createAgentSession()` option). On a low-level `Agent`, set `finishTurn` instead: it runs after the assistant message and tool results are finalized but before `turn_end`, also for error/aborted responses. Return `{ action: "end" }` to stop, `{ action: "continue" }` to ensure one more request, or `undefined` for normal scheduling — guard hard exits first: `if (turn.message.stopReason === "error" || turn.message.stopReason === "aborted") return;`. Inside `createAgentSession()`, use an extension's actionable `turn_end` / `agent_before_settle` boundaries (see `references/extensions.md`).
 
+## Built-in Extensions: Codemode, Tool Search, MCP
+
+The CLI loads `codemode`, `tool_search`, MCP, and llama.cpp as built-in extensions. SDK sessions load none of them. Opt in through the resource loader (Pi 0.99.0, [example](https://github.com/earendil-works/pi/blob/v1.0.0/packages/coding-agent/examples/sdk/14-codemode-mcp.ts)):
+
+```typescript
+import {
+  createAgentSession,
+  createCodemodeExtension,
+  createMcpExtension,
+  createToolSearchExtension,
+  DefaultResourceLoader,
+  getAgentDir,
+  SessionManager,
+  SettingsManager,
+} from "@earendil-works/pi-coding-agent";
+
+const cwd = process.cwd();
+const resourceLoader = new DefaultResourceLoader({
+  cwd,
+  agentDir: getAgentDir(),
+  extensionFactories: [
+    createCodemodeExtension({ mode: "on" }),   // options override codemode.mode / inlineBudget
+    createToolSearchExtension(),
+    createMcpExtension(),                        // reads mcp.json like the CLI (project file only when trusted)
+  ],
+});
+await resourceLoader.reload();
+
+const settingsManager = SettingsManager.create(cwd);
+settingsManager.applyOverrides({ defaultTools: ["+codemode", "+tool_search"] });
+
+const { session } = await createAgentSession({
+  resourceLoader,
+  settingsManager,
+  sessionManager: SessionManager.inMemory(),
+});
+
+try {
+  await session.bindExtensions({});   // emits session_start; MCP connects here, in the background
+  await session.prompt("Use codemode to count the TypeScript files in src/.");
+} finally {
+  session.dispose();
+}
+```
+
+- `codemode` and `tool_search` are registered inactive. Enable them with `defaultTools` (`+name` keeps the other defaults), or let MCP activate them for servers that need them. Passing `tools: [...]` instead restricts the session to the named tools, which hides MCP tools.
+- Extension `session_start` handlers run only when the host calls `session.bindExtensions()`. Without it, MCP servers never connect.
+- Inline extensions can be named `{ name, factory, replaceable?: true, builtin?: true }`. `replaceable` drops the extension when another one registers the same tool, command, or flag name. `builtin` supplies the code for `builtin:<name>`: it loads by default, is listed in `pi config`, is disabled by `-builtin:<name>` or `noExtensions`, and loads after project trust (so it cannot handle `project_trust`).
+
 ## Models & Auth (`ModelRuntime`)
 
-`ModelRuntime` (Pi 0.80.8) implements the pi-ai `Models` interface and owns credential storage. Auth resolution priority: runtime overrides (`setRuntimeApiKey`, not persisted) → stored credentials in `auth.json` → environment variables → fallback resolver for `models.json` keys.
+`ModelRuntime` (Pi 0.80.8) implements the pi-ai `Models` interface and owns credential storage. Auth resolution priority: runtime overrides (`setRuntimeApiKey`, not persisted) → stored credentials in `auth.json` → `apiKey` from `models.json` or an extension registration → the provider's environment variables or ambient cloud credentials.
 
 ```typescript
 import { InMemoryCredentialStore } from "@earendil-works/pi-ai";
@@ -115,6 +175,8 @@ const inMemory = await ModelRuntime.create({ credentials: new InMemoryCredential
 
 Pi 0.84.x made catalog refresh cancellation-aware: `refresh(options?)` accepts `{ providers?, allowNetwork?, force?, signal? }` and returns a `ModelsRefreshResult` (`{ errors, aborted }`) instead of discarding provider errors; `create({ signal })`, `login()`, `logout()`, and the now-async `setRuntimeApiKey()/removeRuntimeApiKey()` accept optional abort signals too (unbounded when omitted — applications own deadline policy). Credential mutations resolve once local state is consistent, without waiting for remote freshness; if that synchronization fails they reject with the exported `CredentialSynchronizationError` (inspect `providerId`, `operation`, `credential`, `cause` rather than retrying blindly). A failed refresh never undoes a committed credential change, and each `refresh()` starts a fresh generation so stale refreshes cannot publish afterward.
 
+Non-chat models (Pi 0.99.0): `getModelsOfType(type, provider?)`, `getModelOfType(type, provider, id)`, `getAvailableOfType()`, `getAllModels()`, and `getAllAvailable()` cover `"chat"`, `"image"`, and `"classifier"` entries; `getModels()` stays chat-only. `modelRuntime.classify(model, context, options?)` and `modelRuntime.generateImages(model, context, options?)` resolve auth at request time and return error results (`stopReason: "error" | "aborted"`) instead of rejecting. `modelRuntime.registerVirtualModel(definition)` registers a routing model without an extension. See `references/providers.md#model-types`.
+
 To match CLI model parsing, use the exported resolver helpers (Pi 0.80.4):
 
 ```typescript
@@ -138,11 +200,11 @@ await session.prompt("Review the current directory");
 await session.prompt("Stop and do this instead", { streamingBehavior: "steer" });
 await session.prompt("After you finish, also check tests", { streamingBehavior: "followUp" });
 
-await session.steer("Use a smaller diff");
+const disposition = await session.steer("Use a smaller diff");   // "queued" | "handled"
 await session.followUp("Summarize the changes afterward");
 ```
 
-`prompt()` expands file-based prompt templates. During active streaming, calling it without `streamingBehavior` throws.
+`prompt()` expands file-based prompt templates and resolves after an accepted run finishes. During active streaming, calling it without `streamingBehavior` throws. Since Pi 0.99.0 `steer()` and `followUp()` return a disposition: `"queued"` (also after an extension transformed the input) or `"handled"` (an extension consumed it, so nothing was queued). Both throw for extension commands (`/name`); send those through `prompt()`, which runs them immediately, even while streaming. Read state through `session.messages`, `session.model`, `session.thinkingLevel`, `session.systemPrompt`, and `session.getActiveToolNames()`.
 
 ## Session Runtime
 
@@ -230,7 +292,7 @@ session.subscribe((event) => {
         process.stdout.write(event.assistantMessageEvent.delta);
       }
       break;
-    case "tool_execution_start":
+    case "tool_execution_start":   // nested calls (ctx.executeTool, codemode) carry parentToolCallId
     case "tool_execution_update":
     case "tool_execution_end":
     case "agent_start":
@@ -261,8 +323,9 @@ Pi 0.84.0 added transport-neutral remote-session client APIs: `@earendil-works/p
 
 ## RPC Mode
 
-`pi --mode rpc` speaks newline-delimited JSON over stdio. Additions since Pi 0.79:
+`pi --mode rpc` speaks newline-delimited JSON over stdio ([rpc.md](https://github.com/earendil-works/pi/blob/v1.0.0/packages/coding-agent/docs/rpc.md), [rpc-commands.md](https://github.com/earendil-works/pi/blob/v1.0.0/packages/coding-agent/docs/rpc-commands.md)). Additions since Pi 0.79:
 
+- Input dispositions (Pi 0.99.0): a successful `prompt` response carries `data.disposition` — `"started"` (a run started), `"queued"` (queued during a run), or `"handled"` (an extension command or input handler consumed it). `steer` and `follow_up` responses carry `"queued"` or `"handled"`. On `"handled"` no run started for that input: do not wait for `agent_settled`. Otherwise keep consuming events and wait for `agent_settled`, not `agent_end`. Failures after acceptance arrive as events, never as a second response. `RpcClient.prompt(message, images?, streamingBehavior?)`, `steer()`, and `followUp()` return the disposition.
 - `agent_settled` event (Pi 0.80.4) fires when a run is fully settled — no automatic retry, compaction retry, or queued continuation remains; `agent_end` now carries `willRetry`. `set_thinking_level` accepts `"max"` where the model supports it.
 - `clear_queue` (Pi 0.84.4) returns and removes queued steering and follow-up messages; direct RPC `steer`/`follow_up` commands pass through extension `input` handlers since Pi 0.86.0.
 - `get_entries` / `get_tree` (Pi 0.80.3) read session entries and tree snapshots over RPC; `get_available_thinking_levels` (Pi 0.81.0) lists the current model's supported thinking levels.
@@ -285,13 +348,18 @@ Pi 0.84.0 added transport-neutral remote-session client APIs: `@earendil-works/p
 To name an inline factory in the startup Extensions list (instead of `<inline:1>`), wrap it in an `InlineExtension` (Pi 0.80.4):
 
 ```typescript
-import type { InlineExtension } from "@earendil-works/pi-coding-agent";
+import { DefaultResourceLoader, getAgentDir, type InlineExtension } from "@earendil-works/pi-coding-agent";
 
 const myProvider: InlineExtension = {
   name: "my-provider",
   factory: (pi) => { /* ... */ },
 };
-const loader = new DefaultResourceLoader({ extensionFactories: [myProvider] });
+const loader = new DefaultResourceLoader({
+  cwd: process.cwd(),
+  agentDir: getAgentDir(),
+  extensionFactories: [myProvider],
+});
+await loader.reload();
 ```
 
 Bare factory functions are still accepted.

package/skills/pi/references/settings.md

@@ -38,7 +38,7 @@ Edit JSON directly or use `/settings` for common interactive options.
 
 ```json
 {
-  "theme": "dark",
+  "theme": "system",
   "quietStartup": false,
   "collapseChangelog": false,
   "doubleEscapeAction": "tree",
@@ -51,30 +51,33 @@ Edit JSON directly or use `/settings` for common interactive options.
 }
 ```
 
+- `quietStartup`: `true` hides the startup header and loaded-resource listing; `"header"` (Pi 1.0.0) keeps the header (version and key hints) but hides the model scope line and resource listing
 - `doubleEscapeAction`: `"tree"`, `"fork"`, or `"none"`
 - `treeFilterMode`: `"default"`, `"no-tools"`, `"user-only"`, `"labeled-only"`, or `"all"`
 - In `/tree`, `Shift+T` toggles timestamps on entry labels
-- `theme` also accepts `"light-name/dark-name"` (Pi 0.79.7) to switch themes automatically with the terminal color scheme; `/` is reserved in theme names for this. On first run Pi detects the terminal background and defaults to `dark` or `light`. `--use-theme <name[/name]>` (Pi 0.84.2) sets a per-run initial theme without changing saved settings.
+- `theme` defaults to `"system"` (Pi 0.99.0), which builds Pi's colors from the terminal's reported foreground, background, and ANSI palette and follows light/dark switches; `system` is a reserved theme name. `dark` and `light` are the other built-ins. `"light-name/dark-name"` (Pi 0.79.7) switches themes with the terminal color scheme; `/` is reserved in theme names for this. `--use-theme <name[/name]>` (Pi 0.84.2) sets a per-run initial theme without changing saved settings.
 - `outputPad` (Pi 0.80.3, `0` or `1`) sets horizontal padding for user messages, assistant messages, and thinking blocks; custom message renderers receive it as `options.outputPad` (Pi 0.82.1).
 - `externalEditor` (Pi 0.80.3) sets the `Ctrl+G` external editor command and takes precedence over `$VISUAL`/`$EDITOR`.
 
 ## Fullscreen TUI Mode
 
-Experimental since Pi 0.84.0:
+Fullscreen is the default since Pi 1.0.0 (added in 0.84.0):
 
 ```json
 {
-  "tuiMode": "regular",
+  "tuiMode": "fullscreen",
   "fullscreenExitOutput": "transcript",
   "fullscreenScrollbar": "auto",
-  "fullscreenCopyOnSelect": true
+  "fullscreenCopyOnSelect": true,
+  "fullscreenWheelScrollLines": "auto"
 }
 ```
 
-- `tuiMode`: `"regular"` (default) or `"fullscreen"`; `/settings` switches at runtime, `--tui-mode` overrides per run
+- `tuiMode`: `"fullscreen"` (default since Pi 1.0.0) or `"regular"` for the terminal's normal scrollback; `/settings` switches at runtime, `--tui-mode` overrides per run. Scripts that capture Pi's screen (VHS, tmux) see the fullscreen layout unless they set `regular`
 - `fullscreenExitOutput` (Pi 0.84.2): `"transcript"` prints the final transcript on exit; `"resume-hint"` restores the previous screen and prints only a resume hint
 - `fullscreenScrollbar`: `"auto"` shows while scrolling, `"always"` reserves the rightmost column, `"hidden"`
 - `fullscreenCopyOnSelect` (Pi 0.84.4, default `true`): when `false`, `Ctrl+X` copies the active selection (falling back to the last assistant message)
+- `fullscreenWheelScrollLines` (Pi 0.99.0): `"auto"` (default) or 1–100 lines per mouse-wheel event. `"auto"` moves one line per event in local macOS terminals and accelerates fast spins elsewhere (up to 6 lines); Alt+wheel moves five times as far
 - Fullscreen keeps editor/status/widgets/footer docked while the transcript scrolls independently; transcript search (`Ctrl+Shift+F`, Pi 0.84.2), page/half-page/line scrolling, and marked-message navigation are configurable via `tui.altScreen.*` keybindings
 - Theme tokens `scrollbarThumb`, `searchMatchBg`, `searchMatchText` are optional additions with fallbacks (`selectedBg`, `selectedBg`, `text`)
 
@@ -181,7 +184,6 @@ Notes:
 {
   "sessionDir": ".pi/sessions",
   "enabledModels": ["claude-*", "gpt-4o", "gemini-2*"],
-  "defaultTools": ["bash", "read", "edit"],
   "markdown": {
     "codeBlockIndent": "  ",
     "mermaid": "streaming"
@@ -191,12 +193,26 @@ Notes:
 
 When multiple sources specify a session directory, `--session-dir` takes precedence over `sessionDir` in settings. Pi 0.65.0 removed the old `session_directory` extension/settings hook.
 
-- `defaultTools` (Pi 0.84.2) picks the built-in tools enabled at startup (default `read`, `bash`, `edit`, `write`; also available: `grep`, `find`, `ls`, and `powershell` on Windows since Pi 0.84.3) (global or per project; project replaces global). An empty array starts with no built-in tools while keeping extension/SDK custom tools. `--tools` remains a strict allowlist for all tools, `--exclude-tools` filters the resulting list.
 - `markdown.mermaid` (Pi 0.84.0): `"off"`, `"final"`, or `"streaming"` — themed Unicode rendering of supported Mermaid diagrams in interactive messages. Pi 0.84.0 also renders terminal-friendly Unicode for LaTeX expressions.
 
+## Tools & Codemode
+
+```json
+{
+  "defaultTools": ["+codemode"],
+  "codemode": { "mode": "on", "inlineBudget": 3000 }
+}
+```
+
+- `defaultTools` picks the tools enabled at startup (default `read`, `bash`, `edit`, `write`; also `grep`, `find`, `ls`, `powershell`, and the built-in extension tools `codemode` and `tool_search`). Plain names replace the defaults. A list of only `+name`/`-name` entries (Pi 0.99.0) changes the inherited selection instead; in a mixed list the plain names form the selection and `+`/`-` apply in order. A project list of only `+`/`-` entries applies on top of the user setting; a project list with a plain name replaces it. An empty array disables built-in tools but keeps extension/SDK tools.
+- `--tools` replaces the whole selection for one run and does not accept `+`/`-`; `--exclude-tools` filters the result.
+- `/reload` (Pi 0.99.2) enables tools newly added to `defaultTools`. It does not disable tools removed from it or re-enable unchanged tools turned off in the session; `--tools`, `--no-tools`, and `--no-builtin-tools` still win on reload.
+- `codemode.mode`: `"on"` (default) keeps declared tools declared; `"only"` hides active built-in and extension tools from the model so it reaches them through `codemode`. `codemode.inlineBudget` (default `3000`, estimated tokens) caps tool declarations in the `codemode` description. See `references/codemode.md`.
+- MCP servers are configured in `~/.pi/agent/mcp.json` and the trust-gated `.pi/mcp.json`, not in `settings.json`. See `references/mcp.md`.
+
 ## Project Trust
 
-Since Pi 0.79.0, project-local settings, resources, and packages (`.pi/` settings/extensions/skills/prompts/themes, project packages) only load after the project is trusted. `AGENTS.md` / `CLAUDE.md` context files load regardless of trust. Trust is a loading gate, not a sandbox.
+Since Pi 0.79.0, project-local settings, resources, and packages (`.pi/` settings/extensions/skills/prompts/themes/`mcp.json`, project packages) only load after the project is trusted. `AGENTS.md` / `CLAUDE.md` context files load regardless of trust. Trust is a loading gate, not a sandbox.
 
 ```json
 {
@@ -238,6 +254,7 @@ Notes:
 - `packages` loads npm/git/local Pi packages.
 - `extensions`, `skills`, `prompts`, and `themes` are for local files/directories.
 - `enableSkillCommands` controls `/skill:name` registration.
+- Built-in extensions (Pi 0.99.0) are `builtin:mcp`, `builtin:llama.cpp`, `builtin:codemode`, and `builtin:tool-search`. They load by default; `"extensions": ["-builtin:mcp"]` disables one, and a project `+builtin:<name>`/`-builtin:<name>` entry overrides the user setting. `pi config` lists them under Built-in.
 
 ## Include / Exclude Patterns
 
@@ -266,6 +283,7 @@ Run `pi --help` for the authoritative list. Most commonly:
 pi [options] [@files...] [messages...]
 
 # package commands: install/remove/uninstall/update/list/config (all support -l for project scope)
+# MCP commands: pi mcp add|remove|list|login|logout (see references/mcp.md)
 
 # modes
 -p, --print                      single-shot text output
@@ -273,7 +291,7 @@ pi [options] [@files...] [messages...]
 --export <in> [out]              export a session to HTML
 
 # model
---provider <name>                e.g. anthropic, openai, google
+--provider <name>                e.g. anthropic, openai, google; needs --model (Pi 1.0.0)
 --model <pattern>                supports provider/id and optional :<thinking>
 --api-key <key>
 --thinking off|minimal|low|medium|high|xhigh|max
@@ -291,15 +309,16 @@ pi [options] [@files...] [messages...]
 --no-session                     ephemeral
 
 # tools and resources
---tools <list>, -t               name allowlist (read,bash,edit,write,grep,find,ls,...)
+--tools <list>, -t               name allowlist (read,bash,edit,write,grep,find,ls,codemode,...)
 --exclude-tools <list>, -xt      disable specific built-in/extension/custom tools, keep the rest
 --no-tools, -nt                  disable everything
 --no-builtin-tools, -nbt         disable built-ins, keep extension/custom
--e, --extension <source>         repeatable; npm/git/path
+-e, --extension <source>         repeatable; npm/git/path, or builtin:<name>
 --skill <path>                   repeatable
 --prompt-template <path>         repeatable
 --theme <path>                   repeatable
---no-extensions / --no-skills / --no-prompt-templates / --no-themes
+--no-extensions, -ne             also disables built-in extensions (pi -ne -e builtin:mcp keeps only MCP)
+--no-skills / --no-prompt-templates / --no-themes
 --no-context-files, -nc          skip AGENTS.md / CLAUDE.md discovery
 
 # trust and network
@@ -308,9 +327,9 @@ pi [options] [@files...] [messages...]
 --offline                        disable startup network operations (same as PI_OFFLINE=1)
 
 # prompts and misc
---system-prompt <text>           replace default
---append-system-prompt <text>    repeatable; appended with double newlines
---tui-mode regular|fullscreen    experimental fullscreen TUI (Pi 0.84.0)
+--system-prompt <text|path>      replace default
+--append-system-prompt <text|path>  repeatable; appended with double newlines
+--tui-mode regular|fullscreen    fullscreen is the default (Pi 1.0.0)
 --use-theme <name[/name]>        per-run initial theme, saved settings untouched (Pi 0.84.2)
 --verbose
 ```