@hasna/terminal 4.3.1 → 4.3.2

package/dist/sessions-db.js

@@ -0,0 +1,240 @@
+// SQLite session database — tracks every terminal interaction
+import { SqliteAdapter } from "@hasna/cloud";
+import { existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { randomUUID } from "crypto";
+import { getTerminalDir } from "./paths.js";
+const DIR = getTerminalDir();
+const DB_PATH = process.env.HASNA_TERMINAL_DB_PATH ?? process.env.TERMINAL_DB_PATH ?? join(DIR, "sessions.db");
+let db = null;
+function getDb() {
+    if (db)
+        return db;
+    if (!existsSync(DIR))
+        mkdirSync(DIR, { recursive: true });
+    db = new SqliteAdapter(DB_PATH);
+    db.exec("PRAGMA journal_mode = WAL");
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      started_at INTEGER NOT NULL,
+      ended_at INTEGER,
+      cwd TEXT NOT NULL,
+      provider TEXT,
+      model TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS interactions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL REFERENCES sessions(id),
+      nl TEXT NOT NULL,
+      command TEXT,
+      output TEXT,
+      exit_code INTEGER,
+      tokens_used INTEGER DEFAULT 0,
+      tokens_saved INTEGER DEFAULT 0,
+      duration_ms INTEGER,
+      model TEXT,
+      cached INTEGER DEFAULT 0,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_interactions_session ON interactions(session_id);
+    CREATE INDEX IF NOT EXISTS idx_sessions_started ON sessions(started_at);
+
+    CREATE TABLE IF NOT EXISTS corrections (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      prompt TEXT NOT NULL,
+      failed_command TEXT NOT NULL,
+      error_output TEXT,
+      corrected_command TEXT NOT NULL,
+      worked INTEGER DEFAULT 1,
+      error_type TEXT,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS outputs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT,
+      command TEXT NOT NULL,
+      raw_output_path TEXT,
+      compressed_summary TEXT,
+      tokens_raw INTEGER DEFAULT 0,
+      tokens_compressed INTEGER DEFAULT 0,
+      provider TEXT,
+      model TEXT,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_corrections_prompt ON corrections(prompt);
+
+    CREATE TABLE IF NOT EXISTS feedback (
+      id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
+      message TEXT NOT NULL,
+      email TEXT,
+      category TEXT DEFAULT 'general',
+      version TEXT,
+      machine_id TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+    return db;
+}
+// ── Sessions ─────────────────────────────────────────────────────────────────
+export function createSession(cwd, provider, model) {
+    const id = randomUUID();
+    getDb().prepare("INSERT INTO sessions (id, started_at, cwd, provider, model) VALUES (?, ?, ?, ?, ?)").run(id, Date.now(), cwd, provider ?? null, model ?? null);
+    return id;
+}
+export function endSession(sessionId) {
+    getDb().prepare("UPDATE sessions SET ended_at = ? WHERE id = ?").run(Date.now(), sessionId);
+}
+export function listSessions(limit = 20) {
+    return getDb().prepare("SELECT * FROM sessions ORDER BY started_at DESC LIMIT ?").all(limit);
+}
+export function getSession(id) {
+    return getDb().prepare("SELECT * FROM sessions WHERE id = ?").get(id);
+}
+export function logInteraction(sessionId, data) {
+    const result = getDb().prepare(`INSERT INTO interactions (session_id, nl, command, output, exit_code, tokens_used, tokens_saved, duration_ms, model, cached, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(sessionId, data.nl, data.command ?? null, data.output ? data.output.slice(0, 500) : null, data.exitCode ?? null, data.tokensUsed ?? 0, data.tokensSaved ?? 0, data.durationMs ?? null, data.model ?? null, data.cached ? 1 : 0, Date.now());
+    // bun:sqlite — lastInsertRowid is a property on the statement after run()
+    const lastId = getDb().prepare("SELECT last_insert_rowid() as id").get();
+    return lastId?.id ?? 0;
+}
+export function updateInteraction(id, data) {
+    const sets = [];
+    const vals = [];
+    if (data.command !== undefined) {
+        sets.push("command = ?");
+        vals.push(data.command);
+    }
+    if (data.output !== undefined) {
+        sets.push("output = ?");
+        vals.push(data.output.slice(0, 500));
+    }
+    if (data.exitCode !== undefined) {
+        sets.push("exit_code = ?");
+        vals.push(data.exitCode);
+    }
+    if (data.tokensSaved !== undefined) {
+        sets.push("tokens_saved = ?");
+        vals.push(data.tokensSaved);
+    }
+    if (sets.length === 0)
+        return;
+    vals.push(id);
+    getDb().prepare(`UPDATE interactions SET ${sets.join(", ")} WHERE id = ?`).run(...vals);
+}
+export function getSessionInteractions(sessionId) {
+    return getDb().prepare("SELECT * FROM interactions WHERE session_id = ? ORDER BY created_at ASC").all(sessionId);
+}
+export function getSessionStats() {
+    const d = getDb();
+    const sessions = d.prepare("SELECT COUNT(*) as c FROM sessions").get();
+    const interactions = d.prepare("SELECT COUNT(*) as c, SUM(tokens_saved) as saved, SUM(tokens_used) as used FROM interactions").get();
+    const cached = d.prepare("SELECT COUNT(*) as c FROM interactions WHERE cached = 1").get();
+    const errors = d.prepare("SELECT COUNT(*) as c FROM interactions WHERE exit_code IS NOT NULL AND exit_code != 0").get();
+    const totalInteractions = interactions.c ?? 0;
+    return {
+        totalSessions: sessions.c ?? 0,
+        totalInteractions,
+        totalTokensSaved: interactions.saved ?? 0,
+        totalTokensUsed: interactions.used ?? 0,
+        cacheHitRate: totalInteractions > 0 ? (cached.c ?? 0) / totalInteractions : 0,
+        avgInteractionsPerSession: sessions.c > 0 ? totalInteractions / sessions.c : 0,
+        errorRate: totalInteractions > 0 ? (errors.c ?? 0) / totalInteractions : 0,
+    };
+}
+/** Get economy stats for a specific session */
+export function getSessionEconomy(sessionId) {
+    const d = getDb();
+    const rows = d.prepare("SELECT nl, tokens_saved, tokens_used, duration_ms FROM interactions WHERE session_id = ?").all(sessionId);
+    const tools = {};
+    let totalSaved = 0, totalUsed = 0, aiCalls = 0, totalLatency = 0, latencyCount = 0;
+    for (const r of rows) {
+        totalSaved += r.tokens_saved ?? 0;
+        totalUsed += r.tokens_used ?? 0;
+        if (r.tokens_used > 0)
+            aiCalls++;
+        if (r.duration_ms) {
+            totalLatency += r.duration_ms;
+            latencyCount++;
+        }
+        // Extract tool name from nl field: [mcp:toolname] command
+        const toolMatch = r.nl.match(/^\[mcp:(\w+)\]/);
+        const tool = toolMatch?.[1] ?? "cli";
+        if (!tools[tool])
+            tools[tool] = { calls: 0, tokensSaved: 0 };
+        tools[tool].calls++;
+        tools[tool].tokensSaved += r.tokens_saved ?? 0;
+    }
+    // Savings at consumer model rates (×5 turns before compaction)
+    const multiplied = totalSaved * 5;
+    return {
+        totalCalls: rows.length,
+        tokensSaved: totalSaved,
+        tokensUsed: totalUsed,
+        aiCalls,
+        avgLatencyMs: latencyCount > 0 ? Math.round(totalLatency / latencyCount) : 0,
+        savingsUsd: {
+            opus: (multiplied * 15) / 1_000_000,
+            sonnet: (multiplied * 3) / 1_000_000,
+            haiku: (multiplied * 0.8) / 1_000_000,
+        },
+        tools,
+    };
+}
+// ── Corrections ─────────────────────────────────────────────────────────────
+/** Record a correction: command failed, then AI retried with a better one */
+export function recordCorrection(prompt, failedCommand, errorOutput, correctedCommand, worked, errorType) {
+    getDb().prepare("INSERT INTO corrections (prompt, failed_command, error_output, corrected_command, worked, error_type, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)").run(prompt, failedCommand, errorOutput?.slice(0, 2000) ?? "", correctedCommand, worked ? 1 : 0, errorType ?? null, Date.now());
+}
+/** Find similar corrections for a prompt — used to inject as negative examples */
+export function findSimilarCorrections(prompt, limit = 5) {
+    // Simple keyword matching — extract significant words from prompt
+    const words = prompt.toLowerCase().split(/\s+/).filter(w => w.length > 3);
+    if (words.length === 0)
+        return [];
+    // Search corrections where the prompt shares keywords
+    const all = getDb().prepare("SELECT prompt, failed_command, corrected_command, error_type FROM corrections WHERE worked = 1 ORDER BY created_at DESC LIMIT 100").all();
+    return all
+        .filter(c => {
+        const cWords = c.prompt.toLowerCase().split(/\s+/);
+        const overlap = words.filter((w) => cWords.some((cw) => cw.includes(w) || w.includes(cw)));
+        return overlap.length >= Math.min(2, words.length);
+    })
+        .slice(0, limit)
+        .map(c => ({ failed_command: c.failed_command, corrected_command: c.corrected_command, error_type: c.error_type ?? "unknown" }));
+}
+// ── Output tracking ─────────────────────────────────────────────────────────
+/** Record a compressed output for audit trail */
+export function recordOutput(command, rawOutputPath, compressedSummary, tokensRaw, tokensCompressed, provider, model, sessionId) {
+    getDb().prepare("INSERT INTO outputs (session_id, command, raw_output_path, compressed_summary, tokens_raw, tokens_compressed, provider, model, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)").run(sessionId ?? null, command, rawOutputPath ?? null, compressedSummary?.slice(0, 5000) ?? "", tokensRaw, tokensCompressed, provider ?? null, model ?? null, Date.now());
+}
+/** Prune sessions and interactions older than N days */
+export function pruneSessions(olderThanDays = 90) {
+    const d = getDb();
+    const cutoff = Date.now() - (olderThanDays * 24 * 60 * 60 * 1000);
+    const oldSessions = d.prepare("SELECT id FROM sessions WHERE started_at < ?").all(cutoff);
+    if (oldSessions.length === 0)
+        return { sessionsDeleted: 0, interactionsDeleted: 0 };
+    const ids = oldSessions.map(s => s.id);
+    const placeholders = ids.map(() => "?").join(",");
+    const intResult = d.prepare(`DELETE FROM interactions WHERE session_id IN (${placeholders})`).run(...ids);
+    const sesResult = d.prepare(`DELETE FROM sessions WHERE id IN (${placeholders})`).run(...ids);
+    // Also prune old corrections and outputs
+    d.prepare("DELETE FROM corrections WHERE created_at < ?").run(cutoff);
+    d.prepare("DELETE FROM outputs WHERE created_at < ?").run(cutoff);
+    return {
+        sessionsDeleted: oldSessions.length,
+        interactionsDeleted: intResult.changes ?? 0,
+    };
+}
+/** Close the database connection */
+export function closeDb() {
+    if (db) {
+        db.close();
+        db = null;
+    }
+}

package/dist/smart-display.js

@@ -0,0 +1,286 @@
+// Smart output display — compress repetitive output into grouped patterns
+import { dirname, basename } from "path";
+/** Detect if lines look like file paths */
+function looksLikePaths(lines) {
+    if (lines.length < 3)
+        return false;
+    const pathLike = lines.filter(l => l.trim().match(/^\.?\//) || l.trim().includes("/"));
+    return pathLike.length > lines.length * 0.6;
+}
+/** Find the varying part between similar strings and create a glob pattern */
+function findPattern(items) {
+    if (items.length < 2)
+        return null;
+    const first = items[0];
+    const last = items[items.length - 1];
+    // Find common prefix
+    let prefixLen = 0;
+    while (prefixLen < first.length && prefixLen < last.length && first[prefixLen] === last[prefixLen]) {
+        prefixLen++;
+    }
+    // Find common suffix
+    let suffixLen = 0;
+    while (suffixLen < first.length - prefixLen &&
+        suffixLen < last.length - prefixLen &&
+        first[first.length - 1 - suffixLen] === last[last.length - 1 - suffixLen]) {
+        suffixLen++;
+    }
+    const prefix = first.slice(0, prefixLen);
+    const suffix = suffixLen > 0 ? first.slice(-suffixLen) : "";
+    if (prefix.length + suffix.length < first.length * 0.3)
+        return null; // too different
+    return `${prefix}*${suffix}`;
+}
+/** Group file paths by directory */
+function groupByDir(paths) {
+    const groups = new Map();
+    for (const p of paths) {
+        const dir = dirname(p.trim());
+        const file = basename(p.trim());
+        if (!groups.has(dir))
+            groups.set(dir, []);
+        groups.get(dir).push(file);
+    }
+    return groups;
+}
+/** Detect duplicate filenames across directories */
+function findDuplicates(paths) {
+    const byName = new Map();
+    for (const p of paths) {
+        const file = basename(p.trim());
+        if (!byName.has(file))
+            byName.set(file, []);
+        byName.get(file).push(dirname(p.trim()));
+    }
+    // Only return files that appear in 2+ dirs
+    const dupes = new Map();
+    for (const [file, dirs] of byName) {
+        if (dirs.length >= 2)
+            dupes.set(file, dirs);
+    }
+    return dupes;
+}
+/** Collapse node_modules paths */
+function collapseNodeModules(paths) {
+    const nodeModulesPaths = [];
+    const otherPaths = [];
+    for (const p of paths) {
+        if (p.includes("node_modules")) {
+            nodeModulesPaths.push(p);
+        }
+        else {
+            otherPaths.push(p);
+        }
+    }
+    return { nodeModulesPaths, otherPaths };
+}
+/** Smart display: compress file path output into grouped patterns */
+export function smartDisplay(lines) {
+    if (lines.length <= 5)
+        return lines;
+    // Try ls -la table compression first
+    const lsCompressed = compressLsTable(lines);
+    if (lsCompressed)
+        return lsCompressed;
+    if (!looksLikePaths(lines))
+        return compressGeneric(lines);
+    const paths = lines.map(l => l.trim()).filter(l => l);
+    const result = [];
+    // Step 1: Separate node_modules
+    const { nodeModulesPaths, otherPaths } = collapseNodeModules(paths);
+    // Step 2: Find duplicates in non-node_modules paths
+    const dupes = findDuplicates(otherPaths);
+    const handledPaths = new Set();
+    // Show duplicates first
+    for (const [file, dirs] of dupes) {
+        if (dirs.length >= 3) {
+            result.push(`  **/${file}  ×${dirs.length}`);
+            result.push(`    ${dirs.slice(0, 5).join(", ")}${dirs.length > 5 ? ` +${dirs.length - 5} more` : ""}`);
+            for (const d of dirs) {
+                handledPaths.add(`${d}/${file}`);
+            }
+        }
+    }
+    // Step 3: Group remaining by directory
+    const remaining = otherPaths.filter(p => !handledPaths.has(p.trim()));
+    const dirGroups = groupByDir(remaining);
+    for (const [dir, files] of dirGroups) {
+        if (files.length === 1) {
+            result.push(`  ${dir}/${files[0]}`);
+        }
+        else if (files.length <= 3) {
+            result.push(`  ${dir}/`);
+            for (const f of files)
+                result.push(`    ${f}`);
+        }
+        else {
+            // Try to find a pattern
+            const sorted = files.sort();
+            const pattern = findPattern(sorted);
+            if (pattern) {
+                const dateRange = collapseDateRange(sorted);
+                const rangeStr = dateRange ? ` (${dateRange})` : "";
+                result.push(`  ${dir}/${pattern}  ×${files.length}${rangeStr}`);
+            }
+            else {
+                result.push(`  ${dir}/ (${files.length} files)`);
+                // Show first 2 + count
+                result.push(`    ${sorted[0]}, ${sorted[1]}${files.length > 2 ? `, +${files.length - 2} more` : ""}`);
+            }
+        }
+    }
+    // Step 4: Collapsed node_modules summary
+    if (nodeModulesPaths.length > 0) {
+        if (nodeModulesPaths.length <= 2) {
+            for (const p of nodeModulesPaths)
+                result.push(`  ${p}`);
+        }
+        else {
+            // Group node_modules by package name
+            const nmGroups = new Map();
+            for (const p of nodeModulesPaths) {
+                // Extract package name from path: ./X/node_modules/PKG/...
+                const match = p.match(/node_modules\/(@[^/]+\/[^/]+|[^/]+)/);
+                const pkg = match ? match[1] : "other";
+                nmGroups.set(pkg, (nmGroups.get(pkg) ?? 0) + 1);
+            }
+            result.push(`  node_modules/ (${nodeModulesPaths.length} matches)`);
+            const topPkgs = [...nmGroups.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3);
+            for (const [pkg, count] of topPkgs) {
+                result.push(`    ${pkg}  ×${count}`);
+            }
+            if (nmGroups.size > 3) {
+                result.push(`    +${nmGroups.size - 3} more packages`);
+            }
+        }
+    }
+    return result;
+}
+/** Detect date range in timestamps and collapse */
+function collapseDateRange(files) {
+    const timestamps = [];
+    for (const f of files) {
+        const match = f.match(/(\d{4})-(\d{2})-(\d{2})T?(\d{2})?/);
+        if (match) {
+            const [, y, m, d, h] = match;
+            timestamps.push(new Date(`${y}-${m}-${d}T${h ?? "00"}:00:00`));
+        }
+    }
+    if (timestamps.length < 2)
+        return null;
+    timestamps.sort((a, b) => a.getTime() - b.getTime());
+    const first = timestamps[0];
+    const last = timestamps[timestamps.length - 1];
+    const fmt = (d) => `${d.getMonth() + 1}/${d.getDate()}`;
+    if (first.toDateString() === last.toDateString()) {
+        return `${fmt(first)}`;
+    }
+    return `${fmt(first)}–${fmt(last)}`;
+}
+/** Detect and compress ls -la style table output */
+function compressLsTable(lines) {
+    // Detect ls -la format: permissions size date name
+    const lsPattern = /^[dlcbps-][rwxsStT-]{9}\s+\d+\s+\S+\s+\S+\s+\S+\s+\w+\s+\d+\s+[\d:]+\s+.+$/;
+    const isLsOutput = lines.filter(l => lsPattern.test(l.trim())).length > lines.length * 0.5;
+    if (!isLsOutput)
+        return null;
+    const result = [];
+    const dirs = [];
+    const files = [];
+    let totalSize = 0;
+    for (const line of lines) {
+        const match = line.trim().match(/^([dlcbps-])[rwxsStT-]{9}\s+\d+\s+\S+\s+\S+\s+(\S+)\s+\w+\s+\d+\s+[\d:]+\s+(.+)$/);
+        if (!match) {
+            if (line.trim().startsWith("total "))
+                continue;
+            result.push(line);
+            continue;
+        }
+        const [, type, sizeStr, name] = match;
+        const size = parseInt(sizeStr) || 0;
+        totalSize += size;
+        if (type === "d") {
+            dirs.push(name);
+        }
+        else {
+            files.push({ name, size: formatSize(size) });
+        }
+    }
+    // Compact display
+    if (dirs.length > 0) {
+        result.push(`  📁 ${dirs.join("  ")}${dirs.length > 5 ? ` (+${dirs.length - 5} more)` : ""}`);
+    }
+    if (files.length <= 8) {
+        for (const f of files) {
+            result.push(`  ${f.size.padStart(6)}  ${f.name}`);
+        }
+    }
+    else {
+        // Show top 5 by size + count
+        const sorted = files.sort((a, b) => parseSize(b.size) - parseSize(a.size));
+        for (const f of sorted.slice(0, 5)) {
+            result.push(`  ${f.size.padStart(6)}  ${f.name}`);
+        }
+        result.push(`  ... +${files.length - 5} more files (${formatSize(totalSize)} total)`);
+    }
+    return result;
+}
+function formatSize(bytes) {
+    if (bytes >= 1_000_000)
+        return `${(bytes / 1_000_000).toFixed(1)}M`;
+    if (bytes >= 1_000)
+        return `${(bytes / 1_000).toFixed(1)}K`;
+    return `${bytes}B`;
+}
+function parseSize(s) {
+    const match = s.match(/([\d.]+)([BKMG])?/);
+    if (!match)
+        return 0;
+    const n = parseFloat(match[1]);
+    const unit = match[2];
+    if (unit === "K")
+        return n * 1000;
+    if (unit === "M")
+        return n * 1000000;
+    if (unit === "G")
+        return n * 1000000000;
+    return n;
+}
+/** Compress non-path generic output by deduplicating similar lines */
+function compressGeneric(lines) {
+    if (lines.length <= 10)
+        return lines;
+    const result = [];
+    let repeatCount = 0;
+    let lastPattern = "";
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Normalize: remove numbers, timestamps, hashes for pattern matching
+        const pattern = line
+            .replace(/\d{4}-\d{2}-\d{2}T[\d:.-]+Z?/g, "TIMESTAMP")
+            .replace(/\b[0-9a-f]{7,40}\b/g, "HASH")
+            .replace(/\b\d+\b/g, "N")
+            .trim();
+        if (pattern === lastPattern && i > 0) {
+            repeatCount++;
+        }
+        else {
+            if (repeatCount > 1) {
+                result.push(`  ... ×${repeatCount} similar`);
+            }
+            else if (repeatCount === 1) {
+                result.push(lines[i - 1]);
+            }
+            result.push(line);
+            lastPattern = pattern;
+            repeatCount = 0;
+        }
+    }
+    if (repeatCount > 1) {
+        result.push(`  ... ×${repeatCount} similar`);
+    }
+    else if (repeatCount === 1) {
+        result.push(lines[lines.length - 1]);
+    }
+    return result;
+}

package/dist/snapshots.js

@@ -0,0 +1,51 @@
+// Session snapshots — capture terminal state for agent context handoff
+import { loadHistory } from "./history.js";
+import { bgStatus } from "./supervisor.js";
+import { getEconomyStats, formatTokens } from "./economy.js";
+import { listRecipes } from "./recipes/storage.js";
+/** Capture a compact snapshot of the current terminal state */
+export function captureSnapshot() {
+    // Filtered env — only relevant vars, no secrets
+    const safeEnvKeys = [
+        "PATH", "HOME", "USER", "SHELL", "NODE_ENV", "PWD", "LANG",
+        "TERM", "EDITOR", "VISUAL",
+    ];
+    const env = {};
+    for (const key of safeEnvKeys) {
+        if (process.env[key])
+            env[key] = process.env[key];
+    }
+    // Running processes
+    const processes = bgStatus().map(p => ({
+        pid: p.pid,
+        command: p.command,
+        port: p.port,
+        uptime: Date.now() - p.startedAt,
+    }));
+    // Recent commands (last 10)
+    const history = loadHistory().slice(-10);
+    const recentCommands = history.map(h => ({
+        cmd: h.cmd,
+        exitCode: h.error,
+        intent: h.nl !== h.cmd ? h.nl : undefined, // user's original NL intent, not AI-generated
+    }));
+    // Project recipes
+    const recipes = listRecipes(process.cwd()).slice(0, 10).map(r => ({
+        name: r.name,
+        command: r.command,
+    }));
+    // Economy
+    const econ = getEconomyStats();
+    return {
+        cwd: process.cwd(),
+        env,
+        runningProcesses: processes,
+        recentCommands,
+        recipes,
+        economy: {
+            tokensSaved: formatTokens(econ.totalTokensSaved),
+            tokensUsed: formatTokens(econ.totalTokensUsed),
+        },
+        timestamp: Date.now(),
+    };
+}

package/dist/supervisor.js

@@ -0,0 +1,112 @@
+// Process supervisor — manages background processes for agents and humans
+import { spawn } from "child_process";
+import { createConnection } from "net";
+const processes = new Map();
+/** Auto-detect port from common commands */
+function detectPort(command) {
+    // "next dev -p 3001", "vite --port 4000", etc.
+    const portMatch = command.match(/-p\s+(\d+)|--port\s+(\d+)|PORT=(\d+)/);
+    if (portMatch)
+        return parseInt(portMatch[1] ?? portMatch[2] ?? portMatch[3]);
+    // Common defaults
+    if (/\bnext\s+dev\b/.test(command))
+        return 3000;
+    if (/\bvite\b/.test(command))
+        return 5173;
+    if (/\bnuxt\s+dev\b/.test(command))
+        return 3000;
+    if (/\bremix\s+dev\b/.test(command))
+        return 5173;
+    return undefined;
+}
+/** Start a background process */
+export function bgStart(command, cwd) {
+    const workDir = cwd ?? process.cwd();
+    const proc = spawn("/bin/zsh", ["-c", command], {
+        cwd: workDir,
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: false,
+    });
+    const meta = {
+        pid: proc.pid,
+        command,
+        cwd: workDir,
+        port: detectPort(command),
+        startedAt: Date.now(),
+        lastOutput: [],
+    };
+    const pushOutput = (d) => {
+        const lines = d.toString().split("\n").filter(l => l.trim());
+        meta.lastOutput.push(...lines);
+        // Keep last 50 lines
+        if (meta.lastOutput.length > 50) {
+            meta.lastOutput = meta.lastOutput.slice(-50);
+        }
+    };
+    proc.stdout?.on("data", pushOutput);
+    proc.stderr?.on("data", pushOutput);
+    proc.on("close", (code) => {
+        meta.exitCode = code ?? 0;
+    });
+    processes.set(proc.pid, { proc, meta });
+    return meta;
+}
+/** List all managed processes */
+export function bgStatus() {
+    const result = [];
+    for (const [pid, { proc, meta }] of processes) {
+        // Check if still alive
+        try {
+            process.kill(pid, 0);
+            result.push({ ...meta, lastOutput: meta.lastOutput.slice(-5) });
+        }
+        catch {
+            // Process is dead
+            result.push({ ...meta, exitCode: meta.exitCode ?? -1, lastOutput: meta.lastOutput.slice(-5) });
+        }
+    }
+    return result;
+}
+/** Stop a background process */
+export function bgStop(pid) {
+    const entry = processes.get(pid);
+    if (!entry)
+        return false;
+    try {
+        entry.proc.kill("SIGTERM");
+        processes.delete(pid);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Get logs for a background process */
+export function bgLogs(pid, tail = 20) {
+    const entry = processes.get(pid);
+    if (!entry)
+        return [];
+    return entry.meta.lastOutput.slice(-tail);
+}
+/** Wait for a port to be ready */
+export function bgWaitPort(port, timeoutMs = 30000) {
+    return new Promise((resolve) => {
+        const start = Date.now();
+        const check = () => {
+            if (Date.now() - start > timeoutMs) {
+                resolve(false);
+                return;
+            }
+            const sock = createConnection({ port, host: "127.0.0.1" });
+            sock.on("connect", () => {
+                sock.destroy();
+                resolve(true);
+            });
+            sock.on("error", () => {
+                sock.destroy();
+                setTimeout(check, 500);
+            });
+        };
+        check();
+    });
+}