@phren/agent 0.1.2 → 0.1.4

package/dist/commands.js

@@ -1,17 +1,10 @@
-import { estimateMessageTokens } from "./context/token-counter.js";
-import { pruneMessages } from "./context/pruner.js";
-import { listPresets, loadPreset, savePreset, deletePreset, formatPreset } from "./multi/presets.js";
-import { renderMarkdown } from "./multi/markdown.js";
-import { showModelPicker } from "./multi/model-picker.js";
-import { formatProviderList, formatModelAddHelp, addCustomModel, removeCustomModel } from "./multi/provider-manager.js";
+// Sub-module handlers
+import { helpCommand, turnsCommand, clearCommand, cwdCommand, filesCommand, costCommand, planCommand, undoCommand, contextCommand } from "./commands/info.js";
+import { sessionCommand, historyCommand, compactCommand, diffCommand, gitCommand } from "./commands/session.js";
+import { memCommand, askCommand } from "./commands/memory.js";
+import { modelCommand, providerCommand, presetCommand } from "./commands/model.js";
 const DIM = "\x1b[2m";
-const BOLD = "\x1b[1m";
-const CYAN = "\x1b[36m";
-const GREEN = "\x1b[32m";
-const RED = "\x1b[31m";
-const YELLOW = "\x1b[33m";
 const RESET = "\x1b[0m";
-const HISTORY_MAX_LINES = 5;
 export function createCommandContext(session, contextLimit) {
     return {
         session,
@@ -19,227 +12,33 @@ export function createCommandContext(session, contextLimit) {
         undoStack: [],
     };
 }
-/** Truncate text to N lines, appending [+M lines] if overflow. */
-function truncateText(text, maxLines) {
-    const lines = text.split("\n");
-    if (lines.length <= maxLines)
-        return text;
-    const overflow = lines.length - maxLines;
-    return lines.slice(0, maxLines).join("\n") + `\n${DIM}[+${overflow} lines]${RESET}`;
-}
 /**
  * Try to handle a slash command. Returns true if the input was a command.
+ * Returns a Promise<boolean> for async commands like /ask.
  */
 export function handleCommand(input, ctx) {
     const parts = input.trim().split(/\s+/);
     const name = parts[0];
     switch (name) {
-        case "/help":
-            process.stderr.write(`${DIM}Commands:
-  /help       Show this help
-  /model      Interactive model + reasoning picker
-  /model add <id>  Add a custom model
-  /model remove <id>  Remove a custom model
-  /provider   Show configured providers + auth status
-  /turns      Show turn and tool call counts
-  /clear      Clear conversation history
-  /cost       Show token usage and estimated cost
-  /plan       Show conversation plan (tool calls so far)
-  /undo       Undo last user message and response
-  /history [n|full]  Show last N messages (default 10) with rich formatting
-  /compact    Compact conversation to save context space
-  /mode       Toggle input mode (steering ↔ queue)
-  /spawn <name> <task>  Spawn a background agent
-  /agents     List running agents
-  /preset [name|save|delete|list]  Config presets
-  /exit       Exit the REPL${RESET}\n`);
-            return true;
-        case "/model": {
-            const sub = parts[1]?.toLowerCase();
-            // /model add <id> [provider=X] [context=N] [reasoning=X]
-            if (sub === "add") {
-                const modelId = parts[2];
-                if (!modelId) {
-                    process.stderr.write(formatModelAddHelp() + "\n");
-                    return true;
-                }
-                let provider = ctx.providerName ?? "openrouter";
-                let contextWindow = 128_000;
-                let reasoning = null;
-                const reasoningRange = [];
-                for (const arg of parts.slice(3)) {
-                    const [k, v] = arg.split("=", 2);
-                    if (k === "provider")
-                        provider = v;
-                    else if (k === "context")
-                        contextWindow = parseInt(v, 10) || 128_000;
-                    else if (k === "reasoning") {
-                        reasoning = v;
-                        reasoningRange.push("low", "medium", "high");
-                        if (v === "max")
-                            reasoningRange.push("max");
-                    }
-                }
-                addCustomModel(modelId, provider, { contextWindow, reasoning, reasoningRange });
-                process.stderr.write(`${GREEN}→ Added ${modelId} to ${provider}${RESET}\n`);
-                return true;
-            }
-            // /model remove <id>
-            if (sub === "remove" || sub === "rm") {
-                const modelId = parts[2];
-                if (!modelId) {
-                    process.stderr.write(`${DIM}Usage: /model remove <model-id>${RESET}\n`);
-                    return true;
-                }
-                const ok = removeCustomModel(modelId);
-                process.stderr.write(ok ? `${GREEN}→ Removed ${modelId}${RESET}\n` : `${DIM}Model "${modelId}" not found in custom models.${RESET}\n`);
-                return true;
-            }
-            // /model (no sub) — interactive picker
-            if (!ctx.providerName) {
-                process.stderr.write(`${DIM}Provider not configured. Start with --provider to set one.${RESET}\n`);
-                return true;
-            }
-            showModelPicker(ctx.providerName, ctx.currentModel, process.stdout).then((result) => {
-                if (result && ctx.onModelChange) {
-                    ctx.onModelChange(result);
-                    const reasoningLabel = result.reasoning ? ` (reasoning: ${result.reasoning})` : "";
-                    process.stderr.write(`${GREEN}→ ${result.model}${reasoningLabel}${RESET}\n`);
-                }
-                else if (result) {
-                    process.stderr.write(`${DIM}Model selected: ${result.model} — restart to apply.${RESET}\n`);
-                }
-            });
-            return true;
-        }
-        case "/provider": {
-            process.stderr.write(formatProviderList());
-            return true;
-        }
-        case "/turns": {
-            const tokens = estimateMessageTokens(ctx.session.messages);
-            const pct = ctx.contextLimit > 0 ? ((tokens / ctx.contextLimit) * 100).toFixed(1) : "?";
-            const costLine = ctx.costTracker ? `  Cost: $${ctx.costTracker.totalCost.toFixed(4)}` : "";
-            process.stderr.write(`${DIM}Turns: ${ctx.session.turns}  Tool calls: ${ctx.session.toolCalls}  ` +
-                `Messages: ${ctx.session.messages.length}  Tokens: ~${tokens} (${pct}%)${costLine}${RESET}\n`);
-            return true;
-        }
-        case "/clear":
-            ctx.session.messages.length = 0;
-            ctx.session.turns = 0;
-            ctx.session.toolCalls = 0;
-            ctx.undoStack.length = 0;
-            process.stderr.write(`${DIM}Conversation cleared.${RESET}\n`);
-            return true;
-        case "/cost": {
-            const ct = ctx.costTracker;
-            if (ct) {
-                process.stderr.write(`${DIM}Tokens — input: ${ct.inputTokens}  output: ${ct.outputTokens}  est. cost: $${ct.totalCost.toFixed(4)}${RESET}\n`);
-            }
-            else {
-                process.stderr.write(`${DIM}Cost tracking not available.${RESET}\n`);
-            }
-            return true;
-        }
-        case "/plan": {
-            const tools = [];
-            for (const msg of ctx.session.messages) {
-                if (typeof msg.content !== "string") {
-                    for (const block of msg.content) {
-                        if (block.type === "tool_use") {
-                            tools.push(block.name);
-                        }
-                    }
-                }
-            }
-            if (tools.length === 0) {
-                process.stderr.write(`${DIM}No tool calls yet.${RESET}\n`);
-            }
-            else {
-                process.stderr.write(`${DIM}Tool calls (${tools.length}): ${tools.join(" → ")}${RESET}\n`);
-            }
-            return true;
-        }
-        case "/undo": {
-            if (ctx.session.messages.length < 2) {
-                process.stderr.write(`${DIM}Nothing to undo.${RESET}\n`);
-                return true;
-            }
-            // Remove messages back to the previous user message
-            let removed = 0;
-            while (ctx.session.messages.length > 0) {
-                const last = ctx.session.messages.pop();
-                removed++;
-                if (last?.role === "user" && typeof last.content === "string")
-                    break;
-            }
-            process.stderr.write(`${DIM}Undid ${removed} messages.${RESET}\n`);
-            return true;
-        }
-        case "/history": {
-            const msgs = ctx.session.messages;
-            if (msgs.length === 0) {
-                process.stderr.write(`${DIM}No messages yet.${RESET}\n`);
-                return true;
-            }
-            const arg = parts[1];
-            const isFull = arg === "full";
-            const count = isFull ? msgs.length : Math.min(parseInt(arg, 10) || 10, msgs.length);
-            const slice = msgs.slice(-count);
-            const tokens = estimateMessageTokens(msgs);
-            const pct = ctx.contextLimit > 0 ? ((tokens / ctx.contextLimit) * 100).toFixed(1) : "?";
-            process.stderr.write(`${DIM}── History (${slice.length}/${msgs.length} messages, ~${tokens} tokens, ${pct}% context) ──${RESET}\n`);
-            for (const msg of slice) {
-                if (msg.role === "user") {
-                    if (typeof msg.content === "string") {
-                        const truncated = truncateText(msg.content, isFull ? Infinity : HISTORY_MAX_LINES);
-                        process.stderr.write(`\n${CYAN}${BOLD}You:${RESET} ${truncated}\n`);
-                    }
-                    else {
-                        // Tool results
-                        for (const block of msg.content) {
-                            if (block.type === "tool_result") {
-                                const icon = block.is_error ? `${RED}✗${RESET}` : `${GREEN}✓${RESET}`;
-                                const preview = (block.content ?? "").slice(0, 80).replace(/\n/g, " ");
-                                process.stderr.write(`${DIM}  ${icon} tool_result ${preview}${preview.length >= 80 ? "..." : ""}${RESET}\n`);
-                            }
-                            else if (block.type === "text") {
-                                process.stderr.write(`${DIM}  ${block.text.slice(0, 100)}${RESET}\n`);
-                            }
-                        }
-                    }
-                }
-                else if (msg.role === "assistant") {
-                    if (typeof msg.content === "string") {
-                        const rendered = isFull ? renderMarkdown(msg.content) : truncateText(msg.content, HISTORY_MAX_LINES);
-                        process.stderr.write(`\n${GREEN}${BOLD}Agent:${RESET}\n${rendered}\n`);
-                    }
-                    else {
-                        for (const block of msg.content) {
-                            if (block.type === "text") {
-                                const text = block.text;
-                                const rendered = isFull ? renderMarkdown(text) : truncateText(text, HISTORY_MAX_LINES);
-                                process.stderr.write(`\n${GREEN}${BOLD}Agent:${RESET}\n${rendered}\n`);
-                            }
-                            else if (block.type === "tool_use") {
-                                const tb = block;
-                                const inputPreview = JSON.stringify(tb.input).slice(0, 60);
-                                process.stderr.write(`${YELLOW}  ⚡ ${tb.name}${RESET}${DIM}(${inputPreview})${RESET}\n`);
-                            }
-                        }
-                    }
-                }
-            }
-            process.stderr.write(`${DIM}── end ──${RESET}\n`);
-            return true;
-        }
-        case "/compact": {
-            const before = ctx.session.messages.length;
-            ctx.session.messages = pruneMessages(ctx.session.messages, { contextLimit: ctx.contextLimit, keepRecentTurns: 4 });
-            const after = ctx.session.messages.length;
-            process.stderr.write(`${DIM}Compacted: ${before} → ${after} messages.${RESET}\n`);
-            return true;
-        }
+        case "/help": return helpCommand(parts, ctx);
+        case "/turns": return turnsCommand(parts, ctx);
+        case "/clear": return clearCommand(parts, ctx);
+        case "/cwd": return cwdCommand(parts, ctx);
+        case "/files": return filesCommand(parts, ctx);
+        case "/cost": return costCommand(parts, ctx);
+        case "/plan": return planCommand(parts, ctx);
+        case "/undo": return undoCommand(parts, ctx);
+        case "/context": return contextCommand(parts, ctx);
+        case "/model": return modelCommand(parts, ctx);
+        case "/provider": return providerCommand(parts, ctx);
+        case "/preset": return presetCommand(parts, ctx);
+        case "/session": return sessionCommand(parts, ctx);
+        case "/history": return historyCommand(parts, ctx);
+        case "/compact": return compactCommand(parts, ctx);
+        case "/diff": return diffCommand(parts, ctx);
+        case "/git": return gitCommand(parts, ctx);
+        case "/mem": return memCommand(parts, ctx);
+        case "/ask": return askCommand(parts, ctx);
         case "/spawn": {
             if (!ctx.spawner) {
                 process.stderr.write(`${DIM}Spawner not available. Start with --multi or --team to enable.${RESET}\n`);
@@ -275,77 +74,6 @@ export function handleCommand(input, ctx) {
             }
             return true;
         }
-        case "/preset": {
-            const sub = parts[1]?.toLowerCase();
-            if (!sub || sub === "list") {
-                const all = listPresets();
-                if (all.length === 0) {
-                    process.stderr.write(`${DIM}No presets.${RESET}\n`);
-                }
-                else {
-                    const lines = all.map((p) => `  ${formatPreset(p.name, p.preset, p.builtin)}`);
-                    process.stderr.write(`${DIM}Presets:\n${lines.join("\n")}${RESET}\n`);
-                }
-                return true;
-            }
-            if (sub === "save") {
-                // /preset save <name> [provider=X] [model=X] [permissions=X] [max-turns=N] [budget=N] [plan]
-                const presetName = parts[2];
-                if (!presetName) {
-                    process.stderr.write(`${DIM}Usage: /preset save <name> [provider=X] [model=X] [permissions=X] [max-turns=N] [budget=N] [plan]${RESET}\n`);
-                    return true;
-                }
-                const preset = {};
-                for (const arg of parts.slice(3)) {
-                    const [k, v] = arg.split("=", 2);
-                    if (k === "provider")
-                        preset.provider = v;
-                    else if (k === "model")
-                        preset.model = v;
-                    else if (k === "permissions")
-                        preset.permissions = v;
-                    else if (k === "max-turns")
-                        preset.maxTurns = parseInt(v, 10) || undefined;
-                    else if (k === "budget")
-                        preset.budget = v === "none" ? null : parseFloat(v) || undefined;
-                    else if (k === "plan")
-                        preset.plan = true;
-                }
-                try {
-                    savePreset(presetName, preset);
-                    process.stderr.write(`${DIM}Saved preset "${presetName}".${RESET}\n`);
-                }
-                catch (err) {
-                    process.stderr.write(`${DIM}${err instanceof Error ? err.message : String(err)}${RESET}\n`);
-                }
-                return true;
-            }
-            if (sub === "delete") {
-                const presetName = parts[2];
-                if (!presetName) {
-                    process.stderr.write(`${DIM}Usage: /preset delete <name>${RESET}\n`);
-                    return true;
-                }
-                try {
-                    const ok = deletePreset(presetName);
-                    process.stderr.write(`${DIM}${ok ? `Deleted "${presetName}".` : `Preset "${presetName}" not found.`}${RESET}\n`);
-                }
-                catch (err) {
-                    process.stderr.write(`${DIM}${err instanceof Error ? err.message : String(err)}${RESET}\n`);
-                }
-                return true;
-            }
-            // /preset <name> — show preset details (use --preset <name> on CLI to apply at startup)
-            const preset = loadPreset(sub);
-            if (!preset) {
-                process.stderr.write(`${DIM}Preset "${sub}" not found. Use /preset list to see available presets.${RESET}\n`);
-            }
-            else {
-                const isBuiltin = ["fast", "careful", "yolo"].includes(sub);
-                process.stderr.write(`${DIM}${formatPreset(sub, preset, isBuiltin)}\nUse: phren-agent --preset ${sub} <task>${RESET}\n`);
-            }
-            return true;
-        }
         case "/exit":
         case "/quit":
         case "/q":

package/dist/config.js

@@ -11,7 +11,8 @@ Options:
   --max-output <n>     Max output tokens per response (default: auto per model)
   --budget <dollars>   Max spend in USD (aborts when exceeded)
   --plan               Plan mode: show plan before executing tools
-  --permissions <mode> Permission mode: suggest, auto-confirm, full-auto (default: auto-confirm)
+  --permissions <mode> Permission mode: suggest (default), auto-confirm, full-auto
+  --yolo               Full-auto permissions — no confirmations (alias for --permissions full-auto)
   --interactive, -i    Interactive REPL mode (multi-turn conversation)
   --resume             Resume last session's conversation
   --lint-cmd <cmd>     Override auto-detected lint command
@@ -46,7 +47,7 @@ Examples:
 export function parseArgs(argv) {
     const args = {
         task: "",
-        permissions: "auto-confirm",
+        permissions: "suggest",
         maxTurns: 50,
         budget: null,
         plan: false,
@@ -120,6 +121,9 @@ export function parseArgs(argv) {
         else if (arg === "--budget" && argv[i + 1]) {
             args.budget = parseFloat(argv[++i]) || null;
         }
+        else if (arg === "--yolo") {
+            args.permissions = "full-auto";
+        }
         else if (arg === "--permissions" && argv[i + 1]) {
             const mode = argv[++i];
             if (mode === "suggest" || mode === "auto-confirm" || mode === "full-auto") {

package/dist/index.js

@@ -165,6 +165,7 @@ export async function runAgentCli(raw) {
         costTracker,
         plan: args.plan,
         lintTestConfig,
+        sessionId,
     };
     // Multi-agent TUI mode
     if (args.multi || args.team) {
@@ -183,12 +184,17 @@ export async function runAgentCli(raw) {
         mcpCleanup?.();
         return;
     }
-    // Interactive mode — TUI if terminal, fallback to REPL if not
+    // Interactive mode — Ink TUI if available, legacy TUI fallback, REPL if not TTY
     if (args.interactive) {
         const isTTY = process.stdout.isTTY && process.stdin.isTTY;
-        const session = isTTY
-            ? await (await import("./tui.js")).startTui(agentConfig)
-            : await (await import("./repl.js")).startRepl(agentConfig);
+        let session;
+        if (!isTTY) {
+            session = await (await import("./repl.js")).startRepl(agentConfig);
+        }
+        else {
+            // Ink TUI only — no legacy fallback
+            session = await (await import("./tui/ink-entry.js")).startInkTui(agentConfig);
+        }
         // Flush anti-patterns at session end
         if (phrenCtx) {
             try {

package/dist/mcp-client.js

@@ -24,7 +24,8 @@ class McpConnection {
             try {
                 const msg = JSON.parse(line);
                 if (msg.id !== undefined && this.pending.has(msg.id)) {
-                    const { resolve, reject } = this.pending.get(msg.id);
+                    const { resolve, reject, timer } = this.pending.get(msg.id);
+                    clearTimeout(timer);
                     this.pending.delete(msg.id);
                     if (msg.error)
                         reject(new Error(`MCP error: ${msg.error.message}`));
@@ -35,8 +36,10 @@ class McpConnection {
             catch { /* ignore non-JSON lines */ }
         });
         this.proc.on("error", (err) => {
-            for (const { reject } of this.pending.values())
+            for (const { reject, timer } of this.pending.values()) {
+                clearTimeout(timer);
                 reject(err);
+            }
             this.pending.clear();
         });
     }
@@ -44,15 +47,14 @@ class McpConnection {
         return new Promise((resolve, reject) => {
             const id = this.nextId++;
             const msg = { jsonrpc: "2.0", id, method, params };
-            this.pending.set(id, { resolve, reject });
-            this.proc.stdin.write(JSON.stringify(msg) + "\n");
-            // Timeout after 30s
-            setTimeout(() => {
+            const timer = setTimeout(() => {
                 if (this.pending.has(id)) {
                     this.pending.delete(id);
                     reject(new Error(`MCP call ${method} timed out (30s)`));
                 }
             }, 30_000);
+            this.pending.set(id, { resolve, reject, timer });
+            this.proc.stdin.write(JSON.stringify(msg) + "\n");
         });
     }
     async initialize() {
@@ -81,8 +83,10 @@ class McpConnection {
         }
         catch { /* ignore */ }
         this.rl.close();
-        for (const { reject } of this.pending.values())
+        for (const { reject, timer } of this.pending.values()) {
+            clearTimeout(timer);
             reject(new Error("Connection closed"));
+        }
         this.pending.clear();
     }
 }

package/dist/multi/multi-commands.js

@@ -0,0 +1,170 @@
+import { createPane, appendToPane, flushPartial } from "./pane.js";
+import { s, statusColor } from "./multi-render.js";
+function resolveAgentTarget(target, agentOrder, panes, spawner) {
+    // Try numeric index (1-based)
+    const idx = parseInt(target, 10);
+    if (!isNaN(idx) && idx >= 1 && idx <= agentOrder.length) {
+        return agentOrder[idx - 1];
+    }
+    // Try name match
+    for (const [id, pane] of panes) {
+        if (pane.name === target)
+            return id;
+    }
+    // Try agent ID
+    if (spawner.getAgent(target))
+        return target;
+    return null;
+}
+function appendToSystem(ctx, text) {
+    if (!ctx.selectedId || !ctx.panes.has(ctx.selectedId)) {
+        // Create a virtual system pane
+        const pane = createPane("_system", "system");
+        ctx.panes.set("_system", pane);
+        if (!ctx.agentOrder.includes("_system"))
+            ctx.agentOrder.push("_system");
+        ctx.setSelectedId("_system");
+        appendToPane(pane, text + "\n");
+    }
+    else {
+        const pane = ctx.panes.get(ctx.selectedId);
+        flushPartial(pane);
+        appendToPane(pane, text + "\n");
+    }
+    ctx.render();
+}
+export function handleSlashCommand(line, ctx) {
+    const parts = line.split(/\s+/);
+    const cmd = parts[0].toLowerCase();
+    if (cmd === "/spawn") {
+        const name = parts[1];
+        const task = parts.slice(2).join(" ");
+        if (!name || !task) {
+            appendToSystem(ctx, "Usage: /spawn <name> <task>");
+            return true;
+        }
+        const opts = {
+            task,
+            cwd: process.cwd(),
+            provider: ctx.config.provider.name,
+            permissions: "auto-confirm",
+            verbose: ctx.config.verbose,
+        };
+        const agentId = ctx.spawner.spawn(opts);
+        const pane = ctx.getOrCreatePane(agentId);
+        pane.name = name;
+        appendToPane(pane, s.cyan(`Spawned agent "${name}" (${agentId}): ${task}`) + "\n");
+        ctx.setSelectedId(agentId);
+        ctx.render();
+        return true;
+    }
+    if (cmd === "/list") {
+        const agents = ctx.spawner.listAgents();
+        if (agents.length === 0) {
+            appendToSystem(ctx, "No agents.");
+        }
+        else {
+            const lines = ["Agents:"];
+            for (let i = 0; i < agents.length; i++) {
+                const a = agents[i];
+                const pane = ctx.panes.get(a.id);
+                const name = pane?.name ?? a.id;
+                const color = statusColor(a.status);
+                const elapsed = a.finishedAt
+                    ? `${((a.finishedAt - a.startedAt) / 1000).toFixed(1)}s`
+                    : `${((Date.now() - a.startedAt) / 1000).toFixed(0)}s`;
+                lines.push(`  ${i + 1}. ${name} [${color(a.status)}] ${s.dim(elapsed)} — ${a.task.slice(0, 50)}`);
+            }
+            appendToSystem(ctx, lines.join("\n"));
+        }
+        return true;
+    }
+    if (cmd === "/kill") {
+        const target = parts[1];
+        if (!target) {
+            appendToSystem(ctx, "Usage: /kill <name|index>");
+            return true;
+        }
+        const agentId = resolveAgentTarget(target, ctx.agentOrder, ctx.panes, ctx.spawner);
+        if (!agentId) {
+            appendToSystem(ctx, `Agent "${target}" not found.`);
+            return true;
+        }
+        const ok = ctx.spawner.cancel(agentId);
+        const pane = ctx.getOrCreatePane(agentId);
+        if (ok) {
+            appendToPane(pane, s.yellow("\n--- Cancelled ---\n"));
+        }
+        else {
+            appendToSystem(ctx, `Agent "${target}" is not running.`);
+        }
+        ctx.render();
+        return true;
+    }
+    if (cmd === "/broadcast") {
+        const msg = parts.slice(1).join(" ");
+        if (!msg) {
+            appendToSystem(ctx, "Usage: /broadcast <message>");
+            return true;
+        }
+        const agents = ctx.spawner.listAgents();
+        let sent = 0;
+        for (const a of agents) {
+            if (a.status === "running") {
+                const pane = ctx.getOrCreatePane(a.id);
+                appendToPane(pane, s.yellow(`[broadcast] ${msg}`) + "\n");
+                sent++;
+            }
+        }
+        appendToSystem(ctx, `Broadcast sent to ${sent} running agent(s).`);
+        return true;
+    }
+    if (cmd === "/msg") {
+        const target = parts[1];
+        const msg = parts.slice(2).join(" ");
+        if (!target || !msg) {
+            appendToSystem(ctx, "Usage: /msg <agent> <text>");
+            return true;
+        }
+        const agentId = resolveAgentTarget(target, ctx.agentOrder, ctx.panes, ctx.spawner);
+        if (!agentId) {
+            appendToSystem(ctx, `Agent "${target}" not found.`);
+            return true;
+        }
+        const ok = ctx.spawner.sendToAgent(agentId, msg, "user");
+        if (ok) {
+            const recipientPane = ctx.getOrCreatePane(agentId);
+            flushPartial(recipientPane);
+            appendToPane(recipientPane, s.yellow(`[user -> ${recipientPane.name}] ${msg}`) + "\n");
+            if (ctx.selectedId && ctx.selectedId !== agentId && ctx.panes.has(ctx.selectedId)) {
+                const curPane = ctx.panes.get(ctx.selectedId);
+                flushPartial(curPane);
+                appendToPane(curPane, s.yellow(`[user -> ${recipientPane.name}] ${msg}`) + "\n");
+            }
+        }
+        else {
+            appendToSystem(ctx, `Agent "${target}" is not running.`);
+        }
+        ctx.render();
+        return true;
+    }
+    if (cmd === "/help") {
+        appendToSystem(ctx, [
+            "Commands:",
+            "  /spawn <name> <task>  — Spawn a new agent",
+            "  /list                 — List all agents",
+            "  /kill <name|index>    — Terminate an agent",
+            "  /msg <agent> <text>   — Send direct message to an agent",
+            "  /broadcast <msg>      — Send to all running agents",
+            "  /help                 — Show this help",
+            "",
+            "Keys:",
+            "  1-9                   — Select agent by number",
+            "  Ctrl+Left/Right       — Cycle agents",
+            "  PageUp/PageDown       — Scroll output",
+            "  Ctrl+D                — Exit (kills all)",
+        ].join("\n"));
+        return true;
+    }
+    return false;
+}