Skip to content
Back to search

pi-interactive-shell

Pi coding agent extension that allows Pi to autonomously control interactive CLIs in an observable overlay. Full PTY emulation, no tmux, token efficient. User can take over anytime.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/nicobailon--pi-interactive-shell/badge.svg)](/listings/nicobailon--pi-interactive-shell)

HTML

<a href="/listings/nicobailon--pi-interactive-shell"><img src="/api/listings/nicobailon--pi-interactive-shell/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

pi install npm:pi-interactive-shell

The `interactive-shell` skill is automatically symlinked to `~/.pi/agent/skills/interactive-shell/`.

**Requires:** Node.js. PTY support uses `zigpty` prebuilt binaries (no `node-gyp` toolchain required on supported platforms).

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 852 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <p>
  2. <img src="banner.png" alt="pi-interactive-shell" width="1100">
  3. </p>
  4. # Pi Interactive Shell
  5. An extension for [Pi coding agent](https://github.com/badlogic/pi-mono/) that lets Pi autonomously run interactive CLIs in an observable TUI overlay. Pi controls the subprocess while you watch - take over anytime.
  6. https://github.com/user-attachments/assets/76f56ecd-fc12-4d92-a01e-e6ae9ba65ff4
  7. ```typescript
  8. interactive_shell({ command: 'vim config.yaml' })
  9. ```
  10. Important: the `interactive_shell({...})` snippets in this README are tool calls made by Pi (or extension/prompt authors). End users do not type these directly into chat. As a user, ask Pi to run something (for example: "run this in dispatch mode") or use `/spawn`, `/attach`, and `/dismiss` commands.
  11. ## Why
  12. Some tasks need interactive CLIs - editors, REPLs, database shells, long-running processes. Pi can launch them in an overlay where:
  13. - **User watches** - See exactly what's happening in real-time
  14. - **User takes over** - Type anything to gain control
  15. - **Agent monitors** - Query status, send input, decide when done
  16. Works with any CLI: `vim`, `htop`, `psql`, `ssh`, `docker logs -f`, `npm run dev`, `git rebase -i`, etc.
  17. ## Install
  18. ```bash
  19. pi install npm:pi-interactive-shell
  20. ```
  21. The package ships an `interactive-shell` skill that teaches agents when and how to use each mode. If you load the extension from a local folder instead of a package, link `skills/interactive-shell` into `~/.pi/agent/skills/` yourself.
  22. **Requires:** Node.js. PTY support uses `zigpty` prebuilt binaries (no `node-gyp` toolchain required on supported platforms).
  23. ## Modes
  24. | Mode | Agent waits? | How output reaches agent | Best for |
  25. |---|---|---|---|
  26. | **Interactive** (default) | No | Stable `sessionId` for input/status | Editors, REPLs, SSH — when the agent or user will drive the shell |
  27. | **Hands-free** | No | Poll with `sessionId` plus quiet updates | Dev servers, builds — when you want to watch progress and send follow-up commands |
  28. | **Dispatch** | No | Notification on completion via `triggerTurn` | Delegating tasks to subagents — fire and forget |
  29. | **Monitor** | No | Notification on structured monitor trigger events | Watchers, logs, tests, and state checks — wake only when something specific happens |
  30. **Interactive** — The overlay opens and returns a stable `sessionId` immediately. The user can type directly, and the agent can send `input` with `submit: true`, check status, or background the same id. Use for editors (`vim`), database shells (`psql`), SSH, or manual CLI flows where the next step is still interactive.
  31. **Hands-free** — The overlay opens and returns a stable `sessionId` immediately. The agent polls periodically with `sessionId` and also receives quiet/output updates. Good for long-running builds or dev servers where you want to react mid-flight (send input, check logs, or locally cancel supervision when ready).
  32. **Dispatch** — Returns immediately. No polling. The agent gets woken up via `triggerTurn` only when the session completes or local supervision ends (natural exit, timeout, quiet detection, or user cancellation). The notification includes a captured tail of the output. This is the default for delegating work to subagents. Add `background: true` to skip the overlay entirely.
  33. **Monitor** — Returns immediately. The agent gets woken up when a configured monitor trigger emits an event, and when the monitor lifecycle stops. Supports stream triggers, poll-diff checks, first-class file watching, optional cooldowns, persistence controls, detector commands, and event history queries. Runs headless; attach to inspect if needed.
  34. ## Quick Start
  35. The examples below show agent-side tool calls. They are not chat commands for end users.
  36. ### Structured Spawn
  37. For Pi, Codex, Claude, and Cursor, the agent can use structured spawn params instead of building command strings by hand:
  38. ```typescript
  39. // User says: "Spawn pi so I can edit files interactively"
  40. interactive_shell({ spawn: { agent: "pi" }, mode: "interactive" })
  41. // User says: "Delegate this refactor to codex and notify me when it's done"
  42. interactive_shell({ spawn: { agent: "codex" }, mode: "dispatch" })
  43. // User says: "Ask cursor to review the diffs in dispatch mode"
  44. interactive_shell({ spawn: { agent: "cursor", prompt: "Review the diffs" }, mode: "dispatch" })
  45. // User says: "Ask claude to review the diffs in dispatch mode"
  46. interactive_shell({ spawn: { agent: "claude", prompt: "Review the diffs" }, mode: "dispatch" })
  47. // User says: "Start claude in a worktree for hands-free monitoring"
  48. interactive_shell({ spawn: { agent: "claude", worktree: true }, mode: "hands-free" })
  49. // User says: "Fork my current pi session" (Pi-only)
  50. interactive_shell({ spawn: { mode: "fork" }, mode: "interactive" })
  51. ```
  52. Structured `spawn` uses the same resolver and config defaults as the user-facing `/spawn` command. Raw `command` is still supported for arbitrary CLIs and custom launch strings. For unattended coding-agent work in a repository, prefer structured `spawn` with `worktree: true` or set an explicitly isolated `cwd`; a raw agent command runs in the supplied working directory and can change its Git state.
  53. Any extra key you add under `spawn.commands` becomes a first-class spawn agent, usable as `spawn: { agent: "aider" }` and `/spawn aider`, with its own `spawn.defaultArgs` entry, worktree support, and prompt passthrough. `fork` stays Pi-only. Agent names must start with a letter or digit, may contain letters, digits, `.`, `_`, and `-`, and cannot be `fresh` or `fork`, because those are `/spawn` keywords.
  54. For Codex image or design work, Codex can invoke `gpt-image-2` directly from the prompt. Natural language is usually enough, and `$imagegen` forces the image-generation tool when you need it. Attach references with `-i` for edits and iterations. See the bundled `codex-cli` skill for concrete examples. For Cursor CLI-specific command references, see the optional `examples/skills/cursor-cli` skill. Cursor structured spawn defaults to `--model composer-2-fast`, which explicitly selects Cursor's Composer 2 Fast model.
  55. ### Interactive
  56. ```typescript
  57. // User says: "Open package.json in vim"
  58. interactive_shell({ command: 'vim package.json' })
  59. // User says: "Connect to the postgres database"
  60. interactive_shell({ command: 'psql -d mydb' })
  61. // User says: "SSH into the server"
  62. interactive_shell({ command: 'ssh user@server' })
  63. ```
  64. The tool returns a stable `sessionId` immediately. The agent can drive the same shell with `interactive_shell({ sessionId, input, submit: true })`, while the user can still type directly in the focused overlay.
  65. ### Hands-Free
  66. ```typescript
  67. // Start a long-running process
  68. interactive_shell({
  69. command: 'npm run dev',
  70. mode: "hands-free",
  71. reason: "Dev server"
  72. })
  73. // → { sessionId: "calm-reef", status: "running" }
  74. // User says: "Check on the dev server status"
  75. interactive_shell({ sessionId: "calm-reef" })
  76. // → { status: "running", output: "Server ready on :3000", runtime: 45000 }
  77. // Send input when needed
  78. interactive_shell({ sessionId: "calm-reef", input: "/run review", submit: true })
  79. interactive_shell({ sessionId: "calm-reef", inputKeys: ["ctrl+c"] })
  80. // Cancel local supervision when done (termination is best-effort)
  81. interactive_shell({ sessionId: "calm-reef", kill: true })
  82. // → { status: "killed", output: "..." } // locally cancelled; subprocess exit is not confirmed
  83. ```
  84. The overlay opens for the user to watch. The agent checks in periodically. User can type anything to take over control. After taking over a monitored hands-free or dispatch session, press `Ctrl+G` to return control to the agent.
  85. ### Dispatch
  86. ```typescript
  87. // User says: "Delegate refactoring the auth module to pi and notify me when done"
  88. interactive_shell({
  89. command: 'pi "Refactor the auth module"',
  90. mode: "dispatch",
  91. reason: "Auth refactor"
  92. })
  93. // → Returns immediately: { sessionId: "calm-reef" }
  94. // → Agent ends turn or does other work.
  95. ```
  96. When the session completes, the agent receives a compact notification on a new turn:
  97. ```
  98. Session calm-reef completed successfully (5m 23s). 847 lines of output.
  99. Step 9 of 10
  100. Step 10 of 10
  101. All tasks completed.
  102. Full output: ~/.pi/agent/cache/interactive-shell/session-calm-reef-<time>.log
  103. ```
  104. The notification includes a brief tail (last 5 lines) and the path to the session's full terminal output, saved when a headless dispatch or monitor finishes. Saved logs older than 24 hours are deleted when the next one is written. A later query by `sessionId` points to the same file.
  105. Dispatch defaults `autoExitOnQuiet: true` — the session gets a 15s startup grace period, then auto-closes after output goes silent (8s by default). The completion notification and details set `completionReason: "auto-close-quiet"`; this is not a terminal command verdict. Tune the grace period with `handsFree: { gracePeriod: 60000 }` or opt out entirely with `handsFree: { autoExitOnQuiet: false }`.
  106. ### Recoverable selected output (explicit opt-in)
  107. Recoverable selection is deliberately narrow: it supports only a raw `command` launched as a headless `mode: "dispatch"` session with `background: true`. It does not filter live TUI output, coding-agent/spawn sessions, auth flows, monitor or hands-free sessions, completion notifications, or ordinary output queries. It does not authorize commands or terminal input, and it does not generate a summary.
  108. ```typescript
  109. const launch = await interactive_shell({
  110. command: "npm test -- --runInBand",
  111. mode: "dispatch",
  112. background: true,
  113. outputSelection: {
  114. enabled: true,
  115. goal: "retain failing test details, totals, and report paths"
  116. }
  117. })
  118. // launch.details.outputSource = {
  119. // sourceId: "<stable source id>",
  120. // representation: "normalized-merged-pty-text-v1",
  121. // available: true
  122. // }
  123. interactive_shell({ sourceId: launch.details.outputSource.sourceId, outputView: "selected" })
  124. interactive_shell({ sourceId: launch.details.outputSource.sourceId, outputView: "status" })
  125. interactive_shell({
  126. sourceId: launch.details.outputSource.sourceId,
  127. outputView: "raw",
  128. sourceOffset: 0,
  129. sourceLimit: 5120
  130. })
  131. ```
  132. Capture starts only from the per-launch `outputSelection` consent above. Capture, `status`, and local-only `raw` reads do not call Jev. An eligible completed-log block reaches TypeSafe only when an agent explicitly queries `outputView: "selected"` and the other two consent gates are also open: the user's **global** config has `jev.enabled: true`, and `TYPESAFE_API_KEY` was inherited by the Pi process. Project config, a credential by itself, and `monitor.semantic` cannot enable selected-output transmission. Never put the credential in a tool call, config example, or project file.
  133. Selected queries return `selected`, `unchanged`, `unavailable`, or `pagination-required`. Semantic omission ranges identify blocks omitted after evaluation; physical recovery ranges identify retained evidence that does not fit the selected display budget. In every case, use `outputView: "raw"` with the stable source ID to recover the local source. Short, exact/exhaustive, JSON/XML/YAML/diff, binary/control-heavy, interactive/auth, secret-like, or incomplete sources conservatively bypass transmission. Disabled configuration, a missing credential, provider/parse/timeout/abort failure, or request-cap exhaustion never authorizes omission: the response is unavailable with the bounded ordinary completion fallback and raw recovery metadata.
  134. The raw source representation, `normalized-merged-pty-text-v1`, is the exact merged PTY JavaScript text received after terminal device-query removal. It preserves ANSI and carriage returns and uses half-open UTF-16 ranges; it is not original bytes and does not separate stdout from stderr. Provider/model and selected display text use `safe-normalized-terminal-text-v1`: controls are removed and carriage returns apply narrow same-line overwrite semantics, while every excerpt retains its exact raw range.
  135. Fixed safety/retention bounds are not configuration knobs: 8 MiB per complete source, 64 MiB process-local aggregate storage, one-hour completed-source recovery, and at most 51,200 UTF-16 characters per raw read. Selection has a 5,120-visible-character budget, uses `jev-1.13.0`, and permits at most eight logical/sixteen possible physical attempts, 10 seconds per call, and one 90-second outer deadline. Canonical UTF-8 preflight stays strictly below 24 KiB for state plus a full single question and below 48 KiB for state plus all questions, conservative headroom under the provider's official 32K/64K token limits. Returned token usage is audit evidence only; this integration does not expose an authoritative price.
  136. Selection requires process-retained launch consent/goal metadata. After a Pi process restart, selected view is explicitly unavailable, but raw recovery by `sourceId` remains available until expiry. The frozen calibration corpus (`747b075e4ad3d49411a12c3775d5316e7ad32bdd3e3ef231670b750facd37a45`) is kept as a reproducible regression: three accepted frozen live runs each scored held-out 15/15 versus deterministic 14/15 and tail 11/15; all 18/18 requests succeeded with no failure/retry statuses, p50 216.5 ms/p95 309 ms, and 17,993 input plus 2,660 output tokens per run. Cost was unavailable. This bounded corpus evidence does not establish universal accuracy or generalization.
  137. For an external gate, use this provider-agnostic watch-until-terminal pattern. The watcher must print one of the terminal lines and exit only after it has a verdict:
  138. ```typescript
  139. interactive_shell({
  140. command: "your-watch-command",
  141. mode: "monitor",
  142. handsFree: { autoExitOnQuiet: false },
  143. timeout: 20 * 60_000,
  144. monitor: {
  145. strategy: "stream",
  146. triggers: [
  147. { id: "ready", literal: "ready" },
  148. { id: "blocked", literal: "blocked" },
  149. { id: "stale-head", literal: "stale-head" }
  150. ]
  151. }
  152. })
  153. ```
  154. This works with CI, deploy, health, and custom CLI watchers. If raw dispatch is required, disable quiet auto-close and treat `completionReason: "auto-close-quiet"` as non-terminal.
  155. The overlay still shows for the user, who can Ctrl+T to transfer output, Ctrl+B to background, take over by typing, or Ctrl+Q for more options. `Ctrl+G` only becomes meaningful after the user has taken over a monitored hands-free or dispatch session.
  156. ### Background Dispatch (Headless)
  157. ```typescript
  158. // No overlay — runs completely invisibly
  159. interactive_shell({
  160. command: 'pi "Fix all lint errors"',
  161. mode: "dispatch",
  162. background: true
  163. })
  164. // → { sessionId: "calm-reef" }
  165. // → User can /attach calm-reef to peek
  166. // → Agent notified on completion, same as regular dispatch
  167. ```
  168. Multiple headless dispatches can run concurrently alongside a single interactive overlay. This is how you parallelize subagent work — fire off three background dispatches and process results as each completion notification arrives.
  169. ### Monitor (Event-Driven)
  170. These examples are **agent tool calls**. End users should ask in natural language (for example: "watch my tests and alert me on failures"), and Pi should invoke `interactive_shell` with the monitor config.
  171. Wake the agent when monitor triggers emit events — no polling and no waiting for process completion.
  172. ```typescript
  173. // User says: "Watch my tests and alert me on failures or errors"
  174. interactive_shell({
  175. command: 'npm test --watch',
  176. mode: "monitor",
  177. monitor: {
  178. strategy: "stream",
  179. triggers: [
  180. { id: "failed", literal: "FAIL" },
  181. { id: "error", regex: "/error|exception/i" }
  182. ],
  183. throttle: { dedupeExactLine: true },
  184. persistence: { stopAfterFirstEvent: false }
  185. }
  186. })
  187. // User says: "Monitor the health endpoint and tell me when it changes"
  188. interactive_shell({
  189. command: 'curl -sf http://localhost:3000/health',
  190. mode: "monitor",
  191. monitor: {
  192. strategy: "poll-diff",
  193. triggers: [{ id: "changed", regex: "/./" }],
  194. poll: { intervalMs: 5000 }
  195. }
  196. })
  197. // User says: "Alert me when NVDA drops below $120"
  198. interactive_shell({
  199. command: 'curl -s https://api.example.com/quote/NVDA',
  200. mode: "monitor",
  201. monitor: {
  202. strategy: "stream",
  203. triggers: [
  204. {
  205. id: "nvda-below-120",
  206. regex: "/NVDA:\\s*\\$?(\\d+(?:\\.\\d+)?)/",
  207. threshold: { captureGroup: 1, op: "lt", value: 120 }
  208. }
  209. ]
  210. }
  211. })
  212. // User says: "Watch the uploads folder for new PDF files and notify me"
  213. interactive_shell({
  214. mode: "monitor",
  215. monitor: {
  216. strategy: "file-watch",
  217. fileWatch: { path: "./uploads", recursive: true, events: ["rename", "change"] },
  218. triggers: [{ id: "pdf", regex: "/\\.pdf$/i" }]
  219. }
  220. })
  221. ```
  222. `file-watch` generates and authorizes its own watcher command. Do not combine it with top-level `command` or `spawn`; mixed requests are rejected before spawn resolution or worktree creation.
  223. Monitor mode emits structured payloads (`sessionId`, `eventId`, `timestamp`, `strategy`, `triggerId`, `matchedText`, `lineOrDiff`, `stream`) and now also emits lifecycle notifications when a monitor stops (stream ended, script failed, stopped, or timed out). `monitorFilter` was removed in favor of the structured `monitor` object.
  224. ```typescript
  225. interactive_shell({ monitorStatus: true, monitorSessionId: "calm-reef" })
  226. interactive_shell({ monitorEvents: true, monitorSessionId: "calm-reef" })
  227. interactive_shell({ monitorEvents: true, monitorSessionId: "calm-reef", monitorSinceEventId: 42 })
  228. interactive_shell({ monitorEvents: true, monitorSessionId: "calm-reef", monitorTriggerId: "error" })
  229. interactive_shell({ monitorEvents: true, monitorSessionId: "calm-reef", monitorEventLimit: 50, monitorEventOffset: 20 })
  230. ```
  231. Monitor sessions run headless and can be managed like other background sessions (`listBackground`, `/attach`, `dismissBackground`).
  232. ### Timeout
  233. Capture output from TUI apps that don't exit cleanly:
  234. ```typescript
  235. interactive_shell({
  236. command: "htop",
  237. mode: "hands-free",
  238. timeout: 3000 // Cancel after 3s, attempt termination, return captured output
  239. })
  240. ```
  241. ## Features
  242. ### Auto-Exit on Quiet
  243. For fire-and-forget single-task delegations, enable auto-exit to cancel local supervision after 8s of output silence and attempt termination:
  244. ```typescript
  245. interactive_shell({
  246. command: 'pi "Fix the bug in auth.ts"',
  247. mode: "hands-free",
  248. handsFree: { autoExitOnQuiet: true }
  249. })
  250. ```
  251. A 15s startup grace period prevents local cancellation before the subprocess has time to produce output. Customize it per-call with `gracePeriod`:
  252. ```typescript
  253. interactive_shell({
  254. command: 'pi "Run the full test suite"',
  255. mode: "hands-free",
  256. handsFree: { autoExitOnQuiet: true, gracePeriod: 60000 }
  257. })
  258. ```
  259. The default grace period is also configurable globally via `autoExitGracePeriod` in the config file.
  260. For multi-turn sessions where you need back-and-forth interaction, leave it disabled (default) and use `kill: true` to cancel local supervision when done.
  261. ### Send Input
  262. ```typescript
  263. // Text only (types text but does not submit)
  264. interactive_shell({ sessionId: "calm-reef", input: "SELECT * FROM users;" })
  265. // Type text and press Enter
  266. interactive_shell({ sessionId: "calm-reef", input: "SELECT * FROM users;", submit: true })
  267. // Named keys
  268. interactive_shell({ sessionId: "calm-reef", inputKeys: ["ctrl+c"] })
  269. interactive_shell({ sessionId: "calm-reef", inputKeys: ["down", "down", "enter"] })
  270. // Bracketed paste (multiline without execution)
  271. interactive_shell({ sessionId: "calm-reef", inputPaste: "line1\nline2\nline3" })
  272. // Hex bytes (raw escape sequences)
  273. interactive_shell({ sessionId: "calm-reef", inputHex: ["0x1b", "0x5b", "0x41"] })
  274. // Combine text with keys
  275. interactive_shell({ sessionId: "calm-reef", input: "y", inputKeys: ["enter"] })
  276. ```
  277. For editor-based TUIs like pi, raw `input` only types text. It does not submit the prompt. Prefer `submit: true` or `inputKeys: ["enter"]` instead of relying on `\n`.
  278. ### Configurable Output
  279. ```typescript
  280. // Default: 20 lines, 5KB
  281. interactive_shell({ sessionId: "calm-reef" })
  282. // More lines (max: 200)
  283. interactive_shell({ sessionId: "calm-reef", outputLines: 100 })
  284. // Incremental pagination (server tracks position)
  285. interactive_shell({ sessionId: "calm-reef", outputLines: 50, incremental: true })
  286. // Drain mode (raw stream since last query)
  287. interactive_shell({ sessionId: "calm-reef", drain: true })
  288. ```
  289. ### Transfer Output to Agent
  290. When a subagent finishes work, press **Ctrl+T** to capture its output and send it directly to the main agent:
  291. ```
  292. [Subagent finishes work]
  293. ↓
  294. [Press Ctrl+T]
  295. ↓
  296. [Overlay closes, main agent receives full output]
  297. ```
  298. The main agent then has the subagent's response in context and can continue working with that information.
  299. **Configuration:**
  300. - `transferLines`: Max lines to capture (default: 200)
  301. - `transferMaxChars`: Max characters (default: 20KB)
  302. ### Background Sessions
  303. Sessions can be backgrounded by the user (Ctrl+B, or Ctrl+Q → "Run in background") or by the agent:
  304. ```typescript
  305. // Agent backgrounds an active session
  306. interactive_shell({ sessionId: "calm-reef", background: true })
  307. // → Overlay closes, process keeps running
  308. // List background sessions
  309. interactive_shell({ listBackground: true })
  310. // Reattach with a specific mode
  311. interactive_shell({ attach: "calm-reef" }) // interactive (blocking)
  312. interactive_shell({ attach: "calm-reef", mode: "hands-free" }) // hands-free (poll)
  313. interactive_shell({ attach: "calm-reef", mode: "dispatch" }) // dispatch (notified)
  314. // Dismiss background sessions
  315. interactive_shell({ dismissBackground: true }) // all sessions
  316. interactive_shell({ dismissBackground: "calm-reef" }) // specific session
  317. ```
  318. Monitor sessions work the same way — they're headless background sessions that wake you on monitor events instead of completion.
  319. The background-session list below the editor shows only running sessions, uses at most 20% of the terminal height (up to six rows), and collapses overflow into a summary. Completed sessions disappear from the widget immediately but remain temporarily queryable. Use `/attach` to view the retained full list.
  320. Running background sessions and monitors survive `/reload` and reappear under the new extension instance. Quitting Pi or switching sessions still terminates them.
  321. User can also `/spawn` to launch the configured default spawn agent, `/spawn codex`, `/spawn cursor`, `/spawn claude`, `/spawn pi`, `/spawn fork`, `/spawn pi fork`, or `/spawn <custom-agent>` for any agent added to `spawn.commands`. Add `--worktree` to spawn in a separate git worktree, for example `/spawn cursor --worktree`, `/spawn codex --worktree`, or `/spawn pi fork --worktree`. Plain `/spawn cursor` stays a normal interactive overlay. `fork` is Pi-only. Worktrees are left in place and the overlay will tell you where they were created. `/attach` or `/attach <id>` reattaches, and `/dismiss` or `/dismiss <id>` cleans up from the chat. The keyboard spawn shortcut is separate from `/spawn` and uses `spawn.shortcut`.
  322. ### Prompt-Bearing `/spawn`
  323. Quoted prompt text plus `--hands-free` or `--dispatch` turns `/spawn` into a monitored delegated run instead of a plain interactive overlay. This shares the same resolver and defaults as structured `interactive_shell({ spawn: ... })`. Plain `/spawn` stays interactive. `Ctrl+G` only applies after you take over one of these monitored sessions.
  324. ```bash
  325. /spawn cursor "review the diffs" --dispatch
  326. /spawn claude "review the diffs" --dispatch
  327. /spawn codex "fix the failing tests" --hands-free
  328. /spawn pi fork "continue from here" --dispatch
  329. ```
  330. ## Keys
  331. | Key | Action |
  332. |-----|--------|
  333. | Ctrl+T | **Transfer & close** - capture output and send to main agent |
  334. | Ctrl+B | Background session (dismiss overlay, keep running) |
  335. | Ctrl+Q | Session menu (transfer/background/kill/cancel) |
  336. | Shift+Up/Down | Scroll history |
  337. | Alt+Shift+F (default) | Toggle focus between overlay and main chat (`focusShortcut`) |
  338. | Ctrl+G | Return to agent monitoring (only after taking over a monitored hands-free or dispatch session) |
  339. | Alt+Shift+P (default) | Launch the configured default spawn agent (`spawn.shortcut`) |
  340. | Any key (hands-free) | Take over control |
  341. ## Deferred tool loading
  342. `interactive_shell` is active by default. Set `"defer": true` to keep its tool definition out of the initial model request:
  343. ```json
  344. {
  345. "defer": true
  346. }
  347. ```
  348. Pi then exposes the small `enable_interactive_shell` loader. When a task needs the shell, the agent calls the loader and `interactive_shell` becomes available on the next model turn. `/spawn`, `/attach`, `/dismiss`, and the keyboard shortcuts continue to work directly.
  349. Each reloaded, new, resumed, or forked session starts with `interactive_shell` inactive again. Pi versions without the active-tool API print a warning and keep the tool active. A CLI `--tools` allowlist must include both `enable_interactive_shell` and `interactive_shell`; deferred activation cannot override an allowlist that excludes the target tool.
  350. Deferred mode omits `interactive_shell`'s `promptSnippet`; the same operating guidance remains in the tool description. This keeps the system-prompt prefix stable when Pi uses native deferred loading.
  351. ### Tool schema size
  352. The tool definition is sent with every model request. By default it lists only the fields agents use day to day (running and querying sessions, input, dispatch, hands-free, stream monitors, spawn, attach, kill), which cuts it from 18,644 to about 4,700 characters (about 4,660 to 1,170 tokens). Advanced fields (Jev supervision, saved output sources, monitor history, raw hex input, handoff snapshots) are not listed but still work exactly as before: every call is checked against the full schema when the tool runs. Set `"toolSchema": "full"` to send the complete definition instead.
  353. ## Optional Jev semantic supervision
  354. Jev integration is optional and off by default. Terminal data reaches TypeSafe AI only when all three gates are open: the user enables `jev.enabled` in the **global** config, `TYPESAFE_API_KEY` exists in Pi's process environment, and a tool call explicitly supplies `monitor.semantic`. Put the environment variable in the shell that starts Pi or inject it with your secret manager; it is never a tool argument or an `interactive-shell.json` field. A project config cannot enable Jev or switch its model.
  355. Example global opt-in (the default is `false`):
  356. ```json
  357. {
  358. "jev": {
  359. "enabled": true,
  360. "model": "jev-1.13.0",
  361. "requestTimeoutMs": 10000,
  362. "maxRetries": 1,
  363. "maxViewportLines": 40,
  364. "maxRecentChars": 4000,
  365. "redactionPatterns": [],
  366. "diagnostics": { "enabled": false, "retentionDays": 14, "maxBytes": 20000000 }
  367. }
  368. }
  369. ```
  370. | Jev field | Default | Implemented bounds/ownership |
  371. |---|---:|---|
  372. | `enabled` | `false` | Global config only |
  373. | `model` | `jev-1.13.0` | Nonempty global value only; project model is ignored |
  374. | `requestTimeoutMs` | `10000` | 1,000–30,000; project may only lower the global value |
  375. | `maxRetries` | `1` | 0–2; project may only lower the global value |
  376. | `maxViewportLines` | `40` | 5–80; project may only lower the global value |
  377. | `maxRecentChars` | `4000` | 500–8,000; project may only lower the global value |
  378. | `redactionPatterns` | `[]` | Up to 50 global-first, project-added RE2-compatible patterns; each source is 1–512 characters |
  379. | `diagnostics.enabled` | `false` | Global config only; records local structured metadata without another model call |
  380. | `diagnostics.retentionDays` | `14` | 1–90 days; global config only |
  381. | `diagnostics.maxBytes` | `20000000` | 1–100 MB per process across its retained journals; global config only |
  382. Per-session `monitor.semantic` supports: `goal` (optional task context, sent bounded to 1,000 characters), `attention` (built-in events, default `false`), `watches` (safe unique IDs, nonempty conditions, optional threshold 0–1 with default `0.8`), `minIntervalMs` (default `1000`, clamped 250–60,000), `quietIntervalMs` (below), `uncertain` (`"continue"` by default or `"notify"`), and optional `actions`. Actions require literal `enabled: true`, 1–10 items, session `maxActions` default 1/max 10, safe unique IDs, descriptions up to 500 characters, exactly one text input (1–2,000 characters, optional `submit`) or strict key array (1–32 keys), encoded bytes up to 4,096, cooldown 0–86,400,000 ms, and per-action executions 1–10. A code-owned process-wide cap permits at most 10 semantic action attempts across all sessions; refused or throwing writes consume an attempt, and the cap is not caller-configurable.
  383. Quiet-state integration adds `quietIntervalMs`: one observe-only reassessment per inactivity episode (default 2,000ms, bounded 250–60,000 and still subject to `minIntervalMs`). It also covers sessions that produce no output. An unchanged quiet observation can notify but cannot execute actions or write terminal bytes.
  384. Bounded viewport/recent terminal text is sent to TypeSafe AI. ANSI/control text is stripped and built-in plus configured redaction runs first, but redaction is defense in depth—not a promise to identify every secret. Custom patterns use linear-time RE2-compatible syntax (no backreferences, lookaround, or nested repetition), are validated at config load, and replace every case-insensitive match with literal `[REDACTED]`. Invalid selected patterns reject configuration rather than being skipped. Full scrollback, request bodies, exact action input/bytes, and the API key are not stored in semantic history. Provider failures, uncertainty, stale responses, or a visible result never imply process completion or permission to act; PTY exit remains deterministic authority.
  385. Built-in attention notifications use the model's confident, mutually exclusive primary state. Confident `working` continues silently, confident `other` remains uncertain, and confident input, approval, result, or blocked states emit their corresponding bounded event. The same attention event is suppressed until the primary state changes or new input is written to the session, so screen churn such as token counters or timers does not wake Pi again while a follow-up question after an answer does. Independent watches and action-control events retain their own delivery semantics. Independent Noul answers remain inspectable metadata and drive watches or action readiness where configured; they do not duplicate-veto the primary attention event. This routing never grants terminal-action authority.
  386. Observe a hands-free or dispatch session without authorizing input:
  387. ```typescript
  388. interactive_shell({
  389. command: 'pi "Review the changes"',
  390. mode: "hands-free", // mode: "dispatch" also works
  391. monitor: { semantic: { goal: "Review changes and report blockers" } }
  392. })
  393. ```
  394. Emit built-in attention events and an independent watch:
  395. ```typescript
  396. interactive_shell({
  397. command: "npm test -- --watch",
  398. mode: "monitor",
  399. monitor: {
  400. strategy: "semantic",
  401. semantic: {
  402. attention: true,
  403. uncertain: "notify",
  404. watches: [{ id: "tests-failed", condition: "A test failure is visibly present", threshold: 0.85 }]
  405. }
  406. }
  407. })
  408. ```
  409. Authorize one bounded, immutable exact response:
  410. ```typescript
  411. interactive_shell({
  412. command: "deploy-tool",
  413. mode: "monitor",
  414. monitor: {
  415. strategy: "semantic",
  416. semantic: {
  417. attention: true,
  418. actions: {
  419. enabled: true,
  420. maxActions: 1,
  421. items: [{ id: "confirm", description: "Confirm the visible ordinary deployment prompt", input: "yes", submit: true, maxExecutions: 1 }]
  422. }
  423. }
  424. }
  425. })
  426. ```
  427. Actions are predeclared immutable `input` (+ optional `submit`) or strict `inputKeys`, never generated text, hex, paste, credentials, secret/payment entry, or lifecycle commands. Confidence is one required safety gate, not authorization. User takeover pauses supervision; returning control requires fresh rendered output before evaluation/action resumes. Semantic events never mark a process exited.
  428. Semantic events carry a bounded, already-redacted excerpt of the screen Jev evaluated. Answer a question with ordinary `input` or `inputKeys` on the session.
  429. Inspect semantic decisions with `interactive_shell({ semanticDecisions: true, semanticSessionId: sessionId })`. Inspect delivered events with `interactive_shell({ monitorEvents: true, monitorSessionId: sessionId })`; `monitorStatus: true` returns monitor lifecycle state.
  430. Optional diagnostics write private per-process JSONL journals under Pi's agent directory. Each process owns and bounds its own files, so writers need no shared lock. Records contain only fixed schema/version identifiers, random run and incident IDs, timestamps, bounded timing/token counts, fixed decision/event/outcome categories, and sanitized model names. They never contain terminal text, commands, paths, session IDs, observation hashes, configured goals or watches, credentials, API keys, raw provider responses, or free-form notes. Files are mode `0600`; expired records are excluded from summaries immediately, and old journals are pruned on later writes. Diagnostics add no terminal polling, provider request, notification, action, or automatic tuning.
  431. Summarize recent diagnostics without reading terminal content:
  432. ```typescript
  433. interactive_shell({ semanticDiagnostics: true, semanticDiagnosticDays: 7 })
  434. ```
  435. When ordinary task handling supplies observable evidence of a discrepancy, the agent can attach one fixed-category incident to a live semantic run:
  436. ```typescript
  437. interactive_shell({
  438. semanticSessionId: sessionId,
  439. semanticIncident: {
  440. kind: "wrong-notification-type",
  441. decisionId: 12,
  442. expectedEvent: "input-required",
  443. observedEvent: "result-ready"
  444. }
  445. })
  446. ```
  447. Supported incident categories are `missed-notification`, `unnecessary-notification`, `wrong-notification-type`, `duplicate-notification`, `premature-result`, and `stale-notification`. A report is a suspected problem, not ground truth. Confirm recurring incidents with an observable outcome or sanitized reproduction, add the reproduction to the corpus, then run `npm run eval:jev` before changing calibration. Diagnostics cannot discover a silent missed notification unless normal work or an explicit check causes the terminal state to be observed.
  448. Troubleshooting:
  449. - **Disabled globally:** set global `jev.enabled: true`; project configuration cannot enable transmission.
  450. - **Missing credential:** start Pi from an environment containing `TYPESAFE_API_KEY`; do not put it in tool or project configuration.
  451. - **Timeout/rate limit/provider failure:** the decision fails closed with a bounded diagnostic; increase only the global timeout within its bound or retry after provider recovery.
  452. - **Uncertain result:** default behavior is continue silently; set `uncertain: "notify"` to emit a bounded event. Uncertainty never authorizes input.
  453. - **Model change:** run the repository corpus explicitly with `npm run eval:jev` before relying on the new globally configured model. This command reads only packaged fixtures, requires the same global enablement and environment credential, and never runs in normal tests/CI. Its pass gate measures the expected attention state and default user-visible event outcome; `atomicAccuracy` separately reports agreement with every secondary Noul.
  454. TypeSafe states that customer requests/responses are not used to train Jev; see [Models](https://docs.typesafe.ai/models) and [Legal](https://docs.typesafe.ai/legal). Its [public privacy policy](https://typesafe.ai/legal/privacy-policy) says personal data is retained as reasonably necessary, so do not assume default zero retention. Enterprise zero-data-retention is a separate arrangement described by TypeSafe and is not enabled by this direct SDK integration.
  455. ## Config
  456. Configuration files (project overrides global):
  457. - **Global:** `~/.pi/agent/interactive-shell.json`
  458. - **Project:** `.pi/interactive-shell.json`
  459. ### Launch policy
  460. Global `launchPolicy` lets you allow, deny, or require confirmation for commands launched through `interactive_shell` and `/spawn`. It is off unless the field is present, and only the global config can set it; a project config that defines it is rejected.
  461. ```json
  462. {
  463. "launchPolicy": [
  464. { "command": "npm test", "decision": "allow" },
  465. { "command": "deploy --production", "decision": "deny" }
  466. ]
  467. }
  468. ```
  469. Each raw command, or the final resolved structured-spawn command including configured default arguments and prompt, is matched exactly before any PTY, session, process, or worktree is created. `deny` blocks, `ask` requires Pi's confirmation dialog, and `allow` proceeds. Unmatched commands ask, and when several rules match, `deny` wins over `ask`, which wins over `allow`. An empty array asks for every launch. Unavailable UI, rejection, or dialog failure blocks an `ask`. Queries, input, attach, and lifecycle calls for existing sessions are unaffected.
  470. The policy is local and needs no Jev setup, API key, or model call. It is an `interactive_shell` launch check, not a shell, Bash, Pi, or operating-system sandbox.
  471. ### Shell selection
  472. New sessions use the same Bash resolver as Pi rather than the ambient `$SHELL`
  473. or `COMSPEC`. On Unix, this changes the default from `$SHELL`/`/bin/sh` to
  474. Pi's Bash selection (`/bin/bash`, then `bash` on `PATH`, with Pi's documented
  475. fallback). On Windows, Pi discovers Git Bash in its standard install
  476. locations, then `bash.exe` on `PATH`.
  477. To choose a specific Bash executable, set Pi's `shellPath` in
  478. `~/.pi/agent/settings.json` (or trusted project `.pi/settings.json`):
  479. ```json
  480. {
  481. "shellPath": "C:/Program Files/Git/bin/bash.exe"
  482. }
  483. ```
  484. Project settings follow Pi's trust rules: a trusted project's `shellPath`
  485. overrides the global setting, while an untrusted project's setting is ignored.
  486. `shellPath` must select a Bash-compatible executable; PowerShell and `cmd.exe`
  487. are not interactive-shell transports. Pi's legacy WSL `bash.exe` uses
  488. stdin-only command transport and is rejected for interactive PTYs; select Git
  489. Bash instead.
  490. Deferred loading, tool schema, and shortcut settings are pinned at startup. If you change `defer`, `toolSchema`, `focusShortcut`, or `spawn.shortcut`, reload or restart Pi to apply them.
  491. ```json
  492. {
  493. "defer": false,
  494. "toolSchema": "lean",
  495. "overlayWidthPercent": 95,
  496. "overlayHeightPercent": 60,
  497. "overlayAnchor": "center",
  498. "focusShortcut": "alt+shift+f",
  499. "spawn": {
  500. "defaultAgent": "pi",
  501. "shortcut": "alt+shift+p",
  502. "commands": {
  503. "pi": "pi",
  504. "codex": "codex",
  505. "claude": "claude",
  506. "cursor": "agent",
  507. "aider": "aider"
  508. },
  509. "defaultArgs": {
  510. "pi": [],
  511. "codex": [],
  512. "claude": [],
  513. "cursor": ["--model", "composer-2-fast"],
  514. "aider": ["--yes-always"]
  515. },
  516. "worktree": false,
  517. "worktreeBaseDir": "../repo-worktrees"
  518. },
  519. "scrollbackLines": 5000,
  520. "exitAutoCloseDelay": 10,
  521. "minQueryIntervalSeconds": 60,
  522. "transferLines": 200,
  523. "transferMaxChars": 20000,
  524. "completionNotifyLines": 50,
  525. "completionNotifyMaxChars": 5000,
  526. "handsFreeUpdateMode": "on-quiet",
  527. "handsFreeUpdateInterval": 60000,
  528. "handsFreeQuietThreshold": 8000,
  529. "autoExitGracePeriod": 15000,
  530. "handsFreeUpdateMaxChars": 1500,
  531. "handsFreeMaxTotalChars": 100000,
  532. "handoffPreviewEnabled": true,
  533. "handoffPreviewLines": 30,
  534. "handoffPreviewMaxChars": 2000,
  535. "handoffSnapshotEnabled": false,
  536. "ansiReemit": true
  537. }
  538. ```
  539. | Setting | Default | Description |
  540. |---------|---------|-------------|
  541. | `defer` | `false` | Start each session with only `enable_interactive_shell`; the full tool loads on demand |
  542. | `toolSchema` | "lean" | `lean` lists only common fields in the tool definition; `full` lists every field. Both accept every field |
  543. | `overlayWidthPercent` | 95 | Overlay width (10-100%) |
  544. | `overlayHeightPercent` | 60 | Overlay height (20-90%) |
  545. | `overlayAnchor` | "center" | Overlay position: `center`, `top-left`, `top-center`, `top-right`, `left-center`, `right-center`, `bottom-left`, `bottom-center`, `bottom-right` |
  546. | `focusShortcut` | "alt+shift+f" | Toggle focus between overlay and main chat |
  547. | `spawn.defaultAgent` | "pi" | Configured default spawn agent for `/spawn`, the spawn shortcut, and agent-side structured spawn |
  548. | `spawn.shortcut` | "alt+shift+p" | Keyboard shortcut that launches the configured default spawn agent |
  549. | `spawn.commands.<agent>` | `pi` / `codex` / `claude` / `agent` (cursor) | Executable or path per spawn agent. Extra keys define custom spawn agents |
  550. | `spawn.defaultArgs.<agent>` | `[]` (Cursor defaults to `--model composer-2-fast`) | Extra default CLI args per spawn agent |
  551. | `spawn.worktree` | `false` | Launch spawns in a separate git worktree by default |
  552. | `spawn.worktreeBaseDir` | unset | Optional base directory for generated worktrees |
  553. | `scrollbackLines` | 5000 | Terminal scrollback buffer |
  554. | `exitAutoCloseDelay` | 10 | Seconds before auto-close after exit |
  555. | `minQueryIntervalSeconds` | 60 | Rate limit between agent queries |
  556. | `transferLines` | 200 | Lines to capture on Ctrl+T transfer (10-1000) |
  557. | `transferMaxChars` | 20000 | Max chars for transfer (1KB-100KB) |
  558. | `completionNotifyLines` | 50 | Lines in dispatch completion notification (10-500) |
  559. | `completionNotifyMaxChars` | 5000 | Max chars in completion notification (1KB-50KB) |
  560. | `handsFreeUpdateMode` | "on-quiet" | "on-quiet" or "interval" |
  561. | `handsFreeQuietThreshold` | 8000 | Silence duration before update (ms) |
  562. | `autoExitGracePeriod` | 15000 | Startup grace before `autoExitOnQuiet` cancellation (ms) |
  563. | `handsFreeUpdateInterval` | 60000 | Max interval between updates (ms) |
  564. | `handsFreeUpdateMaxChars` | 1500 | Max chars per update |
  565. | `handsFreeMaxTotalChars` | 100000 | Total char budget for updates |
  566. | `handoffPreviewEnabled` | true | Include tail in tool result |
  567. | `handoffPreviewLines` | 30 | Lines in tail preview (0-500) |
  568. | `handoffPreviewMaxChars` | 2000 | Max chars in tail preview (0-50KB) |
  569. | `handoffSnapshotEnabled` | false | Write transcript on detach/exit |
  570. | `ansiReemit` | true | Preserve ANSI colors in output |
  571. ## How It Works
  572. ```
  573. interactive_shell → zigpty → subprocess
  574. ↓
  575. xterm-headless (terminal emulation)
  576. ↓
  577. TUI overlay (pi rendering)
  578. ```
  579. Full PTY. The subprocess thinks it's in a real terminal.
  580. ## Example Workflow: Plan, Implement, Review
  581. The `examples/prompts/` directory includes three opt-in prompt templates that chain together into a complete development workflow using Codex CLI. Each template loads the example `gpt-5-4-prompting` skill by default, falls back to `codex-5-3-prompting` when the user explicitly asks for Codex 5.3, and launches Codex in an interactive overlay with Codex CLI's preferred `gpt-5.5` model.
  582. ### The Pipeline
  583. ```
  584. Write a plan
  585. ↓
  586. /codex-review-plan path/to/plan.md ← Codex verifies every assumption against the codebase
  587. ↓
  588. /codex-implement-plan path/to/plan.md ← Codex implements the reviewed plan faithfully
  589. ↓
  590. /codex-review-impl path/to/plan.md ← Codex reviews the diff against the plan, fixes issues
  591. ```
  592. ### Installing the Templates
  593. Install the package first for the extension and core `interactive-shell` skill:
  594. ```bash
  595. pi install npm:pi-interactive-shell
  596. ```
  597. The Codex workflow prompts and supporting skills are opt-in examples. Copy them into your agent config if you want to use them:
  598. ```bash
  599. # Prompt templates (slash commands)
  600. cp ~/.pi/agent/extensions/pi-interactive-shell/examples/prompts/*.md ~/.pi/agent/prompts/
  601. # Optional skills used by the templates
  602. cp -r ~/.pi/agent/extensions/pi-interactive-shell/examples/skills/codex-cli ~/.pi/agent/skills/
  603. cp -r ~/.pi/agent/extensions/pi-interactive-shell/examples/skills/gpt-5-4-prompting ~/.pi/agent/skills/
  604. cp -r ~/.pi/agent/extensions/pi-interactive-shell/examples/skills/codex-5-3-prompting ~/.pi/agent/skills/
  605. # Optional CLI reference skill
  606. cp -r ~/.pi/agent/extensions/pi-interactive-shell/examples/skills/cursor-cli ~/.pi/agent/skills/
  607. ```
  608. ### Usage
  609. Say you have a plan at `docs/auth-redesign-plan.md`:
  610. **Step 1: Review the plan** — Codex reads your plan, then verifies every file path, API shape, data flow, and integration point against the actual codebase. Fixes issues directly in the plan file.
  611. ```
  612. /codex-review-plan docs/auth-redesign-plan.md
  613. /codex-review-plan docs/auth-redesign-plan.md pay attention to the migration steps
  614. ```
  615. **Step 2: Implement the plan** — Codex reads all relevant code first, then implements bottom-up: shared utilities first, then dependent modules, then integration code. No stubs, no TODOs.
  616. ```
  617. /codex-implement-plan docs/auth-redesign-plan.md
  618. /codex-implement-plan docs/auth-redesign-plan.md skip test files for now
  619. ```
  620. **Step 3: Review the implementation** — Codex diffs the changes, reads every changed file in full (plus imports and dependents), traces code paths across file boundaries, and fixes every issue it finds. Pass the plan to verify completeness, or omit it to just review the diff.
  621. ```
  622. /codex-review-impl docs/auth-redesign-plan.md # review diff against plan
  623. /codex-review-impl docs/auth-redesign-plan.md check cleanup ordering
  624. /codex-review-impl # just review the diff, no plan
  625. /codex-review-impl focus on error handling and race conditions
  626. ```
  627. ### How They Work
  628. These templates demonstrate a "meta-prompt generation" pattern:
  629. 1. **Pi gathers context** — reads the plan, runs git diff, and loads the copied local `gpt-5-4-prompting` or `codex-5-3-prompting` skill
  630. 2. **Pi generates a calibrated prompt** — tailored to the specific plan/diff, following the selected skill's best practices
  631. 3. **Pi launches Codex in the overlay** — defaulting to `-m gpt-5.5 -a never` and switching to `-m gpt-5.3-codex -a never` only when the user explicitly asks for Codex 5.3
  632. The user watches Codex work in the overlay and can take over anytime (type to intervene, Ctrl+T to transfer output back to pi, Ctrl+Q for options).
  633. ### Customizing
  634. These are starting points. Fork them and adjust:
  635. - **Model/flags** — swap `gpt-5.3-codex` for another model, change reasoning effort
  636. - **Review criteria** — add project-specific checks (security policies, style rules)
  637. - **Implementation rules** — change the 500-line file limit, add framework-specific patterns
  638. - **Other agents** — adapt the pattern for Claude (`claude "prompt"`), Gemini (`gemini -i "prompt"`), or any CLI
  639. See the [pi prompt templates docs](https://github.com/badlogic/pi-mono/) for the full `$1`, `$@` placeholder syntax.
  640. ## Advanced: Multi-Agent Workflows
  641. For orchestrating multi-agent chains (scout → planner → worker → reviewer) with file-based handoff and auto-continue support, see:
  642. **[pi-foreground-chains](https://github.com/nicobailon/pi-foreground-chains)** - A separate skill that builds on interactive-shell for complex agent workflows.
  643. ## Limitations
  644. - macOS tested, Linux experimental
  645. - 60s rate limit between queries (configurable)
  646. - Some TUI apps may have rendering quirks

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.