@aerode/pish 0.8.0 → 0.9.2

package/README.md

@@ -1,38 +1,84 @@
+<div align="center">
+
 # pish
 
 **Your shell, with AI built in.**
 
-pish wraps bash or zsh transparently. Every command you know works exactly as before — zero overhead. When you type something the shell doesn't recognize, an AI agent ([pi](https://github.com/badlogic/pi-mono)) kicks in automatically.
+[![CI](https://github.com/dacapoday/pish/actions/workflows/ci.yml/badge.svg)](https://github.com/dacapoday/pish/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/@aerode/pish?color=cb0000&label=npm)](https://www.npmjs.com/package/@aerode/pish)
+[![Node.js](https://img.shields.io/badge/node-%E2%89%A518-339933?logo=nodedotjs&logoColor=white)](https://nodejs.org/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+<br/>
 
-<p align="center">
-  <img src="pish-example.gif" alt="pish demo" width="600">
+<p>
+  <a href="#-features">Features</a> ·
+  <a href="#-quick-start">Quick Start</a> ·
+  <a href="#-usage">Usage</a> ·
+  <a href="#%EF%B8%8F-configuration">Configuration</a> ·
+  <a href="#-how-it-works">How It Works</a> ·
+  <a href="#-contributing">Contributing</a>
 </p>
 
-## How it works
+<br/>
 
-pish runs your shell inside a PTY with lightweight hooks injected via rcfile. Normal commands flow through untouched. Only when `command_not_found` fires does pish intercept — it sends your recent shell history as context to the AI agent, which can read files, run commands, and edit code.
+<img src="pish-example.gif" alt="pish demo" width="640">
 
-```
-You ←→ pish (Node.js) ←→ PTY (bash/zsh + hooks)
-              ↓
-        Agent (pi --mode rpc, on demand)
-              ↓
-        Renderer → stderr
-```
+</div>
+
+---
+
+## Why pish?
+
+You already know your shell. You've built muscle memory for `cd`, `grep`, `git`, pipes, redirections, and a hundred aliases. **Why should talking to AI mean leaving all that behind?**
+
+pish doesn't replace your shell — it **is** your shell. Every command you know works exactly as before, with zero overhead. The moment you type something the shell doesn't recognize, an AI coding agent ([pi](https://github.com/badlogic/pi-mono)) seamlessly steps in — reading files, running commands, and editing code — all without breaking your flow.
+
+> **Think of it as autocomplete for intent:** you describe what you want in plain English, and pish makes it happen, right where you are.
+
+## ✨ Features
+
+<table>
+<tr>
+<td width="50%">
+
+### 🔄 Transparent Shell Wrapper
+Every alias, function, pipe, redirection, job control, tab completion, and history feature works exactly as in your native bash/zsh.
+
+### 🤖 Automatic AI Agent
+Type anything the shell doesn't recognize — the AI agent activates with your recent shell context, reads files, runs commands, and edits code.
+
+### 🚀 Zero Overhead
+Normal commands never touch the AI. No hooks intercepting your keystrokes, no latency. The agent is on-demand only.
+
+</td>
+<td width="50%">
+
+### 🧠 Context-Aware
+The agent automatically sees your recent commands and their outputs — it understands what you've been doing and can pick up where you left off.
+
+### 🔀 Seamless pi TUI
+Type `pi` to switch to the full pi TUI. Your conversation carries over — the AI remembers everything. Exit pi, and you're right back in pish.
 
-Agent output goes to **stderr**, never contaminating your shell's stdout. Your prompt, pipes, and redirections work exactly as expected.
+### ⚡ Control Commands
+Switch models, adjust thinking levels, and compact context — all without leaving your terminal. Just type `/model`, `/think`, or `/compact`.
 
-## Quick start
+</td>
+</tr>
+</table>
 
-**Requirements:**
-- Node.js ≥ 18
-- bash ≥ 4.4 or zsh ≥ 5.0
-- [`pi`](https://github.com/badlogic/pi-mono) installed and on PATH
+## 📦 Quick Start
+
+### Prerequisites
+
+- **Node.js** ≥ 18
+- **bash** ≥ 4.4 or **zsh** ≥ 5.0
+- [**pi**](https://github.com/badlogic/pi-mono) installed and on PATH
 
 ### Install from npm
 
 ```bash
-npm install -g pish
+npm install -g @aerode/pish
 ```
 
 ### Install from source
@@ -45,7 +91,7 @@ npm run build
 npm link          # makes `pish` available globally
 ```
 
-### Run
+### Launch
 
 ```bash
 pish                            # start with $SHELL (or bash)
@@ -54,13 +100,13 @@ pish /usr/local/bin/bash        # use a specific shell binary
 pish --pi /path/to/pi           # use a specific pi binary
 ```
 
-## Usage
+## 🎯 Usage
 
-### Normal commands
+### Normal commands — everything just works
 
-Everything works exactly like your regular shell — aliases, functions, pipes, redirections, job control, history, tab completion.
+Aliases, functions, pipes, redirections, job control, history, tab completion — **all unchanged**. pish adds zero overhead to normal shell operations.
 
-### AI agent
+### AI agent — just describe what you want
 
 Type anything the shell doesn't recognize. The agent sees your recent commands and their outputs as context:
 
@@ -68,35 +114,48 @@ Type anything the shell doesn't recognize. The agent sees your recent commands a
 ❯ find all TODO comments in src/
 ⠋ Working...
   $ grep -rn "TODO" src/
-✓ done (2.1s)
+✓ done (2.1s · 1.2k tokens · $0.003 · claude-sonnet-4-20250514)
 ```
 
+The agent can:
+- 📖 Read files and understand project structure
+- ⚡ Run commands to gather information
+- ✏️ Edit code across multiple files
+- 🔍 Debug errors using your recent shell output as context
+
 ### Reverse to pi TUI
 
-Type `pi` with no arguments to open the full pi TUI. Your conversation carries over — the AI remembers everything from the current session. When you exit pi, you're back in pish.
+Type `pi` with no arguments to open the full [pi](https://github.com/badlogic/pi-mono) TUI. Your conversation carries over — the AI remembers everything from the current session. When you exit, you're back in pish with the updated session.
+
+> **Tip:** `pi` with any arguments (e.g. `pi --help`, `pi some-file.txt`) is passed straight through to the original pi binary — only bare `pi` activates the session handoff. You can also use `command pi` to bypass pish entirely.
 
 ### Control commands
 
-```
-/compact [instructions]     # compact agent context
-/model provider/model       # switch model
-/think [level]              # set thinking level (none/low/medium/high)
-```
+| Command | Description | Example |
+|---------|-------------|---------|
+| `/compact [instructions]` | Compact agent context | `/compact focus on auth` |
+| `/model [provider/model]` | Switch or query model | `/model anthropic/claude-sonnet-4-20250514` |
+| `/think [level]` | Set thinking level | `/think high` |
 
 ### Keyboard shortcuts
 
 | Key | Action |
 |-----|--------|
-| `Ctrl+C` | Abort running agent |
-| `Ctrl+L` | Clear screen + reset context + reset session |
+| <kbd>Ctrl</kbd>+<kbd>C</kbd> | Abort running agent |
+| <kbd>Ctrl</kbd>+<kbd>L</kbd> | Clear screen + reset context + reset session |
+
+## ⚙️ Configuration
 
-## Configuration
+Configuration priority: **CLI args > Environment variables > Defaults**
 
-Priority: **CLI > ENV > defaults**
+### CLI Options
 
 ```
 pish [options] [shell]
 
+Arguments:
+  shell               bash, zsh, or full path (default: $SHELL or bash)
+
 Options:
   -s, --shell <name>  Shell name or path
   --pi <path>         Path to pi binary
@@ -105,25 +164,161 @@ Options:
   -h, --help          Show help
 ```
 
-| Environment variable | Description | Default |
-|---------------------|-------------|---------|
+### Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
 | `PISH_SHELL` | Shell name or path | `$SHELL` or `bash` |
 | `PISH_PI` | Path to pi binary | `pi` |
 | `PISH_MAX_CONTEXT` | Max history entries sent to AI | `20` |
-| `PISH_HEAD_LINES` | Output head lines kept | `50` |
-| `PISH_TAIL_LINES` | Output tail lines kept | `30` |
-| `PISH_LINE_WIDTH` | Max chars per line | `512` |
-| `PISH_TOOL_LINES` | Max tool result lines shown | `10` |
+| `PISH_HEAD_LINES` | Output head lines kept per command | `50` |
+| `PISH_TAIL_LINES` | Output tail lines kept per command | `30` |
+| `PISH_LINE_WIDTH` | Max chars per output line | `512` |
+| `PISH_TOOL_LINES` | Max tool result lines displayed | `10` |
 | `PISH_LOG` | Event log (`stderr` or file path) | off |
 | `PISH_DEBUG` | Debug log file path | off |
 | `PISH_NO_BANNER` | Hide startup banner (set to `1`) | off |
 
+## 🏗️ How It Works
+
+pish runs your shell inside a PTY with lightweight hooks injected via a temporary rcfile. An [OSC 9154](https://en.wikipedia.org/wiki/ANSI_escape_code#OSC_(Operating_System_Command)_sequences) signal protocol embedded in the terminal data stream lets pish detect shell events — command execution, prompts, errors — without interfering with normal operation.
+
+```
+┌─────────────────────────────────────────────────────┐
+│  Terminal (stdin/stdout)                            │
+│       ▲                                             │
+│       │                                             │
+│       ▼                                             │
+│  ┌─────────────────────────────────────────────┐    │
+│  │  pish (Node.js)                             │    │
+│  │                                             │    │
+│  │  ┌──────────┐   ┌──────────┐                │    │
+│  │  │ Recorder │◄──│ OSC      │  PTY data      │    │
+│  │  │ (context)│   │ Parser   │◄──────────┐    │    │
+│  │  └────┬─────┘   └──────────┘           │    │    │
+│  │       │                                │    │    │
+│  │       ▼                                │    │    │
+│  │  ┌──────────┐                  ┌───────┴─┐  │    │
+│  │  │ Agent    │  pi --mode rpc   │ PTY     │  │    │
+│  │  │ Manager  │◄────────────────►│ bash/zsh│  │    │
+│  │  └────┬─────┘   (on demand)    │ +hooks  │  │    │
+│  │       │                        └────┬────┘  │    │
+│  │       ▼                             │       │    │
+│  │  ┌──────────┐                  ┌────┴────┐  │    │
+│  │  │ Renderer │──► stderr        │ FIFO    │  │    │
+│  │  │ (pi-tui) │    (AI output)   │ (sync)  │  │    │
+│  │  └──────────┘                  └─────────┘  │    │
+│  └─────────────────────────────────────────────┘    │
+└─────────────────────────────────────────────────────┘
+```
+
+### Key design decisions
+
+| Decision | Rationale |
+|----------|-----------|
+| Agent output goes to **stderr** | Never contaminates shell stdout — pipes and redirections work perfectly |
+| Normal commands **never touch FIFO** | Zero latency for regular shell operations |
+| Agent spawns **on demand** | No background process until you need it — instant startup |
+| Session persists **across agent restarts** | Your conversation context survives `kill` and `reverse` |
+| Context is **automatically truncated** | Smart head/tail truncation keeps AI context relevant without overwhelming tokens |
+
+### The four signal paths
+
+| Path | Trigger | What happens |
+|------|---------|-------------|
+| **Normal command** | `ls`, `git status`, etc. | Flows through PTY untouched. Recorder captures output for context. |
+| **AI agent** | Unknown command like `fix the bug` | CNF fires → FIFO blocks shell → agent runs → PROCEED unblocks |
+| **Reverse pi** | `pi` (no args) | Switches to full pi TUI with session handoff, returns to pish on exit |
+| **Empty line** | Just pressing Enter | No-op, no context captured |
 
-## Known limitations
+## 🧪 Testing
 
-- **Bash keywords** — `do something` or `if something` triggers a syntax error instead of the AI agent. Rephrase as `please do something`.
+pish has a comprehensive three-layer test suite:
+
+```bash
+# Run everything
+bash test/run_tests.sh
+
+# Unit tests only (~60s, 104 tests covering osc/strip/recorder/agent/config)
+npm run test:unit
+
+# Fast scenario tests (~10s, no pi binary needed)
+bash test/run_tests.sh fast
+
+# Slow scenario tests (~2min, needs real pi + LLM)
+bash test/run_tests.sh slow
+
+# Single test
+bash test/run_tests.sh bash normal_cmd
+```
+
+| Layer | Tests | What it covers | Requires pi? |
+|-------|-------|---------------|-------------|
+| **Unit** | 104 | OSC parsing, ANSI stripping, recorder logic, agent RPC, config loading | No |
+| **Fast scenarios** | 10 × bash/zsh + 3 edge | Shell lifecycle, context capture, truncation, nesting, control commands | No |
+| **Slow scenarios** | 6 × bash/zsh | Real agent interaction, abort, reverse, model switching | Yes |
+
+Scenario tests use `expect` scripts to drive real shell sessions, produce JSONL event logs, and verify with assertion-based checks.
+
+## 🤝 Contributing
+
+Contributions are welcome! Here's how to get started:
+
+```bash
+git clone https://github.com/dacapoday/pish.git
+cd pish
+npm install
+npm run build
+```
+
+### Development workflow
+
+```bash
+npm run dev           # Watch mode (tsc --watch)
+npm run lint          # Biome lint + format check
+npm run test:unit     # Quick unit tests
+bash test/run_tests.sh fast   # Fast scenario tests
+```
+
+### Project structure
+
+```
+src/
+├── main.ts        # Entry point: bootstrap + I/O wiring
+├── app.ts         # Core state machine + event dispatch
+├── config.ts      # Unified config (CLI + ENV + defaults)
+├── recorder.ts    # PTY stream → context entries
+├── agent.ts       # pi RPC process management
+├── hooks.ts       # bash/zsh rcfile generation
+├── render.ts      # Agent UI → stderr (Markdown, spinner, status)
+├── osc.ts         # OSC 9154 signal parser
+├── session.ts     # pi session file discovery
+├── theme.ts       # ANSI colors + Markdown theme
+├── vterm.ts       # xterm headless prompt replay
+├── strip.ts       # ANSI stripping + truncation
+└── log.ts         # JSON event logging
+```
+
+Before submitting a PR, please:
+1. Run `npm run lint` to ensure code style
+2. Run `bash test/run_tests.sh fast` to verify nothing is broken
+3. Update documentation if behavior changes
+
+## 📋 Known Limitations
+
+- **Bash keywords** — `do something` or `if something` triggers a bash syntax error instead of the AI agent. Rephrase as `please do something`.
 - **CNF returns 0** — `$?` after an agent run is always 0, not 127.
+- **Reverse context** — When switching to pi TUI, shell context history is not transferred (only the agent session carries over).
+- **bash 4.4+ required** — macOS ships bash 3.2; install a newer version via `brew install bash`.
 
-## License
+## 📄 License
 
 [MIT](LICENSE) © [dacapoday](https://github.com/dacapoday)
+
+---
+
+<div align="center">
+
+**[⬆ Back to top](#pish)**
+
+</div>

package/dist/agent.js

@@ -34,19 +34,19 @@ function toRpcResponse(obj) {
 export class AgentManager {
     proc = null;
     buf = '';
-    cb = null;
+    _onEvent = null;
     _running = false;
     _submitted = false;
     startTime = 0;
     lastUsage = null;
-    piPath;
+    config;
     pendingRpc = new Map();
-    /** Current session file path. Maintained by pish across agent process restarts. */
-    sessionFile;
-    /** Crash info (in-memory), displayed on next enterAgentMode */
-    crashInfo;
-    constructor(piPath = 'pi') {
-        this.piPath = piPath;
+    /** Session file path. Maintained by pish across agent process restarts. */
+    _sessionFile;
+    /** Crash info (in-memory), displayed on next enterAgentMode. */
+    _crashInfo;
+    constructor(config) {
+        this.config = config;
     }
     get running() {
         return this._running;
@@ -56,18 +56,18 @@ export class AgentManager {
         return this.proc !== null && !this.proc.killed;
     }
     onEvent(cb) {
-        this.cb = cb;
+        this._onEvent = cb;
     }
     /** Ensure the pi process is alive (lazy spawn). */
     ensureRunning() {
         if (this.proc && !this.proc.killed)
             return;
         const args = ['--mode', 'rpc'];
-        if (this.sessionFile) {
-            args.push('--session', this.sessionFile);
+        if (this._sessionFile) {
+            args.push('--session', this._sessionFile);
         }
         log('agent_spawn', { args });
-        this.proc = spawn(this.piPath, args, {
+        this.proc = spawn(this.config.piPath, args, {
             stdio: ['pipe', 'pipe', 'pipe'],
             env: { ...process.env },
         });
@@ -125,7 +125,7 @@ export class AgentManager {
                 code !== 0 &&
                 signal !== 'SIGTERM' &&
                 signal !== 'SIGKILL') {
-                this.crashInfo = `agent process exited unexpectedly (code ${code})`;
+                this._crashInfo = `agent process exited unexpectedly (code ${code})`;
             }
         });
     }
@@ -167,6 +167,7 @@ export class AgentManager {
                 this.emitEvent({ type: 'turn_end' });
                 break;
             case 'message_end': {
+                // Stash per-message usage as fallback — agent_end may lack messages[]
                 const msg = obj.message;
                 if (msg?.role === 'assistant' && msg.usage) {
                     const u = msg.usage;
@@ -262,7 +263,10 @@ export class AgentManager {
             // toolcall_start/delta/end handled by tool_execution_* events
         }
     }
-    /** Aggregate usage from agent_end messages array. */
+    /**
+     * Aggregate usage from agent_end.messages[]. Falls back to lastUsage
+     * (stashed from message_end) if messages array is absent or empty.
+     */
     aggregateUsage(agentEnd) {
         const messages = agentEnd.messages;
         if (!Array.isArray(messages)) {
@@ -309,7 +313,7 @@ export class AgentManager {
         };
     }
     emitEvent(event) {
-        this.cb?.(event);
+        this._onEvent?.(event);
     }
     /** Submit a prompt to the agent. */
     submit(message) {
@@ -332,15 +336,9 @@ export class AgentManager {
         const cmd = `${JSON.stringify({ type: 'abort' })}\n`;
         this.proc.stdin.write(cmd);
     }
-    /** Send an RPC command (fire-and-forget). */
-    rpc(command) {
-        this.ensureRunning();
-        if (!this.proc?.stdin?.writable)
-            return;
-        this.proc.stdin.write(`${JSON.stringify(command)}\n`);
-    }
     /** Send an RPC command and wait for the matching response. */
-    async rpcWait(command, timeoutMs = 30000) {
+    async rpcWait(command, timeoutMs) {
+        const timeout = timeoutMs ?? this.config.rpcTimeout;
         this.ensureRunning();
         if (!this.proc?.stdin?.writable) {
             return {
@@ -355,7 +353,7 @@ export class AgentManager {
                 if (this.pendingRpc.delete(id)) {
                     resolve({ type: 'response', success: false, error: 'RPC timeout' });
                 }
-            }, timeoutMs);
+            }, timeout);
             this.pendingRpc.set(id, { resolve, timer });
             this.proc.stdin.write(`${JSON.stringify({ ...command, id })}\n`);
         });
@@ -375,7 +373,7 @@ export class AgentManager {
         if (this.proc && !this.proc.killed) {
             const p = this.proc;
             p.kill('SIGTERM');
-            // Escalate to SIGKILL if process doesn't exit within 2s
+            // Escalate to SIGKILL if process doesn't exit in time
             const forceKill = setTimeout(() => {
                 try {
                     p.kill('SIGKILL');
@@ -383,16 +381,31 @@ export class AgentManager {
                 catch {
                     /* already exited */
                 }
-            }, 2000);
+            }, this.config.killTimeout);
             forceKill.unref(); // Don't prevent Node from exiting
             this.proc = null;
         }
         this._running = false;
         this._submitted = false;
     }
+    get sessionFile() {
+        return this._sessionFile;
+    }
+    set sessionFile(path) {
+        this._sessionFile = path;
+    }
+    /**
+     * Consume crash info — returns the stored message and clears it.
+     * Designed for one-time display on next enterAgentMode.
+     */
+    consumeCrashInfo() {
+        const info = this._crashInfo;
+        this._crashInfo = undefined;
+        return info;
+    }
     /** Kill process + clear session (full reset via Ctrl+L). */
     reset() {
         this.kill();
-        this.sessionFile = undefined;
+        this._sessionFile = undefined;
     }
 }

package/dist/app.js

@@ -6,10 +6,10 @@
  * and FIFO responses. Created by main.ts after all resources are ready.
  */
 import * as fs from 'node:fs';
-import * as os from 'node:os';
 import * as path from 'node:path';
 import { closeLog, log } from './log.js';
 import { printBanner, printControl, printControlResult, printExit, printNotice, StreamRenderer, startSpinner, } from './render.js';
+import { findLatestSession } from './session.js';
 // ═══════════════════════════════════════
 // Pure helpers (module-level, no `this`)
 // ═══════════════════════════════════════
@@ -32,55 +32,6 @@ function formatContext(entries) {
     })
         .join('\n\n');
 }
-/** pi agent directory, respects PI_CODING_AGENT_DIR env var. */
-function getAgentDir() {
-    const envDir = process.env.PI_CODING_AGENT_DIR;
-    if (envDir) {
-        if (envDir === '~')
-            return os.homedir();
-        if (envDir.startsWith('~/'))
-            return os.homedir() + envDir.slice(1);
-        return envDir;
-    }
-    return path.join(os.homedir(), '.pi', 'agent');
-}
-/** CWD encoding rule, matching pi's getDefaultSessionDir. */
-function cwdToSessionSubdir(cwd) {
-    return `--${cwd.replace(/^[\/\\]/, '').replace(/[\/\\:]/g, '-')}--`;
-}
-/**
- * Find the latest session file in the CWD session directory with mtime > since.
- */
-async function findLatestSession(since, debug) {
-    const cwdSessionDir = path.join(getAgentDir(), 'sessions', cwdToSessionSubdir(process.cwd()));
-    let files;
-    try {
-        files = await fs.promises.readdir(cwdSessionDir);
-    }
-    catch {
-        return null; // directory doesn't exist
-    }
-    let latest = null;
-    for (const file of files) {
-        if (!file.endsWith('.jsonl'))
-            continue;
-        try {
-            const filePath = path.join(cwdSessionDir, file);
-            const fstat = await fs.promises.stat(filePath);
-            const mtime = fstat.mtimeMs;
-            if (mtime > since && (!latest || mtime > latest.mtime)) {
-                latest = { path: filePath, mtime };
-            }
-        }
-        catch {
-            debug('findLatestSession: stat error for', file);
-        }
-    }
-    return latest?.path ?? null;
-}
-// ═══════════════════════════════════════
-// App
-// ═══════════════════════════════════════
 export class App {
     // ── Injected dependencies ──
     cfg;
@@ -95,12 +46,8 @@ export class App {
     // ── FIFO ──
     fifoFd = null;
     cleaned = false;
-    // ── Agent mode state ──
-    mode = 'normal';
-    agentCmd = '';
-    agentStartTime = 0;
-    stdinBuffer = [];
-    renderer = null;
+    // ── Agent mode (null = normal) ──
+    agentSession = null;
     // ── Reverse session recovery ──
     sessionEpoch = Date.now();
     reverseStartTime = 0;
@@ -114,8 +61,9 @@ export class App {
         this.tmpDir = infra.tmpDir;
         this.rcPath = infra.rcPath;
         // Open debug log file (same file shell hooks append to)
-        const debugPath = process.env.PISH_DEBUG;
-        this.debugFd = debugPath ? fs.openSync(debugPath, 'a') : null;
+        this.debugFd = deps.cfg.debugPath
+            ? fs.openSync(deps.cfg.debugPath, 'a')
+            : null;
         // Wire internal event handlers
         this.agent.onEvent((event) => this.onAgentEvent(event));
         this.recorder.onEvent((evt) => this.onRecorderEvent(evt));
@@ -132,19 +80,19 @@ export class App {
     onPtyExit(code) {
         this.debugLog('PTY exited, code:', code);
         printExit();
-        log('exit', { context_count: this.recorder.context.length, code });
+        log('exit', { context_count: this.recorder.contextCount, code });
         closeLog();
         this.cleanup();
         process.exit(code);
     }
     /** Terminal stdin data → mode routing. */
     onStdin(data) {
-        if (this.mode === 'agent') {
+        if (this.agentSession) {
             if (data.length === 1 && data[0] === 0x03) {
                 this.abortAgent();
             }
             else {
-                this.stdinBuffer.push(Buffer.from(data));
+                this.agentSession.stdinBuffer.push(Buffer.from(data));
             }
             return;
         }
@@ -163,6 +111,7 @@ export class App {
     /** Terminal resized. */
     onResize(cols, rows) {
         this.pty.resize(cols, rows);
+        this.recorder.updateSize(cols, rows);
     }
     /** Cleanup all resources. Public — called by signal handlers in main.ts. */
     cleanup() {
@@ -212,16 +161,16 @@ export class App {
     // Agent event handler
     // ═══════════════════════════════════════
     onAgentEvent(event) {
-        this.renderer?.handleEvent(event);
-        if (event.type === 'agent_done' && this.mode === 'agent') {
+        this.agentSession?.renderer.handleEvent(event);
+        if (event.type === 'agent_done' && this.agentSession) {
             log('agent_done', {
-                cmd: this.agentCmd,
-                duration_ms: Date.now() - this.agentStartTime,
+                cmd: this.agentSession.cmd,
+                duration_ms: Date.now() - this.agentSession.startTime,
             });
             this.exitAgentMode();
         }
-        if (event.type === 'agent_error' && this.mode === 'agent') {
-            log('agent_error', { cmd: this.agentCmd, error: event.error });
+        if (event.type === 'agent_error' && this.agentSession) {
+            log('agent_error', { cmd: this.agentSession.cmd, error: event.error });
             this.exitAgentMode();
         }
     }
@@ -235,14 +184,18 @@ export class App {
                 this.fifoFd = fs.openSync(this.fifoPath, 'w');
                 this.debugLog('FIFO write fd opened');
                 log('shell_ready', { pid: this.pty.pid });
-                printBanner(this.cfg);
+                if (!this.cfg.noBanner) {
+                    printBanner(this.cfg.version, this.cfg.shell, {
+                        noAgent: this.cfg.noAgent,
+                    });
+                }
                 break;
             case 'context':
                 log('context', {
                     prompt: evt.entry.prompt,
                     output: evt.entry.output,
                     rc: evt.entry.rc,
-                    kept: this.recorder.context.length,
+                    kept: this.recorder.contextCount,
                 });
                 break;
             case 'context_skip':
@@ -271,19 +224,21 @@ export class App {
     // Agent mode transitions
     // ═══════════════════════════════════════
     enterAgentMode(cmd) {
-        this.mode = 'agent';
-        this.agentCmd = cmd;
-        this.agentStartTime = Date.now();
-        this.stdinBuffer = [];
         this.debugLog('enterAgentMode:', cmd);
         const entries = this.recorder.drain();
         log('agent', { cmd, context_count: entries.length });
-        this.renderer = new StreamRenderer(this.cfg.toolResultLines);
-        if (this.agent.crashInfo) {
-            printNotice(this.agent.crashInfo);
-            this.agent.crashInfo = undefined;
+        const renderer = new StreamRenderer(this.cfg.toolResultLines, this.cfg.spinnerInterval);
+        this.agentSession = {
+            cmd,
+            startTime: Date.now(),
+            stdinBuffer: [],
+            renderer,
+        };
+        const crashInfo = this.agent.consumeCrashInfo();
+        if (crashInfo) {
+            printNotice(crashInfo);
         }
-        this.renderer.showSpinner();
+        renderer.showSpinner();
         let message = cmd;
         const ctx = formatContext(entries);
         if (ctx) {
@@ -292,15 +247,15 @@ export class App {
         this.agent.submit(message);
     }
     exitAgentMode() {
-        this.debugLog('exitAgentMode, stdinBuffer:', this.stdinBuffer.length, 'chunks');
-        this.mode = 'normal';
-        this.renderer = null;
+        const session = this.agentSession;
+        this.debugLog('exitAgentMode, stdinBuffer:', session.stdinBuffer.length, 'chunks');
+        this.agentSession = null;
         this.fifoWrite('PROCEED');
         // Request state to get session file (for subsequent reverse).
         // Only if agent process is alive — don't respawn after crash.
         if (this.agent.alive) {
             this.agent
-                .rpcWait({ type: 'get_state' }, 5000)
+                .rpcWait({ type: 'get_state' })
                 .then((response) => {
                 if (response.success && response.data?.sessionFile) {
                     this.agent.sessionFile = response.data.sessionFile;
@@ -310,28 +265,25 @@ export class App {
                 log('get_state_error', { error: String(err) });
             });
         }
-        const buffered = this.stdinBuffer;
-        this.stdinBuffer = [];
-        if (buffered.length > 0) {
+        if (session.stdinBuffer.length > 0) {
             setTimeout(() => {
-                for (const chunk of buffered) {
+                for (const chunk of session.stdinBuffer) {
                     this.pty.write(chunk.toString());
                 }
-                this.debugLog('replayed', buffered.length, 'stdin chunks');
-            }, 50);
+                this.debugLog('replayed', session.stdinBuffer.length, 'stdin chunks');
+            }, this.cfg.stdinReplayDelay);
         }
     }
     abortAgent() {
         this.debugLog('abortAgent');
+        const session = this.agentSession;
         this.agent.abort();
-        this.renderer?.printInterrupted();
+        session.renderer.printInterrupted();
         log('agent_abort', {
-            cmd: this.agentCmd,
-            duration_ms: Date.now() - this.agentStartTime,
+            cmd: session.cmd,
+            duration_ms: Date.now() - session.startTime,
         });
-        this.mode = 'normal';
-        this.renderer = null;
-        this.stdinBuffer = [];
+        this.agentSession = null;
         this.fifoWrite('PROCEED');
     }
     // ═══════════════════════════════════════
@@ -373,9 +325,9 @@ export class App {
         const arg = parts.slice(1).join(' ');
         switch (name) {
             case '/compact': {
-                const stopSpinner = startSpinner('Compacting...');
+                const stopSpinner = startSpinner('Compacting...', this.cfg.spinnerInterval);
                 try {
-                    return await this.agent.rpcWait({ type: 'compact', ...(arg ? { customInstructions: arg } : {}) }, 60000);
+                    return await this.agent.rpcWait({ type: 'compact', ...(arg ? { customInstructions: arg } : {}) }, this.cfg.compactTimeout);
                 }
                 finally {
                     stopSpinner();
@@ -383,7 +335,9 @@ export class App {
             }
             case '/model': {
                 if (!arg) {
-                    const state = await this.agent.rpcWait({ type: 'get_state' }, 5000);
+                    // Query current model via get_state, then wrap as set_model response
+                    // to reuse printControlResult's existing set_model rendering.
+                    const state = await this.agent.rpcWait({ type: 'get_state' });
                     if (state.success && state.data?.model) {
                         const m = state.data.model;
                         const prov = m.provider;
@@ -411,15 +365,19 @@ export class App {
                         type: 'set_model',
                         provider: arg.slice(0, slashIdx),
                         modelId: arg.slice(slashIdx + 1),
-                    }, 10000);
+                    });
                 }
                 else {
-                    return await this.agent.rpcWait({ type: 'set_model', provider: '', modelId: arg }, 10000);
+                    return await this.agent.rpcWait({
+                        type: 'set_model',
+                        provider: '',
+                        modelId: arg,
+                    });
                 }
             }
             case '/think': {
                 const level = arg || 'medium';
-                return await this.agent.rpcWait({ type: 'set_thinking_level', level }, 5000);
+                return await this.agent.rpcWait({ type: 'set_thinking_level', level });
             }
             default:
                 return null;
@@ -435,7 +393,7 @@ export class App {
         this.reverseStartTime = Date.now();
         this.preReverseSessionFile = sessionFile;
         log('reverse', {
-            context_count: this.recorder.context.length,
+            context_count: this.recorder.contextCount,
             session: sessionFile || null,
         });
         if (sessionFile) {

package/dist/config.js

@@ -11,11 +11,24 @@ const require = createRequire(import.meta.url);
 // ── Defaults ──
 export const DEFAULTS = {
     shell: 'bash',
+    // Context truncation
     maxContext: 20,
     headLines: 50,
     tailLines: 30,
     lineWidth: 512,
+    // Rendering
     toolResultLines: 10,
+    // Timeouts (ms)
+    rpcTimeout: 30_000, // default RPC response timeout
+    compactTimeout: 60_000, // /compact needs LLM generation — much longer
+    killTimeout: 2_000, // SIGTERM → SIGKILL escalation wait
+    stdinReplayDelay: 50, // wait for shell readline ready after agent exit
+    // Terminal defaults (PTY spawn + vterm replay fallback)
+    defaultCols: 120,
+    defaultRows: 30,
+    // Internal limits
+    compactBufferThreshold: 100_000, // recorder fullBuffer trim threshold (bytes)
+    spinnerInterval: 80, // spinner animation frame interval (ms)
 };
 // ── Version ──
 function readVersion() {
@@ -182,6 +195,16 @@ export function loadConfig() {
         tailLines: envInt('PISH_TAIL_LINES', DEFAULTS.tailLines),
         lineWidth: envInt('PISH_LINE_WIDTH', DEFAULTS.lineWidth),
         toolResultLines: envInt('PISH_TOOL_LINES', DEFAULTS.toolResultLines),
+        rpcTimeout: DEFAULTS.rpcTimeout,
+        compactTimeout: DEFAULTS.compactTimeout,
+        killTimeout: DEFAULTS.killTimeout,
+        stdinReplayDelay: DEFAULTS.stdinReplayDelay,
+        defaultCols: DEFAULTS.defaultCols,
+        defaultRows: DEFAULTS.defaultRows,
+        compactBufferThreshold: DEFAULTS.compactBufferThreshold,
+        spinnerInterval: DEFAULTS.spinnerInterval,
+        debugPath: process.env.PISH_DEBUG || null,
+        logTarget: process.env.PISH_LOG || null,
         noBanner: process.env.PISH_NO_BANNER === '1',
     };
 }

package/dist/log.js

@@ -1,16 +1,15 @@
 /**
  * Structured JSON event log.
  *
- * Controlled by PISH_LOG env var:
- *   unset          → no output
+ * Target values (from Config.logTarget):
+ *   null           → no output
  *   "1" | "stderr" → stderr
  *   file path      → append to file
  */
 import * as fs from 'node:fs';
 let logFd = null;
 let logToStderr = false;
-export function initLog() {
-    const target = process.env.PISH_LOG;
+export function initLog(target) {
     if (!target)
         return;
     if (target === '1' || target === 'stderr') {

package/dist/main.js

@@ -26,22 +26,15 @@ if (process.env.PISH_PID) {
 // Bootstrap
 // ═══════════════════════════════════════
 const cfg = loadConfig();
-initLog();
+initLog(cfg.logTarget);
 // ── Infrastructure ──
 const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pish-'));
 const fifoPath = path.join(tmpDir, 'fifo');
 execFileSync('mkfifo', [fifoPath]);
 const rcPath = generateRcfile({ shell: cfg.shell, fifoPath, tmpDir });
 // ── Objects ──
-const recorder = new Recorder({
-    maxContext: cfg.maxContext,
-    truncate: {
-        headLines: cfg.headLines,
-        tailLines: cfg.tailLines,
-        maxLineWidth: cfg.lineWidth,
-    },
-});
-const agent = new AgentManager(cfg.piPath);
+const recorder = new Recorder(cfg);
+const agent = new AgentManager(cfg);
 // ── PTY ──
 const shellArgs = cfg.shell === 'bash' ? ['--rcfile', rcPath, '-i'] : ['-i'];
 const env = {
@@ -56,8 +49,8 @@ if (cfg.shell === 'zsh') {
 }
 const ptyProcess = pty.spawn(cfg.shellPath, shellArgs, {
     name: 'xterm-256color',
-    cols: process.stdout.columns || 120,
-    rows: process.stdout.rows || 30,
+    cols: process.stdout.columns || cfg.defaultCols,
+    rows: process.stdout.rows || cfg.defaultRows,
     cwd: process.cwd(),
     env,
 });
@@ -70,9 +63,9 @@ ptyProcess.onData((data) => app.onPtyData(data));
 ptyProcess.onExit(({ exitCode }) => app.onPtyExit(exitCode ?? 0));
 process.stdin.setRawMode?.(true);
 process.stdin.resume();
-process.stdin.on('data', (data) => app.onStdin(data));
+process.stdin.on('data', (data) => app.onStdin(Buffer.from(data)));
 process.stdout.on('resize', () => {
-    app.onResize(process.stdout.columns || 120, process.stdout.rows || 30);
+    app.onResize(process.stdout.columns || cfg.defaultCols, process.stdout.rows || cfg.defaultRows);
 });
 // ═══════════════════════════════════════
 // Signals

package/dist/recorder.js

@@ -9,12 +9,8 @@
  */
 import { log } from './log.js';
 import { OscParser } from './osc.js';
-import { DEFAULT_TRUNCATE, isAltScreen, stripAnsi, truncateLines, } from './strip.js';
+import { isAltScreen, stripAnsi, truncateLines } from './strip.js';
 import { vtermReplay } from './vterm.js';
-const DEFAULT_OPTIONS = {
-    maxContext: 20,
-    truncate: DEFAULT_TRUNCATE,
-};
 export class Recorder {
     /**
      * Complete clean PTY data (OSC 9154 stripped).
@@ -29,13 +25,27 @@ export class Recorder {
     reverseInProgress = false;
     gotFirstD = false;
     pending = Promise.resolve();
+    /** Current terminal dimensions (updated via updateSize). */
+    cols;
+    rows;
     opts;
     oscParser = new OscParser();
     /** Committed context entries. */
     context = [];
     _onEvent = null;
     constructor(opts) {
-        this.opts = { ...DEFAULT_OPTIONS, ...opts };
+        this.opts = opts;
+        this.cols = opts.defaultCols;
+        this.rows = opts.defaultRows;
+    }
+    /** Number of committed context entries. */
+    get contextCount() {
+        return this.context.length;
+    }
+    /** Update terminal dimensions (called on resize). */
+    updateSize(cols, rows) {
+        this.cols = cols;
+        this.rows = rows;
     }
     onEvent(cb) {
         this._onEvent = cb;
@@ -121,12 +131,16 @@ export class Recorder {
             const cRel = snap.cAbs - snap.segStart;
             const promptRaw = segData.slice(0, cRel);
             const outputRaw = segData.slice(cRel);
-            promptText = await vtermReplay(promptRaw);
+            promptText = await vtermReplay(promptRaw, this.cols, this.rows);
             if (isAltScreen(outputRaw)) {
                 outputText = '[full-screen app]';
             }
             else {
-                outputText = truncateLines(stripAnsi(outputRaw).trim(), this.opts.truncate);
+                outputText = truncateLines(stripAnsi(outputRaw).trim(), {
+                    headLines: this.opts.headLines,
+                    tailLines: this.opts.tailLines,
+                    lineWidth: this.opts.lineWidth,
+                });
             }
         }
         else {
@@ -156,7 +170,7 @@ export class Recorder {
     }
     /** Release memory periodically (fullBuffer grows indefinitely). */
     maybeCompact() {
-        if (this.segStart > 100_000) {
+        if (this.segStart > this.opts.compactBufferThreshold) {
             this.fullBuffer = this.fullBuffer.slice(this.segStart);
             if (this.cAbs !== null)
                 this.cAbs -= this.segStart;

package/dist/render.js

@@ -7,11 +7,9 @@
 import { Box, Markdown, Text, visibleWidth, } from '@mariozechner/pi-tui';
 import { bold, createMarkdownTheme, dim, TAG, theme, toolBg } from './theme.js';
 // ─── Banner / Exit / Control ───
-export function printBanner(cfg) {
-    if (cfg.noBanner)
-        return;
-    const parts = [`v${cfg.version}`, dim(cfg.shell)];
-    if (cfg.noAgent)
+export function printBanner(version, shell, flags) {
+    const parts = [`v${version}`, dim(shell)];
+    if (flags?.noAgent)
         parts.push(theme.warning('no-agent'));
     process.stderr.write(`${TAG} ${parts.join(dim(' │ '))}\n`);
 }
@@ -63,7 +61,7 @@ export function printNotice(msg) {
 }
 // ─── Spinner ───
 const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-export function startSpinner(label) {
+export function startSpinner(label, intervalMs) {
     let frame = 0;
     let stopped = false;
     const maxLabelCols = termWidth() - 3;
@@ -81,7 +79,7 @@ export function startSpinner(label) {
         frame++;
     };
     render();
-    const timer = setInterval(render, 80);
+    const timer = setInterval(render, intervalMs);
     return () => {
         if (stopped)
             return;
@@ -92,7 +90,7 @@ export function startSpinner(label) {
 }
 // ─── Helpers ───
 function termWidth() {
-    return process.stderr.columns || 80;
+    return process.stderr.columns || FALLBACK_TERM_WIDTH;
 }
 function flush(comp) {
     for (const line of comp.render(termWidth())) {
@@ -105,6 +103,12 @@ function shortenPath(p) {
         return `~${p.slice(home.length)}`;
     return p;
 }
+/** Max visible chars for generic tool-title arg truncation. */
+const TOOL_TITLE_MAX_CHARS = 60;
+/** Max visible chars for compaction summary. */
+const COMPACTION_SUMMARY_MAX_CHARS = 80;
+/** Default terminal width when stderr columns is unknown. */
+const FALLBACK_TERM_WIDTH = 80;
 function truncate(s, max) {
     const flat = s.replace(/\n/g, ' ');
     if (flat.length <= max)
@@ -136,7 +140,7 @@ function formatToolTitle(toolName, args) {
     }
     const keys = Object.keys(args);
     if (keys.length > 0)
-        return `${toolName} ${truncate(String(args[keys[0]]), 60)}`;
+        return `${toolName} ${truncate(String(args[keys[0]]), TOOL_TITLE_MAX_CHARS)}`;
     return toolName;
 }
 function extractResultText(result) {
@@ -240,9 +244,11 @@ export class StreamRenderer {
     mdTheme;
     pendingTools = new Map();
     toolResultLines;
-    constructor(toolResultLines = 10) {
+    spinnerInterval;
+    constructor(toolResultLines, spinnerInterval) {
         this.mdTheme = createMarkdownTheme();
         this.toolResultLines = toolResultLines;
+        this.spinnerInterval = spinnerInterval;
     }
     handleEvent(event) {
         switch (event.type) {
@@ -290,7 +296,7 @@ export class StreamRenderer {
     }
     showSpinner() {
         process.stderr.write('\x1b[?25l'); // hide cursor
-        this.stopSpinner = startSpinner('Working...');
+        this.stopSpinner = startSpinner('Working...', this.spinnerInterval);
     }
     // ─── Thinking ───
     onThinkingStart() {
@@ -352,7 +358,7 @@ export class StreamRenderer {
         this.clearSpinner();
         const title = formatToolTitle(toolName, args);
         this.pendingTools.set(toolCallId, title);
-        this.stopSpinner = startSpinner(title);
+        this.stopSpinner = startSpinner(title, this.spinnerInterval);
     }
     onToolEnd(toolCallId, _toolName, result, isError) {
         this.clearSpinner();
@@ -385,7 +391,7 @@ export class StreamRenderer {
         const reasonText = reason === 'overflow'
             ? 'Context overflow — auto-compacting...'
             : 'Auto-compacting...';
-        this.stopSpinner = startSpinner(reasonText);
+        this.stopSpinner = startSpinner(reasonText, this.spinnerInterval);
     }
     onCompactionEnd(summary, aborted, error) {
         this.clearSpinner();
@@ -396,7 +402,9 @@ export class StreamRenderer {
             process.stderr.write(`${theme.error('✗')} compaction failed: ${error}\n`);
         }
         else if (summary) {
-            const short = summary.length > 80 ? `${summary.slice(0, 77)}...` : summary;
+            const short = summary.length > COMPACTION_SUMMARY_MAX_CHARS
+                ? `${summary.slice(0, COMPACTION_SUMMARY_MAX_CHARS - 3)}...`
+                : summary;
             process.stderr.write(`${theme.accent('●')} compacted: ${theme.muted(short)}\n`);
         }
     }
@@ -437,7 +445,7 @@ export class StreamRenderer {
         }
     }
     restartSpinner() {
-        this.stopSpinner = startSpinner('Working...');
+        this.stopSpinner = startSpinner('Working...', this.spinnerInterval);
     }
     countCursorLinesFromStart(text) {
         const w = termWidth();

package/dist/session.js

@@ -0,0 +1,61 @@
+/**
+ * Session file discovery.
+ *
+ * Locates pi session files on disk. Encapsulates the path encoding
+ * convention shared with pi (getDefaultSessionDir) so that changes
+ * to session layout only affect this module.
+ *
+ * All functions are pure / side-effect-free (aside from filesystem reads).
+ */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+/** pi agent directory, respects PI_CODING_AGENT_DIR env var. */
+export function getAgentDir() {
+    const envDir = process.env.PI_CODING_AGENT_DIR;
+    if (envDir) {
+        if (envDir === '~')
+            return os.homedir();
+        if (envDir.startsWith('~/'))
+            return os.homedir() + envDir.slice(1);
+        return envDir;
+    }
+    return path.join(os.homedir(), '.pi', 'agent');
+}
+/** CWD encoding rule, matching pi's getDefaultSessionDir. */
+export function cwdToSessionSubdir(cwd) {
+    return `--${cwd.replace(/^[\/\\]/, '').replace(/[\/\\:]/g, '-')}--`;
+}
+/**
+ * Find the latest session file (.jsonl) in the CWD session directory
+ * with mtime strictly greater than `since` (epoch ms).
+ *
+ * Returns the absolute path, or null if none found.
+ */
+export async function findLatestSession(since, debug = () => { }) {
+    const cwdSessionDir = path.join(getAgentDir(), 'sessions', cwdToSessionSubdir(process.cwd()));
+    let files;
+    try {
+        files = await fs.promises.readdir(cwdSessionDir);
+    }
+    catch {
+        return null; // directory doesn't exist
+    }
+    let latest = null;
+    for (const file of files) {
+        if (!file.endsWith('.jsonl'))
+            continue;
+        try {
+            const filePath = path.join(cwdSessionDir, file);
+            const fstat = await fs.promises.stat(filePath);
+            const mtime = fstat.mtimeMs;
+            if (mtime > since && (!latest || mtime > latest.mtime)) {
+                latest = { path: filePath, mtime };
+            }
+        }
+        catch {
+            debug('findLatestSession: stat error for', file);
+        }
+    }
+    return latest?.path ?? null;
+}

package/dist/strip.js

@@ -14,11 +14,6 @@ export function isAltScreen(data) {
 export function stripAnsi(data) {
     return data.replace(ANSI_RE, '');
 }
-export const DEFAULT_TRUNCATE = {
-    headLines: 50,
-    tailLines: 30,
-    maxLineWidth: 512,
-};
 /**
  * Line-level truncation: keep head + tail lines, truncate the middle.
  * Also truncates individual long lines.
@@ -26,12 +21,12 @@ export const DEFAULT_TRUNCATE = {
  * Head > tail ratio: command output typically starts with structured info
  * (headers, column names, first results); tail preserves errors and final results.
  */
-export function truncateLines(text, opts = DEFAULT_TRUNCATE) {
+export function truncateLines(text, opts) {
     let lines = text.split('\n');
     // Per-line truncation
     lines = lines.map((line) => {
-        if (line.length > opts.maxLineWidth) {
-            return `${line.slice(0, opts.maxLineWidth)} ...`;
+        if (line.length > opts.lineWidth) {
+            return `${line.slice(0, opts.lineWidth)} ...`;
         }
         return line;
     });

package/dist/vterm.js

@@ -37,7 +37,7 @@ function getTerm(cols, rows) {
  * Replay raw PTY data and return the final displayed text.
  * Digests readline editing, ANSI color, cursor operations, alt screen, etc.
  */
-export function vtermReplay(data, cols = 120, rows = 30) {
+export function vtermReplay(data, cols, rows) {
     return new Promise((resolve) => {
         const term = getTerm(cols, rows);
         term.write(data, () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aerode/pish",
-  "version": "0.8.0",
+  "version": "0.9.2",
   "description": "A shell-first pi coding agent",
   "license": "MIT",
   "author": "dacapoday",
@@ -12,7 +12,15 @@
   "bugs": {
     "url": "https://github.com/dacapoday/pish/issues"
   },
-  "keywords": ["shell", "ai", "coding-agent", "bash", "zsh", "pi", "cli"],
+  "keywords": [
+    "shell",
+    "ai",
+    "coding-agent",
+    "bash",
+    "zsh",
+    "pi",
+    "cli"
+  ],
   "engines": {
     "node": ">=18"
   },
@@ -37,13 +45,14 @@
     "postinstall.sh"
   ],
   "dependencies": {
-    "@mariozechner/pi-tui": "^0.64.0",
+    "@mariozechner/pi-tui": "^0.65.0",
     "@xterm/headless": "^6.0.0",
     "node-pty": "^1.0.0"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.4.10",
-    "@types/node": "^22.0.0",
-    "typescript": "^5.0.0"
+    "@types/node": "^25.5.2",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.2"
   }
 }