pi-interactive-shell 0.3.0

package/CHANGELOG.md

@@ -0,0 +1,63 @@
+# Changelog
+
+All notable changes to the `pi-interactive-shell` extension will be documented in this file.
+
+## [0.3.0] - 2026-01-17
+
+### Added
+- Hands-free mode (`mode: "hands-free"`) for agent-driven monitoring with periodic tail updates.
+- User can take over hands-free sessions by typing anything (except scroll keys).
+- Configurable update settings for hands-free mode (defaults: on-quiet mode, 5s quiet threshold, 60s max interval, 1500 chars/update, 100KB total budget).
+- **Input injection**: Send input to active hands-free sessions via `sessionId` + `input` parameters.
+- Named key support: `up`, `down`, `enter`, `escape`, `ctrl+c`, etc.
+- "Foreground subagents" terminology to distinguish from background subagents (the `subagent` tool).
+- `sessionId` now available in the first update (before overlay opens) for immediate input injection.
+- **Timeout**: Auto-kill process after N milliseconds via `timeout` parameter. Useful for TUI commands that don't exit cleanly (e.g., `pi --help`).
+- **DSR handling**: Automatically responds to cursor position queries (`ESC[6n` / `ESC[?6n`) with actual xterm cursor position. Prevents TUI apps from hanging when querying cursor.
+- **Enhanced key encoding**: Full modifier support (`ctrl+alt+x`, `shift+tab`, `c-m-delete`), hex bytes (`hex: ["0x1b"]`), bracketed paste mode (`paste: "text"`), and all F1-F12 keys.
+- **Human-readable session IDs**: Sessions now get memorable names like `calm-reef`, `swift-cove` instead of `shell-1`, `shell-2`.
+- **Process tree killing**: Kill entire process tree on termination, preventing orphan child processes.
+- **Session name derivation**: Better display names in `/attach` list showing command summary.
+- **Write queue**: Ordered writes to terminal emulator prevent race conditions.
+- **Raw output streaming**: `getRawStream()` method for incremental output reading with `sinceLast` option.
+- **Exit message in terminal**: Process exit status appended to terminal buffer when process exits.
+- **EOL conversion**: Added `convertEol: true` to xterm for consistent line ending handling.
+- **Incremental updates**: Hands-free updates now send only NEW output since last update, not full tail. Dramatically reduces context bloat.
+- **Activity-driven updates (on-quiet mode)**: Default behavior now waits for 5s of output silence before emitting update. Perfect for agent-to-agent delegation where you want complete "thoughts" not fragments.
+- **Update modes**: `handsFree.updateMode` can be `"on-quiet"` (default) or `"interval"`. On-quiet emits when output stops; interval emits on fixed schedule.
+- **Context budget**: Total character budget (default: 100KB, configurable via `handsFree.maxTotalChars`). Updates stop including content when exhausted.
+- **Dynamic settings**: Change update interval and quiet threshold mid-session via `settings: { updateInterval, quietThreshold }`.
+- **Keypad keys**: Added `kp0`-`kp9`, `kp/`, `kp*`, `kp-`, `kp+`, `kp.`, `kpenter` for numpad input.
+- **tmux-style key aliases**: Added `ppage`/`npage` (PageUp/PageDown), `ic`/`dc` (Insert/Delete), `bspace` (Backspace) for compatibility.
+
+### Changed
+- ANSI stripping now uses Node.js built-in `stripVTControlCharacters` for cleaner, more robust output processing.
+
+### Fixed
+- Double unregistration in hands-free session cleanup (now idempotent via `sessionUnregistered` flag).
+- Potential double `done()` call when timeout fires and process exits simultaneously (added `finished` guard).
+- ReattachOverlay: untracked setTimeout for initial countdown could fire after dispose (now tracked).
+- Input type annotation missing `hex` and `paste` fields.
+- Background session auto-cleanup could dispose session while user is viewing it via `/attach` (now cancels timer on reattach).
+- On-quiet mode now flushes pending output before sending "exited" or "user-takeover" notifications (prevents data loss).
+- Interval mode now also flushes pending output on user takeover (was missing the `|| updateMode === "interval"` check).
+- Timeout in hands-free mode now flushes pending output and sends "exited" notification before returning.
+- Exit handler now waits for writeQueue to drain, ensuring exit message is in rawOutput before notification is sent.
+
+### Removed
+- `handsFree.updateLines` option (was defined but unused after switch to incremental char-based updates).
+
+## [0.2.0] - 2026-01-17
+
+### Added
+- Interactive shell overlay tool `interactive_shell` for supervising interactive CLI agent sessions.
+- Detach dialog (double `Esc`) with kill/background/cancel.
+- Background session reattach command: `/attach`.
+- Scroll support: `Shift+Up` / `Shift+Down`.
+- Tail handoff preview included in tool result (bounded).
+- Optional snapshot-to-file transcript handoff (disabled by default).
+
+### Fixed
+- Prevented TUI width crashes by avoiding unbounded terminal escape rendering.
+- Reduced flicker by sanitizing/redrawing in a controlled overlay viewport.
+

package/README.md

@@ -0,0 +1,173 @@
+# Interactive Shell Extension
+
+Run AI coding agents (Claude Code, Gemini CLI, Codex, Aider, etc.) as **foreground subagents** inside a pi TUI overlay. The user sees the agent working in real-time and can take over control at any time.
+
+This is distinct from **background subagents** (the `subagent` tool) which run pi instances invisibly.
+
+## Foreground vs Background Subagents
+
+| | Foreground (`interactive_shell`) | Background (`subagent`) |
+|---|---|---|
+| **Visibility** | User sees overlay | Hidden |
+| **Agents** | Any CLI agent | Pi only |
+| **Output** | Incremental updates | Full capture |
+| **User control** | Can intervene | None |
+
+## Install
+
+```bash
+npx pi-interactive-shell-install
+```
+
+This installs the extension to `~/.pi/agent/extensions/interactive-shell/`, runs `npm install` for dependencies, and creates the skill symlink.
+
+**Requirements:** `node-pty` requires build tools (Xcode Command Line Tools on macOS).
+
+**Manual install:** If you prefer, clone/copy the files manually and run `npm install` in the extension directory.
+
+## Usage
+
+### Tool: `interactive_shell`
+
+**Start a new session:**
+- `command` (string, required): CLI agent command
+- `cwd` (string): working directory
+- `name` (string): session name (used in sessionId)
+- `reason` (string): shown in overlay header (UI-only, not passed to subprocess)
+- `mode` (string): `"interactive"` (default) or `"hands-free"`
+- `timeout` (number): auto-kill after N milliseconds (for TUI commands that don't exit)
+- `handsFree` (object): options for hands-free mode
+  - `updateMode` (string): `"on-quiet"` (default) or `"interval"`
+  - `updateInterval` (number): max ms between updates, fallback for on-quiet (default: 60000)
+  - `quietThreshold` (number): ms of silence before emitting update in on-quiet mode (default: 5000)
+  - `updateMaxChars` (number): max chars per update (default: 1500)
+  - `maxTotalChars` (number): total char budget for all updates (default: 100000)
+- `handoffPreview` (object): tail preview in tool result
+- `handoffSnapshot` (object): write transcript to file
+
+**Send input to active session:**
+- `sessionId` (string, required): session ID from hands-free updates
+- `input` (string | object): input to send
+  - As string: raw text/keystrokes (e.g., `"/model\n"`)
+  - As object: `{ text?, keys?, hex?, paste? }`
+
+**Change settings mid-session:**
+- `sessionId` (string, required): session ID
+- `settings` (object): `{ updateInterval?, quietThreshold? }`
+
+### Command: `/attach`
+
+Reattach to background sessions:
+```
+/attach
+/attach <id>
+```
+
+## Modes
+
+### Interactive (default)
+
+User supervises and controls the session directly.
+
+```typescript
+interactive_shell({ command: 'pi "Review this code"' })
+```
+
+### Hands-Free (Foreground Subagent)
+
+Agent monitors with periodic updates. User sees the overlay and can take over by typing. **Default to `pi`** unless user requests a different agent.
+
+```typescript
+interactive_shell({
+  command: 'pi "Fix all lint errors in src/"',
+  mode: "hands-free",
+  reason: "Fixing lint errors"
+})
+```
+
+**Update modes:**
+- `on-quiet` (default): Emit update after 5s of output silence. Perfect for agent-to-agent delegation.
+- `interval`: Emit on fixed schedule (every 60s). Use when continuous output is expected.
+
+**Context budget:**
+- Updates include only NEW output since last update (incremental)
+- Default: 1500 chars per update, 100KB total budget
+- When budget exhausted, updates continue but without content
+
+**Status updates (all include `sessionId`):**
+- Initial update - sent immediately when session starts
+- `status: "running"` - incremental output
+- `status: "user-takeover"` - user typed something
+- `status: "exited"` - process finished
+
+### Sending Input to Active Sessions
+
+Use `sessionId` from updates to send input:
+
+```typescript
+// Text input
+interactive_shell({ sessionId: "calm-reef", input: "/help\n" })
+
+// Named keys
+interactive_shell({ sessionId: "calm-reef", input: { text: "/model", keys: ["enter"] } })
+
+// Navigate menus
+interactive_shell({ sessionId: "calm-reef", input: { keys: ["down", "down", "enter"] } })
+
+// Hex bytes for raw escape sequences
+interactive_shell({ sessionId: "calm-reef", input: { hex: ["0x1b", "0x5b", "0x41"] } })
+
+// Bracketed paste (prevents auto-execution)
+interactive_shell({ sessionId: "calm-reef", input: { paste: "multi\nline\ntext" } })
+```
+
+**Named keys:** `up`, `down`, `left`, `right`, `enter`, `escape`, `tab`, `backspace`, `delete`, `home`, `end`, `pageup`, `pagedown`, `f1`-`f12`, `ctrl+c`, `ctrl+d`, etc.
+
+**Keypad keys:** `kp0`-`kp9`, `kp/`, `kp*`, `kp-`, `kp+`, `kp.`, `kpenter`
+
+**tmux-style aliases:** `ppage`/`npage` (PageUp/PageDown), `ic`/`dc` (Insert/Delete), `bspace` (Backspace), `btab` (Shift+Tab)
+
+**Modifiers:** `ctrl+x`, `alt+x`, `shift+tab`, `ctrl+alt+delete` (or shorthand: `c-x`, `m-x`, `s-tab`)
+
+### Change Settings Mid-Session
+
+```typescript
+interactive_shell({ sessionId: "calm-reef", settings: { updateInterval: 30000 } })
+interactive_shell({ sessionId: "calm-reef", settings: { quietThreshold: 3000 } })
+```
+
+## Config
+
+Global: `~/.pi/agent/interactive-shell.json`
+Project: `<cwd>/.pi/interactive-shell.json`
+
+```json
+{
+  "doubleEscapeThreshold": 300,
+  "exitAutoCloseDelay": 10,
+  "overlayWidthPercent": 95,
+  "overlayHeightPercent": 90,
+  "scrollbackLines": 5000,
+  "ansiReemit": true,
+  "handoffPreviewEnabled": true,
+  "handoffPreviewLines": 30,
+  "handoffPreviewMaxChars": 2000,
+  "handoffSnapshotEnabled": false,
+  "handoffSnapshotLines": 200,
+  "handoffSnapshotMaxChars": 12000,
+  "handsFreeUpdateMode": "on-quiet",
+  "handsFreeUpdateInterval": 60000,
+  "handsFreeQuietThreshold": 5000,
+  "handsFreeUpdateMaxChars": 1500,
+  "handsFreeMaxTotalChars": 100000
+}
+```
+
+## Keys
+
+| Key | Action |
+|-----|--------|
+| `Esc` twice | Detach dialog (kill/background/cancel) |
+| `Shift+Up/Down` | Scroll (no takeover in hands-free) |
+| `Ctrl+C` | Forwarded to subprocess |
+| Any other key (hands-free) | Triggers user takeover |

package/SKILL.md

@@ -0,0 +1,368 @@
+---
+name: interactive-shell
+description: Cheat sheet + workflow for launching interactive coding-agent CLIs (Claude Code, Gemini CLI, Codex CLI, Cursor CLI, and pi itself) via the interactive_shell overlay. The overlay is for interactive supervision only - headless commands should use the bash tool instead.
+---
+
+# Interactive Shell (Skill)
+
+Last verified: 2026-01-17
+
+## Foreground vs Background Subagents
+
+Pi has two ways to delegate work to other AI coding agents:
+
+| | Foreground Subagents | Background Subagents |
+|---|---|---|
+| **Tool** | `interactive_shell` | `subagent` |
+| **Visibility** | User sees overlay in real-time | Hidden from user |
+| **Default agent** | `pi` (others if user requests) | Pi only |
+| **Output** | Minimal (tail preview) | Full output captured |
+| **User control** | Can take over anytime | No intervention |
+| **Best for** | Long tasks needing supervision | Parallel tasks, structured delegation |
+
+**Foreground subagents** run in an overlay where the user watches (and can intervene). Use `interactive_shell` with `mode: "hands-free"` to monitor while receiving periodic updates.
+
+**Background subagents** run invisibly via the `subagent` tool. Pi-only, but captures full output and supports parallel execution.
+
+## When to Use Foreground Subagents
+
+Use `interactive_shell` (foreground) when:
+- The task is **long-running** and the user should see progress
+- The user might want to **intervene or guide** the agent
+- You want **hands-free monitoring** with periodic status updates
+- You need a **different agent's capabilities** (only if user specifies)
+
+Use `subagent` (background) when:
+- You need **parallel execution** of multiple tasks
+- You want **full output capture** for processing
+- The task is **quick and deterministic**
+- User doesn't need to see the work happening
+
+### Default Agent Choice
+
+**Default to `pi`** for foreground subagents unless the user explicitly requests a different agent:
+
+| User says | Agent to use |
+|-----------|--------------|
+| "Run this in hands-free" | `pi` |
+| "Delegate this task" | `pi` |
+| "Use Claude to review this" | `claude` |
+| "Have Gemini analyze this" | `gemini` |
+| "Run aider to fix this" | `aider` |
+
+Pi is the default because it's already available, has the same capabilities, and maintains consistency. Only use Claude, Gemini, Codex, or other agents when the user specifically asks for them.
+
+## Foreground Subagent Modes
+
+### Interactive (default)
+User has full control, types directly into the agent.
+```typescript
+interactive_shell({ command: 'pi' })
+```
+
+### Interactive with Initial Prompt
+Agent starts working immediately, user supervises.
+```typescript
+interactive_shell({ command: 'pi "Review this codebase for security issues"' })
+```
+
+### Hands-Free (Foreground Subagent)
+Agent works autonomously, you receive periodic updates, user can take over anytime.
+```typescript
+interactive_shell({
+  command: 'pi "Fix all TypeScript errors in src/"',
+  mode: "hands-free",
+  reason: "Fixing TS errors"
+})
+```
+
+This is the primary pattern for **foreground subagents** - you delegate to pi (or another agent if user specifies) while monitoring progress.
+
+## Hands-Free Status Updates
+
+When running in hands-free mode, `sessionId` is available immediately in the first update (before the overlay opens). Subsequent updates include:
+- `status: "running"` - update with **incremental output** (only new content since last update)
+- `status: "user-takeover"` - user typed something and took control
+- `status: "exited"` - process exited (final update before tool returns)
+
+Updates include budget tracking: `totalCharsSent` and `budgetExhausted` fields.
+
+After takeover or exit, the tool continues blocking until the session closes.
+
+### Update Modes
+
+**on-quiet (default)**: Updates emit after 5 seconds of output silence. Perfect for agent-to-agent delegation - you receive complete "thoughts" rather than fragments mid-stream.
+
+**interval**: Updates emit on a fixed schedule (every 60s). Use when continuous output is expected.
+
+```typescript
+// Default: on-quiet mode (recommended for agent delegation)
+interactive_shell({
+  command: 'pi "Fix all TypeScript errors"',
+  mode: "hands-free"
+})
+
+// Force interval mode for continuous output
+interactive_shell({
+  command: 'tail -f /var/log/app.log',
+  mode: "hands-free",
+  handsFree: { updateMode: "interval", updateInterval: 10000 }
+})
+```
+
+### Context Budget
+
+Updates have a **total character budget** (default: 100KB) to prevent overwhelming your context window:
+- Each update includes only NEW output since the last update (not full tail)
+- Default: 1500 chars max per update, 100KB total budget
+- When budget is exhausted, updates continue but without content (status-only)
+- Configure via `handsFree.maxTotalChars`
+
+```typescript
+// Custom budget for a long task
+interactive_shell({
+  command: 'pi "Refactor entire codebase"',
+  mode: "hands-free",
+  handsFree: { maxTotalChars: 200000 }  // 200KB budget
+})
+```
+
+## Sending Input to Active Sessions
+
+Use the `sessionId` from updates to send input to a running hands-free session:
+
+### Basic Input
+```typescript
+// Send text
+interactive_shell({ sessionId: "shell-1", input: "/help\n" })
+
+// Send with named keys
+interactive_shell({ sessionId: "shell-1", input: { text: "/model", keys: ["enter"] } })
+
+// Navigate menus
+interactive_shell({ sessionId: "shell-1", input: { keys: ["down", "down", "enter"] } })
+
+// Interrupt
+interactive_shell({ sessionId: "shell-1", input: { keys: ["ctrl+c"] } })
+```
+
+### Named Keys
+| Key | Description |
+|-----|-------------|
+| `up`, `down`, `left`, `right` | Arrow keys |
+| `enter`, `return` | Enter/Return |
+| `escape`, `esc` | Escape |
+| `tab`, `shift+tab` (or `btab`) | Tab / Back-tab |
+| `backspace`, `bspace` | Backspace |
+| `delete`, `del`, `dc` | Delete |
+| `insert`, `ic` | Insert |
+| `home`, `end` | Home/End |
+| `pageup`, `pgup`, `ppage` | Page Up |
+| `pagedown`, `pgdn`, `npage` | Page Down |
+| `f1`-`f12` | Function keys |
+| `kp0`-`kp9`, `kp/`, `kp*`, `kp-`, `kp+`, `kp.`, `kpenter` | Keypad keys |
+| `ctrl+c`, `ctrl+d`, `ctrl+z` | Control sequences |
+| `ctrl+a` through `ctrl+z` | All control keys |
+
+Note: `ic`/`dc`, `ppage`/`npage`, `bspace` are tmux-style aliases for compatibility.
+
+### Modifier Combinations
+Supports `ctrl+`, `alt+`, `shift+` prefixes (or shorthand `c-`, `m-`, `s-`):
+```typescript
+// Cancel
+{ keys: ["ctrl+c"] }
+
+// Alt+Tab
+{ keys: ["alt+tab"] }
+
+// Ctrl+Alt+Delete
+{ keys: ["ctrl+alt+delete"] }
+
+// Shorthand syntax
+{ keys: ["c-c", "m-x", "s-tab"] }
+```
+
+### Hex Bytes (Advanced)
+Send raw escape sequences:
+```typescript
+{ hex: ["0x1b", "0x5b", "0x41"] }  // ESC[A (up arrow)
+```
+
+### Bracketed Paste
+Paste multiline text without triggering autocompletion/execution:
+```typescript
+{ paste: "function foo() {\n  return 42;\n}" }
+```
+
+### Model Selection Example
+```typescript
+// Step 1: Open model selector
+interactive_shell({ sessionId: "shell-1", input: { text: "/model", keys: ["enter"] } })
+
+// Step 2: Filter and select (after ~500ms delay)
+interactive_shell({ sessionId: "shell-1", input: { text: "sonnet", keys: ["enter"] } })
+
+// Or navigate with arrows:
+interactive_shell({ sessionId: "shell-1", input: { keys: ["down", "down", "down", "enter"] } })
+```
+
+### Context Compaction
+```typescript
+interactive_shell({ sessionId: "shell-1", input: { text: "/compact", keys: ["enter"] } })
+```
+
+### Changing Update Settings
+Adjust timing during a session:
+```typescript
+// Change max interval (fallback for on-quiet mode)
+interactive_shell({ sessionId: "calm-reef", settings: { updateInterval: 120000 } })
+
+// Change quiet threshold (how long to wait after output stops)
+interactive_shell({ sessionId: "calm-reef", settings: { quietThreshold: 3000 } })
+
+// Both at once
+interactive_shell({ sessionId: "calm-reef", settings: { updateInterval: 30000, quietThreshold: 2000 } })
+```
+
+## CLI Cheat Sheet
+
+### Claude Code (`claude`)
+
+| Mode | Command |
+|------|---------|
+| Interactive (idle) | `claude` |
+| Interactive (prompted) | `claude "Explain this project"` |
+| Headless (use bash, not overlay) | `claude -p "Explain this function"` |
+
+### Gemini CLI (`gemini`)
+
+| Mode | Command |
+|------|---------|
+| Interactive (idle) | `gemini` |
+| Interactive (prompted) | `gemini -i "Explain this codebase"` |
+| Headless (use bash, not overlay) | `gemini -p "What is fine tuning?"` |
+
+### Codex CLI (`codex`)
+
+| Mode | Command |
+|------|---------|
+| Interactive (idle) | `codex` |
+| Interactive (prompted) | `codex "Explain this codebase"` |
+| Headless (use bash, not overlay) | `codex exec "summarize the repo"` |
+
+### Cursor CLI (`cursor-agent`)
+
+| Mode | Command |
+|------|---------|
+| Interactive (idle) | `cursor-agent` |
+| Interactive (prompted) | `cursor-agent "review this repo"` |
+| Headless (use bash, not overlay) | `cursor-agent -p "find issues" --output-format text` |
+
+### Pi (`pi`)
+
+| Mode | Command |
+|------|---------|
+| Interactive (idle) | `pi` |
+| Interactive (prompted) | `pi "List all .ts files"` |
+| Headless (use bash, not overlay) | `pi -p "List all .ts files"` |
+
+Note: Delegating pi to pi is recursive - usually prefer `subagent` for pi-to-pi delegation.
+
+## Prompt Packaging Rules
+
+The `reason` parameter is **UI-only** - it's shown in the overlay header but NOT passed to the subprocess.
+
+To give the agent an initial prompt, embed it in the `command`:
+```typescript
+// WRONG - agent starts idle, reason is just UI text
+interactive_shell({ command: 'claude', reason: 'Review the codebase' })
+
+// RIGHT - agent receives the prompt
+interactive_shell({ command: 'claude "Review the codebase"', reason: 'Code review' })
+```
+
+## Handoff Options
+
+### Tail Preview (default)
+Last 30 lines included in tool result. Good for seeing errors/final status.
+
+### Snapshot to File
+Write full transcript to `~/.pi/agent/cache/interactive-shell/snapshot-*.log`:
+```typescript
+interactive_shell({
+  command: 'claude "Fix bugs"',
+  handoffSnapshot: { enabled: true, lines: 200 }
+})
+```
+
+### Artifact Handoff (recommended for complex tasks)
+Instruct the delegated agent to write a handoff file:
+```
+Write your findings to .pi/delegation/claude-handoff.md including:
+- What you did
+- Files changed
+- Any errors
+- Next steps for the main agent
+```
+
+## Safe TUI Capture
+
+**Never run TUI agents via bash** - they hang even with `--help`. Use `interactive_shell` with `timeout` instead:
+
+```typescript
+interactive_shell({
+  command: "pi --help",
+  mode: "hands-free",
+  timeout: 5000  // Auto-kill after 5 seconds
+})
+```
+
+The process is killed after timeout and captured output is returned in the handoff preview. This is useful for:
+- Getting CLI help from TUI applications
+- Capturing output from commands that don't exit cleanly
+- Any TUI command where you need quick output without user interaction
+
+For pi CLI documentation, you can also read directly: `/opt/homebrew/lib/node_modules/@mariozechner/pi-coding-agent/README.md`
+
+## Quick Reference
+
+**Start foreground subagent (hands-free, default to pi):**
+```typescript
+interactive_shell({
+  command: 'pi "Implement the feature described in SPEC.md"',
+  mode: "hands-free",
+  reason: "Implementing feature"
+})
+// Returns sessionId in updates, e.g., "shell-1"
+```
+
+**Send input to active session:**
+```typescript
+// Text with enter
+interactive_shell({ sessionId: "calm-reef", input: "/compact\n" })
+
+// Named keys
+interactive_shell({ sessionId: "calm-reef", input: { text: "/model", keys: ["enter"] } })
+
+// Menu navigation
+interactive_shell({ sessionId: "calm-reef", input: { keys: ["down", "down", "enter"] } })
+```
+
+**Change update frequency:**
+```typescript
+interactive_shell({ sessionId: "calm-reef", settings: { updateInterval: 60000 } })
+```
+
+**Foreground subagent (user requested different agent):**
+```typescript
+interactive_shell({
+  command: 'claude "Review this code for security issues"',
+  mode: "hands-free",
+  reason: "Security review with Claude"
+})
+```
+
+**Background subagent:**
+```typescript
+subagent({ agent: "scout", task: "Find all TODO comments" })
+```