@aerode/pish 0.8.0 → 0.9.1

package/README.md

@@ -32,7 +32,7 @@ Agent output goes to **stderr**, never contaminating your shell's stdout. Your p
 ### Install from npm
 
 ```bash
-npm install -g pish
+npm install -g @aerode/pish
 ```
 
 ### Install from source

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,16 @@ 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 +242,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 +260,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 +320,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 +330,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 +360,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 +388,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,
 });
@@ -72,7 +65,7 @@ process.stdin.setRawMode?.(true);
 process.stdin.resume();
 process.stdin.on('data', (data) => app.onStdin(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.1",
   "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"
   },