@phren/agent 0.0.1 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ala Arab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/agent-loop.js

@@ -317,7 +317,7 @@ export async function runTurn(userInput, session, config, hooks) {
 export async function runAgent(task, config) {
     const contextLimit = config.provider.contextWindow ?? 200_000;
     const session = createSession(contextLimit);
-    const result = await runTurn(task, session, config);
+    const result = await runTurn(task, session, config, config.hooks);
     return {
         finalText: result.text,
         turns: result.turns,

package/dist/commands.js

@@ -2,6 +2,8 @@ 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";
 const DIM = "\x1b[2m";
 const BOLD = "\x1b[1m";
 const CYAN = "\x1b[36m";
@@ -35,6 +37,10 @@ export function handleCommand(input, ctx) {
         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
@@ -48,6 +54,68 @@ export function handleCommand(input, ctx) {
   /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) : "?";

package/dist/config.js

@@ -8,6 +8,7 @@ Options:
   --model <model>      Override LLM model
   --project <name>     Force phren project context
   --max-turns <n>      Max tool-use turns (default: 50)
+  --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)
@@ -113,6 +114,9 @@ export function parseArgs(argv) {
         else if (arg === "--max-turns" && argv[i + 1]) {
             args.maxTurns = parseInt(argv[++i], 10) || 50;
         }
+        else if (arg === "--max-output" && argv[i + 1]) {
+            args.maxOutput = parseInt(argv[++i], 10) || undefined;
+        }
         else if (arg === "--budget" && argv[i + 1]) {
             args.budget = parseFloat(argv[++i]) || null;
         }

package/dist/context/pruner.js

@@ -10,6 +10,102 @@ export function shouldPrune(systemPrompt, messages, config) {
     const msgTokens = estimateMessageTokens(messages);
     return (systemTokens + msgTokens) > limit * 0.75;
 }
+// ── Fact extraction (regex only, no LLM) ────────────────────────────────────
+const FILE_TOOL_NAMES = new Set(["edit_file", "write_file"]);
+const SEARCH_TOOL_NAMES = new Set(["phren_search"]);
+const DECISION_RE = /\b(?:I'll|Let's|The fix is|Changed|because|decided to|switched to|replaced|removed|added|created|updated|refactored)\b/i;
+/** Extract key facts from messages about to be pruned. Fast regex-only scan. */
+export function extractFacts(messages) {
+    const filesSet = new Set();
+    const errorsSet = new Set();
+    const actionsSet = new Set();
+    const searchesSet = new Set();
+    for (const msg of messages) {
+        if (typeof msg.content === "string") {
+            // Scan assistant text messages for key decisions
+            if (msg.role === "assistant") {
+                extractDecisions(msg.content, actionsSet);
+            }
+            continue;
+        }
+        for (const block of msg.content) {
+            if (block.type === "tool_use") {
+                extractFromToolUse(block, filesSet, searchesSet);
+            }
+            else if (block.type === "tool_result" && block.is_error) {
+                extractError(block, errorsSet);
+            }
+            else if (block.type === "text" && msg.role === "assistant") {
+                extractDecisions(block.text, actionsSet);
+            }
+        }
+    }
+    return {
+        filesModified: [...filesSet],
+        errors: [...errorsSet],
+        keyActions: [...actionsSet],
+        searches: [...searchesSet],
+    };
+}
+function extractFromToolUse(block, filesSet, searchesSet) {
+    if (FILE_TOOL_NAMES.has(block.name)) {
+        const fp = block.input?.file_path;
+        if (typeof fp === "string" && fp) {
+            filesSet.add(fp);
+        }
+    }
+    if (SEARCH_TOOL_NAMES.has(block.name)) {
+        const q = block.input?.query;
+        if (typeof q === "string" && q) {
+            searchesSet.add(q);
+        }
+    }
+}
+function extractError(block, errorsSet) {
+    const firstLine = block.content.split("\n")[0].trim();
+    if (firstLine) {
+        // Cap length to keep summary concise
+        errorsSet.add(firstLine.length > 120 ? firstLine.slice(0, 120) + "..." : firstLine);
+    }
+}
+const MAX_KEY_ACTIONS = 5;
+function extractDecisions(text, actionsSet) {
+    if (actionsSet.size >= MAX_KEY_ACTIONS)
+        return;
+    for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed && DECISION_RE.test(trimmed)) {
+            const capped = trimmed.length > 100 ? trimmed.slice(0, 100) + "..." : trimmed;
+            actionsSet.add(capped);
+            if (actionsSet.size >= MAX_KEY_ACTIONS)
+                return;
+        }
+    }
+}
+// ── Summary formatting ──────────────────────────────────────────────────────
+function formatFactSummary(middle, toolsUsed) {
+    const facts = extractFacts(middle);
+    const lines = [
+        `[Context compacted: ${middle.length} messages removed]`,
+    ];
+    if (toolsUsed.size > 0) {
+        lines.push(`Tools used: ${[...toolsUsed].join(", ")}`);
+    }
+    if (facts.filesModified.length > 0) {
+        lines.push(`Files modified: ${facts.filesModified.join(", ")}`);
+    }
+    if (facts.errors.length > 0) {
+        lines.push(`Errors encountered: ${facts.errors.join(", ")}`);
+    }
+    if (facts.keyActions.length > 0) {
+        lines.push(`Key actions: ${facts.keyActions.join(", ")}`);
+    }
+    if (facts.searches.length > 0) {
+        lines.push(`Searches: ${facts.searches.map(q => `"${q}"`).join(", ")}`);
+    }
+    return lines.join("\n");
+}
+// ── Pruner ──────────────────────────────────────────────────────────────────
 /** Prune messages, keeping the first (original task) and last N turn pairs. */
 export function pruneMessages(messages, config) {
     const keepRecent = config?.keepRecentTurns ?? DEFAULT_CONFIG.keepRecentTurns;
@@ -47,16 +143,9 @@ export function pruneMessages(messages, config) {
             }
         }
     }
-    const summaryText = [
-        `[Context compacted: ${middle.length} messages removed]`,
-        toolsUsed.size > 0 ? `Tools used: ${[...toolsUsed].join(", ")}` : null,
-        `Key points: ${middle.length} intermediate turns were compacted to fit context window.`,
-    ]
-        .filter(Boolean)
-        .join("\n");
     const summaryMessage = {
         role: "user",
-        content: summaryText,
+        content: formatFactSummary(middle, toolsUsed),
     };
     return [first, summaryMessage, ...tail];
 }

package/dist/cost.js

@@ -25,6 +25,41 @@ const PRICING = [
     ["ollama", { inputPer1M: 0, outputPer1M: 0 }],
 ];
 PRICING.sort((a, b) => b[0].length - a[0].length); // longest prefix first
+// Max output token limits per model — prefix match (most specific wins)
+const OUTPUT_LIMITS = [
+    // Anthropic
+    ["claude-opus-4", 32768],
+    ["claude-sonnet-4", 16384],
+    ["claude-haiku-4", 8192],
+    ["claude-3-5-sonnet", 8192],
+    ["claude-3-5-haiku", 8192],
+    ["claude-3-opus", 4096],
+    // OpenAI
+    ["gpt-5", 16384],
+    ["gpt-4.1", 32768],
+    ["gpt-4o", 16384],
+    ["gpt-4-turbo", 4096],
+    ["o3", 100000],
+    ["o4-mini", 100000],
+    // OpenRouter prefixed
+    ["anthropic/claude-opus-4", 32768],
+    ["anthropic/claude-sonnet-4", 16384],
+    ["anthropic/claude-haiku-4", 8192],
+    ["openai/gpt-4o", 16384],
+    // Codex
+    ["gpt-5.2-codex", 16384],
+    // Local
+    ["qwen", 8192],
+];
+OUTPUT_LIMITS.sort((a, b) => b[0].length - a[0].length); // longest prefix first
+export function lookupMaxOutputTokens(model) {
+    const lower = model.toLowerCase();
+    for (const [prefix, limit] of OUTPUT_LIMITS) {
+        if (lower.startsWith(prefix))
+            return limit;
+    }
+    return 8192; // default
+}
 function lookupPricing(model) {
     const lower = model.toLowerCase();
     for (const [prefix, pricing] of PRICING) {

package/dist/index.js

@@ -57,7 +57,7 @@ export async function runAgentCli(raw) {
     // Resolve LLM provider
     let provider;
     try {
-        provider = resolveProvider(args.provider, args.model);
+        provider = resolveProvider(args.provider, args.model, args.maxOutput);
     }
     catch (err) {
         console.error(err instanceof Error ? err.message : String(err));

package/dist/multi/agent-colors.js

@@ -34,8 +34,3 @@ export function formatAgentName(name, index) {
     const { color, icon } = getAgentStyle(index);
     return color(`${icon} ${name}`);
 }
-/** Prefix a line with the agent's icon in its color. */
-export function prefixLine(line, index) {
-    const { color, icon } = getAgentStyle(index);
-    return `${color(icon)} ${line}`;
-}

package/dist/multi/child-entry.js

@@ -25,7 +25,6 @@ import { loadProjectContext } from "../memory/project-context.js";
 import { buildSystemPrompt } from "../system-prompt.js";
 import { runAgent } from "../agent-loop.js";
 import { createCostTracker } from "../cost.js";
-let cancelled = false;
 /** Send a typed message to the parent process. */
 function send(msg) {
     if (process.send) {
@@ -118,6 +117,7 @@ async function runChildAgent(payload) {
         phrenCtx,
         costTracker,
         plan,
+        hooks: createIpcHooks(agentId),
     };
     // Run the agent
     try {
@@ -162,7 +162,6 @@ process.on("message", (msg) => {
         });
     }
     else if (msg.type === "cancel") {
-        cancelled = true;
         process.exit(130);
     }
 });

package/dist/multi/markdown.js

@@ -3,6 +3,7 @@
  * Regex-based, no AST parser. Handles the common subset of markdown
  * that LLMs produce: headers, bold, inline code, code blocks, bullet lists.
  */
+import { highlightCode, detectLanguage } from "./syntax-highlight.js";
 const ESC = "\x1b[";
 const RESET = `${ESC}0m`;
 const BOLD = `${ESC}1m`;
@@ -20,24 +21,33 @@ export function renderMarkdown(text) {
     const out = [];
     let inCodeBlock = false;
     let codeLang = "";
+    let codeBuffer = [];
     for (const line of lines) {
         // Code block fences
         if (line.trimStart().startsWith("```")) {
             if (!inCodeBlock) {
                 inCodeBlock = true;
                 codeLang = line.trimStart().slice(3).trim();
+                codeBuffer = [];
                 const label = codeLang ? ` ${codeLang}` : "";
                 out.push(`${DIM}  ┌──${label}${"─".repeat(Math.max(0, MAX_WIDTH - 6 - label.length))}${RESET}`);
             }
             else {
+                // Flush code buffer through syntax highlighter
+                const lang = codeLang ? detectLanguage(codeLang) : "generic";
+                const highlighted = highlightCode(codeBuffer.join("\n"), lang);
+                for (const hl of highlighted.split("\n")) {
+                    out.push(`${DIM}  │ ${RESET}${hl}`);
+                }
                 inCodeBlock = false;
                 codeLang = "";
+                codeBuffer = [];
                 out.push(`${DIM}  └${"─".repeat(MAX_WIDTH - 3)}${RESET}`);
             }
             continue;
         }
         if (inCodeBlock) {
-            out.push(`${DIM}  │ ${line.slice(0, MAX_WIDTH - 4)}${RESET}`);
+            codeBuffer.push(line.slice(0, MAX_WIDTH - 4));
             continue;
         }
         // Headers

package/dist/multi/model-picker.js

@@ -0,0 +1,154 @@
+const ESC = "\x1b[";
+const s = {
+    bold: (t) => `${ESC}1m${t}${ESC}0m`,
+    dim: (t) => `${ESC}2m${t}${ESC}0m`,
+    cyan: (t) => `${ESC}36m${t}${ESC}0m`,
+    green: (t) => `${ESC}32m${t}${ESC}0m`,
+    yellow: (t) => `${ESC}33m${t}${ESC}0m`,
+    magenta: (t) => `${ESC}35m${t}${ESC}0m`,
+    gray: (t) => `${ESC}90m${t}${ESC}0m`,
+};
+const REASONING_LEVELS = ["low", "medium", "high", "max"];
+/** Models available per provider. Extend as needed. */
+export function getAvailableModels(provider, currentModel) {
+    const models = [];
+    switch (provider) {
+        case "anthropic":
+            models.push({ id: "claude-sonnet-4-20250514", provider: "anthropic", label: "Sonnet 4", reasoning: "medium", reasoningRange: ["low", "medium", "high"], contextWindow: 200_000 }, { id: "claude-opus-4-20250514", provider: "anthropic", label: "Opus 4", reasoning: "high", reasoningRange: ["low", "medium", "high", "max"], contextWindow: 200_000 }, { id: "claude-haiku-4-5-20251001", provider: "anthropic", label: "Haiku 4.5", reasoning: null, reasoningRange: [], contextWindow: 200_000 });
+            break;
+        case "openrouter":
+            models.push({ id: "anthropic/claude-sonnet-4-20250514", provider: "openrouter", label: "Sonnet 4", reasoning: "medium", reasoningRange: ["low", "medium", "high"], contextWindow: 200_000 }, { id: "anthropic/claude-opus-4-20250514", provider: "openrouter", label: "Opus 4", reasoning: "high", reasoningRange: ["low", "medium", "high", "max"], contextWindow: 200_000 }, { id: "openai/gpt-4o", provider: "openrouter", label: "GPT-4o", reasoning: null, reasoningRange: [], contextWindow: 128_000 }, { id: "openai/o4-mini", provider: "openrouter", label: "o4-mini", reasoning: "medium", reasoningRange: ["low", "medium", "high"], contextWindow: 128_000 }, { id: "google/gemini-2.5-pro", provider: "openrouter", label: "Gemini 2.5 Pro", reasoning: "medium", reasoningRange: ["low", "medium", "high"], contextWindow: 1_000_000 }, { id: "deepseek/deepseek-r1", provider: "openrouter", label: "DeepSeek R1", reasoning: "high", reasoningRange: ["medium", "high"], contextWindow: 128_000 });
+            break;
+        case "openai":
+            models.push({ id: "gpt-4o", provider: "openai", label: "GPT-4o", reasoning: null, reasoningRange: [], contextWindow: 128_000 }, { id: "o4-mini", provider: "openai", label: "o4-mini", reasoning: "medium", reasoningRange: ["low", "medium", "high"], contextWindow: 128_000 }, { id: "o3", provider: "openai", label: "o3", reasoning: "high", reasoningRange: ["low", "medium", "high", "max"], contextWindow: 200_000 });
+            break;
+        case "codex":
+            models.push({ id: "gpt-4o", provider: "codex", label: "GPT-4o", reasoning: null, reasoningRange: [], contextWindow: 128_000 }, { id: "o4-mini", provider: "codex", label: "o4-mini", reasoning: "medium", reasoningRange: ["low", "medium", "high"], contextWindow: 128_000 }, { id: "o3", provider: "codex", label: "o3", reasoning: "high", reasoningRange: ["low", "medium", "high", "max"], contextWindow: 200_000 });
+            break;
+        case "ollama":
+            models.push({ id: "qwen2.5-coder:14b", provider: "ollama", label: "Qwen 2.5 Coder 14B", reasoning: null, reasoningRange: [], contextWindow: 32_000 }, { id: "llama3.2", provider: "ollama", label: "Llama 3.2", reasoning: null, reasoningRange: [], contextWindow: 128_000 }, { id: "deepseek-r1:14b", provider: "ollama", label: "DeepSeek R1 14B", reasoning: "medium", reasoningRange: ["medium", "high"], contextWindow: 128_000 });
+            break;
+    }
+    // If user has a custom model not in the list, add it
+    if (currentModel && !models.some((m) => m.id === currentModel)) {
+        models.unshift({
+            id: currentModel,
+            provider: provider,
+            label: currentModel,
+            reasoning: null,
+            reasoningRange: [],
+            contextWindow: 200_000,
+        });
+    }
+    return models;
+}
+// ── Reasoning meter rendering ───────────────────────────────────────────────
+function renderReasoningMeter(level, range) {
+    if (range.length === 0 || level === null)
+        return s.dim("─────");
+    const maxSlots = 5;
+    const levelIdx = REASONING_LEVELS.indexOf(level);
+    const filled = levelIdx < 0 ? 0 : Math.min(levelIdx + 1, maxSlots);
+    let meter = "";
+    for (let i = 0; i < maxSlots; i++) {
+        meter += i < filled ? "●" : "○";
+    }
+    const color = filled >= 4 ? s.magenta : filled >= 3 ? s.yellow : filled >= 2 ? s.green : s.cyan;
+    const label = level ?? "n/a";
+    return `${color(meter)} ${s.dim(label)}`;
+}
+/**
+ * Show interactive model picker. Returns selected model + reasoning, or null on cancel.
+ * Works in raw mode — caller must be in raw mode already (TUI) or we'll set it.
+ */
+export function showModelPicker(provider, currentModel, w) {
+    const models = getAvailableModels(provider, currentModel);
+    if (models.length === 0) {
+        w.write(s.dim("  No models available for this provider.\n"));
+        return Promise.resolve(null);
+    }
+    let cursor = models.findIndex((m) => m.id === currentModel);
+    if (cursor < 0)
+        cursor = 0;
+    // Clone reasoning levels so we can adjust them
+    const reasoningState = models.map((m) => m.reasoning);
+    function render() {
+        // Clear previous render (move up by model count + header + footer + blank)
+        const totalLines = models.length + 4;
+        w.write(`${ESC}${totalLines}A${ESC}J`);
+        drawPicker();
+    }
+    function drawPicker() {
+        const maxLabel = Math.max(...models.map((m) => m.label.length));
+        w.write(`\n  ${s.bold("Select model")} ${s.dim("(↑↓ navigate, ←→ reasoning, enter select, esc cancel)")}\n\n`);
+        for (let i = 0; i < models.length; i++) {
+            const m = models[i];
+            const selected = i === cursor;
+            const arrow = selected ? s.cyan("▸") : " ";
+            const label = selected ? s.bold(m.label) : s.dim(m.label);
+            const padded = m.label + " ".repeat(maxLabel - m.label.length);
+            const labelStr = selected ? s.bold(padded) : s.dim(padded);
+            const meter = renderReasoningMeter(reasoningState[i], m.reasoningRange);
+            const ctx = s.dim(`${(m.contextWindow / 1000).toFixed(0)}k`);
+            w.write(`  ${arrow} ${labelStr}  ${meter}  ${ctx}\n`);
+        }
+        w.write(`\n`);
+    }
+    // Initial draw
+    drawPicker();
+    return new Promise((resolve) => {
+        const wasRaw = process.stdin.isRaw;
+        function onKey(_ch, key) {
+            if (!key)
+                return;
+            if (key.name === "escape" || (key.ctrl && key.name === "c")) {
+                cleanup();
+                resolve(null);
+                return;
+            }
+            if (key.name === "return") {
+                const m = models[cursor];
+                cleanup();
+                resolve({ model: m.id, reasoning: reasoningState[cursor] });
+                return;
+            }
+            if (key.name === "up") {
+                cursor = (cursor - 1 + models.length) % models.length;
+                render();
+                return;
+            }
+            if (key.name === "down") {
+                cursor = (cursor + 1) % models.length;
+                render();
+                return;
+            }
+            // Left/Right: adjust reasoning level
+            if (key.name === "left" || key.name === "right") {
+                const m = models[cursor];
+                if (m.reasoningRange.length === 0)
+                    return; // no reasoning for this model
+                const current = reasoningState[cursor];
+                const idx = current ? REASONING_LEVELS.indexOf(current) : -1;
+                const rangeIndices = m.reasoningRange.map((r) => REASONING_LEVELS.indexOf(r));
+                if (key.name === "right") {
+                    // Go higher
+                    const next = rangeIndices.find((ri) => ri > idx);
+                    if (next !== undefined)
+                        reasoningState[cursor] = REASONING_LEVELS[next];
+                }
+                else {
+                    // Go lower
+                    const prev = [...rangeIndices].reverse().find((ri) => ri < idx);
+                    if (prev !== undefined)
+                        reasoningState[cursor] = REASONING_LEVELS[prev];
+                }
+                render();
+                return;
+            }
+        }
+        function cleanup() {
+            process.stdin.removeListener("keypress", onKey);
+        }
+        process.stdin.on("keypress", onKey);
+    });
+}