actoviq-agent-sdk 0.4.11 → 0.4.13

package/dist/src/tui/hadamardTui.js

@@ -10,7 +10,7 @@ import { createHash, randomUUID } from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import * as readline from 'node:readline';
-import { createHadamardCoreTools, createAgentSdk, createHadamardBridgeSdk, detectBridgeProviders, loadDefaultHadamardSettings, loadJsonConfigFile, listWorkflows, loadWorkflow, listTeamDefinitions, loadTeamDefinition, cloneTeamDefinition, instantiateTeamDefinition, listTeamAgentLabels, countTeamAgents, createModelTeam, createTeamTool, readTeamPreferences, createManagerTools, createAssistantTeamTools, buildAssistantTeamSystemPrompt, TeamProposalStore, SessionCatalog, createAssistantGlobalTools, buildAssistantGlobalSystemPrompt, readAssistantConfig, writeAssistantConfig, buildManagerSystemPrompt, buildUpdateProgressPrompt, formatManagerUpdatePreview, resolveGitHubDigestForUpdate, readManagerConfig, writeManagerConfig, readProjectPlanFile, readProgressFile, managerProgressPath, createProjectIssue, executeProjectIssue, isIssueStatus, isIssueStorageMode, listProjectIssues, listScheduledAutomationTasks, upsertScheduledAutomationTask, resolveHadamardHome, externalSkillPreferencesToRuntimeOptions, readHadamardExternalSkillPreferences, createManagedPluginRuntime, patchManagedPluginSettings, readManagedPluginCatalog, listRouterProfiles, loadRouterProfile, resolveRoutedRun, transitionProjectIssue, WorktreeService, GoalService, GOAL_METADATA_KEY, normalizeGoal, } from '../index.js';
+import { createHadamardCoreTools, createAgentSdk, createHadamardBridgeSdk, detectBridgeProviders, loadDefaultHadamardSettings, loadJsonConfigFile, listWorkflows, loadWorkflow, saveWorkflow, deleteWorkflow, listTeamDefinitions, loadTeamDefinition, cloneTeamDefinition, deleteTeamDefinition, getBuiltInTeamDefinition, instantiateTeamDefinition, listTeamAgentLabels, countTeamAgents, askTeamDefinition, createTeamTool, readTeamPreferences, createManagerTools, createAssistantTeamTools, buildAssistantTeamSystemPrompt, TeamProposalStore, SessionCatalog, createAssistantGlobalTools, buildAssistantGlobalSystemPrompt, readAssistantConfig, writeAssistantConfig, buildManagerSystemPrompt, buildUpdateProgressPrompt, formatManagerUpdatePreview, resolveGitHubDigestForUpdate, readManagerConfig, writeManagerConfig, readProjectPlanFile, readProgressFile, managerProgressPath, createProjectIssue, executeProjectIssue, isIssueStatus, isIssueStorageMode, listProjectIssues, listScheduledAutomationTasks, upsertScheduledAutomationTask, resolveHadamardHome, externalSkillPreferencesToRuntimeOptions, readHadamardExternalSkillPreferences, createManagedPluginRuntime, patchManagedPluginSettings, readManagedPluginCatalog, listRouterProfiles, loadRouterProfile, resolveRoutedRun, transitionProjectIssue, WorktreeService, } from '../index.js';
 import { adaptBridgeRun } from '../parity/bridgeEventAdapter.js';
 import { ExternalCliRuntimeManager } from '../parity/externalCliRuntimeManager.js';
 import { externalCliSessionMatchesConfig, listExternalCliSessions, readExternalCliSession, } from '../parity/externalCliSessions.js';
@@ -22,25 +22,27 @@ import { createPreToolUseHookClassifier, readPreToolUseHooks, readPostToolUseHoo
 import { parseTypedHooks } from '../hooks/hookConfig.js';
 import { isRecord } from '../runtime/helpers.js';
 import { getLoadedJsonConfig } from '../config/loadJsonConfigFile.js';
+import { buildModelConfigurationCatalog, findModelConfiguration, resolveHadamardConfigurationModel, } from '../config/modelConfigurationCatalog.js';
 import { findBridgeConfig, maskApiKey, readBridgeConfigs, addBridgeConfig, removeBridgeConfig, isManagedExternalCliRuntime, } from '../parity/bridgeConfigs.js';
 import { buildRouteModelApi } from '../router/modelRouter.js';
 import { addMcpServer, readMcpServerConfig, removeMcpServer } from '../mcp/mcpServerConfig.js';
 import { isReadOnlyBashCommand } from '../runtime/bashClassification.js';
 import { estimateCost } from '../team/pricing.js';
 import { applyTeamRunEvent, createTeamRunViewState, formatTeamRunTreeLines } from '../team/teamRunView.js';
-import { applyOutputStyle, OUTPUT_STYLES } from '../prompts/outputStyles.js';
 import { planFilePath, readPlanFile } from '../tools/planMode/PlanModeTools.js';
 import { loadProjectContext } from '../memory/projectContext.js';
 import { LegacySurfaceEventPipeline, } from '../surfaces/index.js';
 import { pathToFileURL } from 'node:url';
-import { HADAMARD_INTERACTIVE_COMMANDS, SUBCOMMAND_DESCRIPTIONS, filterInteractiveCommands, interactiveCommandUsage, selectInteractiveCommand, } from '../ui/commandSurface.js';
+import { HADAMARD_INTERACTIVE_COMMANDS, SUBCOMMAND_DESCRIPTIONS, canRunInteractiveCommand, filterInteractiveCommands, interactiveCommandRunPolicy, interactiveCommandUsage, parseTeamAskArguments, selectInteractiveCommand, } from '../ui/commandSurface.js';
 import { createAgentExecutionProjectView, createAgentExecutionRootView, formatAgentExecutionTreeLines, } from '../ui/agentExecutionView.js';
 import { A, stringWidth, truncateToWidth, wrapToWidth } from './ansi.js';
 import { InputEditor } from './editor.js';
 import { discoverHadamardPlugins } from './pluginCatalog.js';
 import { TuiScreen } from './screen.js';
+import { ReasoningDisplayState } from './reasoningDisplay.js';
+import { recallLatestFollowUp, restoreAbandonedFollowUp, submitActiveInput, } from './pendingInput.js';
 import { filterTuiSelectionItems, moveTuiSelection, } from './selection.js';
-import { StreamFlusher, formatBanner, formatCompactNotice, formatDivider, formatEditCall, formatErrorLine, formatInfoLine, formatQueuedPrompt, formatThinking, formatToolCall, formatToolResult, formatUserPrompt, } from './transcript.js';
+import { StreamFlusher, formatBanner, formatCompactNotice, formatDivider, formatEditCall, formatErrorLine, formatInfoLine, formatQueuedPrompt, formatToolCall, formatToolResult, formatUserPrompt, } from './transcript.js';
 const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 const CTRL_C_EXIT_WINDOW_MS = 600;
 const DYNAMIC_FRAME_MS = 33;
@@ -356,6 +358,8 @@ export async function runHadamardTui(options = {}) {
     let running = false;
     let commandBusy = false;
     let shuttingDown = false;
+    /** Follow-up pulled out of the queue into the editor; restored if abandoned. */
+    let recalledFollowUp = null;
     // Active team tool the main agent may call (toggled via /team). null = no team.
     // The tool is only injected into runs when preferences.team.autoInvoke is on;
     // otherwise attach is a selection and /team ask stays the manual path.
@@ -682,13 +686,10 @@ export async function runHadamardTui(options = {}) {
         return cost !== null ? `$${cost.toFixed(4)}` : null;
     }
     let statusNote = '';
-    // /output-style prompt prefix swap (gap #19). Applied to the base system
-    // prompt per turn; 'default' is a no-op.
-    let outputStyle = 'default';
     let ctrlCCount = 0;
     let ctrlCTimer = null;
     let streamedTextSeen = false;
-    let streamedThinkingSeen = false;
+    const reasoningDisplay = new ReasoningDisplayState();
     // Track tool names by callId for PostToolUse hook context.
     const toolCallNames = new Map();
     // Live todo list (captured from TodoWrite tool calls). Rendered as a
@@ -888,6 +889,16 @@ export async function runHadamardTui(options = {}) {
         lines.push(promptDivider());
         return lines;
     }
+    function promptCursorPosition(promptStartLine) {
+        if (editor.isEmpty()) {
+            return { line: promptStartLine + 1, column: 2 };
+        }
+        const visual = editor.visualLines(Math.max(screen.width - 5, 7));
+        return {
+            line: promptStartLine + 1 + visual.cursorRow,
+            column: 2 + visual.cursorCol,
+        };
+    }
     // ── @-mention file completion ──────────────────────────────────────
     // Prefer git's view (tracked + untracked, honoring .gitignore) so the list
     // matches what the agent actually sees; fall back to a bounded fs walk for
@@ -1038,7 +1049,10 @@ export async function runHadamardTui(options = {}) {
             const selected = index === menuSelected;
             const command = `/${name}`.padEnd(commandWidth);
             const label = selected ? `${A.inverse}${command}${A.reset}` : command;
-            const description = truncateToWidth(TUI_SLASH_COMMANDS[name] ?? SUBCOMMAND_DESCRIPTIONS[name] ?? '', descriptionWidth);
+            const commandName = name.split(/\s/u, 1)[0] ?? name;
+            const unavailable = running && interactiveCommandRunPolicy(commandName) === 'idle-only';
+            const summary = TUI_SLASH_COMMANDS[name] ?? SUBCOMMAND_DESCRIPTIONS[name] ?? '';
+            const description = truncateToWidth(unavailable ? `${summary} · after current run` : summary, descriptionWidth);
             return `${label} ${A.dim}${description}${A.reset}`;
         });
         const hiddenAbove = windowStart;
@@ -1051,6 +1065,14 @@ export async function runHadamardTui(options = {}) {
                 parts.push(`↓${hiddenBelow}`);
             lines.push(`${A.dim}  ${parts.join('  ')} more · ${menuSelected + 1}/${matches.length} (↑/↓ to scroll)${A.reset}`);
         }
+        const selected = matches[Math.min(menuSelected, matches.length - 1)];
+        if (selected) {
+            const commandName = selected.split(/\s/u, 1)[0] ?? selected;
+            const availability = interactiveCommandRunPolicy(commandName) === 'during-run'
+                ? 'available while working'
+                : 'idle session';
+            lines.push(`${A.dim}  ${interactiveCommandUsage(commandName)} · ${availability}${A.reset}`);
+        }
         return lines;
     }
     function buildDialog() {
@@ -1146,7 +1168,9 @@ export async function runHadamardTui(options = {}) {
         const ctxColor = pct >= 90 ? A.red : pct >= 70 ? A.yellow : A.dim;
         const modelLabel = activeRouter
             ? `router:${activeRouter.name}${routedModelLabel ? ` → ${routedModelLabel}` : ''}`
-            : session.model;
+            : !bridgeMode && activeBridgeConfig?.runtime === 'hadamard' && bridgeModelLabel
+                ? `${activeBridgeConfig.name}:${bridgeModelLabel}`
+                : session.model;
         const bridgeTag = bridgeMode && activeBridgeConfig
             ? ` · bridge:${activeBridgeConfig.name}${bridgeModelLabel ? ` · ${bridgeModelLabel}` : ''}`
             : '';
@@ -1171,10 +1195,39 @@ export async function runHadamardTui(options = {}) {
     }
     function buildHintLine() {
         if (running) {
-            return [`${A.dim}  enter to queue a steering message · esc interrupt · ctrl+c twice to exit${A.reset}`];
+            return [`${A.dim}  enter queue follow-up · shift+enter steer now · ↑ recall queued · esc interrupt${A.reset}`];
         }
         return [`${A.dim}  ? shortcuts · / commands · @ files · \\↵ newline · ↑↓ history · ctrl+c clear/exit${A.reset}`];
     }
+    function buildPendingInputPanel() {
+        const pending = session.pendingInputs;
+        const visible = pending.followUps.slice(-3);
+        const hidden = pending.followUps.length - visible.length;
+        const lines = visible.map((text, index) => (`${A.dim}  queued ${hidden + index + 1}: ${truncateToWidth(text.replace(/\s+/g, ' '), Math.max(screen.width - 15, 12))}${A.reset}`));
+        if (pending.steering.length > 0) {
+            lines.push(`${A.dim}  ${pending.steering.length} immediate steering message${pending.steering.length === 1 ? '' : 's'} pending${A.reset}`);
+        }
+        return lines;
+    }
+    function selectionDialogCursorPosition(startLine) {
+        if (!selectionDialog?.searchable)
+            return undefined;
+        return {
+            line: startLine + 2 + (selectionDialog.subtitle ? 1 : 0),
+            column: 4 + stringWidth(selectionDialog.query),
+        };
+    }
+    function textInputDialogCursorPosition(startLine) {
+        if (!textInputDialog)
+            return undefined;
+        const valueBeforeCursor = textInputDialog.secret
+            ? '•'.repeat(textInputDialog.editor.cursor)
+            : textInputDialog.editor.text.slice(0, textInputDialog.editor.cursor);
+        return {
+            line: startLine + 2 + (textInputDialog.description ? 1 : 0),
+            column: 2 + stringWidth(`${textInputDialog.label}: `) + stringWidth(valueBeforeCursor),
+        };
+    }
     function buildTodoPanel() {
         if (currentTodos.length === 0)
             return [];
@@ -1210,7 +1263,14 @@ export async function runHadamardTui(options = {}) {
     }
     function renderDynamic() {
         const lines = [];
+        let promptCursor;
         lines.push(...buildStatusLine());
+        if (running && session.pendingInputCount > 0) {
+            lines.push(...buildPendingInputPanel());
+        }
+        if (reasoningDisplay.hasActive) {
+            lines.push(...reasoningDisplay.liveLines(screen.width));
+        }
         const tail = flusher.tail();
         if (running && tail) {
             lines.push(tail);
@@ -1224,13 +1284,19 @@ export async function runHadamardTui(options = {}) {
             lines.push(...buildDialog());
         }
         else if (selectionDialog) {
+            const dialogStartLine = lines.length;
             lines.push(...buildSelectionDialog());
+            promptCursor = selectionDialogCursorPosition(dialogStartLine);
         }
         else if (textInputDialog) {
+            const dialogStartLine = lines.length;
             lines.push(...buildTextInputDialog());
+            promptCursor = textInputDialogCursorPosition(dialogStartLine);
         }
         else {
+            const promptStartLine = lines.length;
             lines.push(...buildPromptBar());
+            promptCursor = promptCursorPosition(promptStartLine);
             const atMenu = buildAtMenu();
             if (atMenu.length > 0) {
                 lines.push(...atMenu);
@@ -1240,7 +1306,7 @@ export async function runHadamardTui(options = {}) {
                 lines.push(...(menu.length > 0 ? menu : buildHintLine()));
             }
         }
-        screen.setDynamic(lines);
+        screen.setDynamic(lines, promptCursor);
     }
     function scheduleDynamicRender() {
         if (dynamicRenderTimer)
@@ -1259,6 +1325,11 @@ export async function runHadamardTui(options = {}) {
     function appendStatic(lines) {
         screen.appendStatic(lines);
     }
+    function collapseReasoning() {
+        const lines = reasoningDisplay.complete();
+        if (lines.length > 0)
+            appendStatic(lines);
+    }
     // Inline CLI spinner for long async operations (probe, reload).
     // Writes directly to stdout with \r — independent of the redrawable region.
     const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
@@ -1419,7 +1490,7 @@ export async function runHadamardTui(options = {}) {
         if (activeRouter && !bridgeMode) {
             try {
                 const decision = await resolveRoutedRun(activeRouter, text, abortCtrl.signal);
-                routed = { model: decision.model, modelApi: decision.modelApi };
+                routed = { model: decision.model, modelApi: decision.modelApi, effort: decision.effort };
                 routedModelLabel = `${decision.label} (${decision.model})`;
                 appendStatic(formatInfoLine(`router → ${routedModelLabel}`));
             }
@@ -1455,7 +1526,7 @@ export async function runHadamardTui(options = {}) {
                 // session → context intact; switching bridge↔hadamard is seamless.
                 statusNote = `bridge:${activeBridgeConfig?.name ?? 'bridge'}`;
                 const stream = session.stream(expandImageRefs(text), {
-                    systemPrompt: applyOutputStyle(systemPrompt + buildAgentContext(), outputStyle),
+                    systemPrompt: systemPrompt + buildAgentContext(),
                     signal: abortCtrl.signal,
                     permissionMode: currentPermissionMode(),
                     effort: currentEffort(),
@@ -1470,14 +1541,18 @@ export async function runHadamardTui(options = {}) {
                 resultPromise = stream.result;
             }
             else {
+                const selectedConfigModel = resolveHadamardConfigurationModel(activeBridgeConfig, bridgeMode, bridgeModelLabel);
                 const stream = session.stream(expandImageRefs(text), {
-                    systemPrompt: applyOutputStyle(systemPrompt + buildAgentContext(), outputStyle),
+                    systemPrompt: systemPrompt + buildAgentContext(),
                     signal: abortCtrl.signal,
                     permissionMode: currentPermissionMode(),
-                    effort: currentEffort(),
+                    // A matched route's effort overrides the session effort for this turn.
+                    effort: routed?.effort ?? currentEffort(),
                     approver,
                     classifier: preToolUseHookClassifier,
-                    ...(routed ? { model: routed.model, modelApi: routed.modelApi } : {}),
+                    ...(routed
+                        ? { model: routed.model, modelApi: routed.modelApi }
+                        : selectedConfigModel ? { model: selectedConfigModel } : {}),
                     ...(activeTeamTool && teamPrefs.autoInvoke ? { tools: [...tools, activeTeamTool] } : {}),
                     ...(canUseTool ? { canUseTool } : {}),
                 });
@@ -1491,6 +1566,7 @@ export async function runHadamardTui(options = {}) {
                 }
             }
             const result = await resultPromise;
+            collapseReasoning();
             // Accumulate token + USD usage for /cost and /usage. The model is the
             // routed model (if a router is active) or the session model. Bridge runs
             recordUsage(routed?.model ?? activeBridgeModelApi?.model ?? bridgeModelLabel ?? session.model, result.usage);
@@ -1521,6 +1597,7 @@ export async function runHadamardTui(options = {}) {
             appendStatic(['']);
         }
         catch (error) {
+            collapseReasoning();
             const rest = flusher.drain();
             if (rest.length > 0)
                 appendStatic(rest);
@@ -1552,7 +1629,7 @@ export async function runHadamardTui(options = {}) {
         switch (event.type) {
             case 'run.started':
                 streamedTextSeen = false;
-                streamedThinkingSeen = false;
+                reasoningDisplay.reset();
                 return;
             case 'request.started':
                 lastTokenEstimate = typeof data.requestTokenEstimate === 'number'
@@ -1564,6 +1641,7 @@ export async function runHadamardTui(options = {}) {
                 const delta = typeof data.delta === 'string' ? data.delta : '';
                 if (!delta)
                     return;
+                collapseReasoning();
                 streamedTextSeen = true;
                 const flushed = flusher.push(delta);
                 if (flushed.length > 0)
@@ -1575,10 +1653,7 @@ export async function runHadamardTui(options = {}) {
                 const delta = typeof data.delta === 'string' ? data.delta : '';
                 if (!delta)
                     return;
-                const lines = formatThinking(delta, screen.width);
-                if (lines.length > 0)
-                    appendStatic(lines);
-                streamedThinkingSeen = true;
+                reasoningDisplay.append(delta);
                 scheduleDynamicRender();
                 return;
             }
@@ -1594,15 +1669,15 @@ export async function runHadamardTui(options = {}) {
             }
             case 'model.content': {
                 const content = isRecord(data.content) ? data.content : undefined;
-                if (data.kind === 'content' && content?.type === 'thinking' && !streamedThinkingSeen) {
+                if (data.kind === 'content' && content?.type === 'thinking' && !reasoningDisplay.hasStreamedContent) {
                     const thinking = typeof content.thinking === 'string' ? content.thinking : '';
-                    const lines = formatThinking(thinking, screen.width);
-                    if (lines.length > 0)
-                        appendStatic(lines);
+                    reasoningDisplay.setCompleteContent(thinking);
+                    scheduleDynamicRender();
                 }
                 return;
             }
             case 'tool.started': {
+                collapseReasoning();
                 const callId = typeof data.callId === 'string' ? data.callId : '';
                 const publicName = typeof data.publicName === 'string'
                     ? data.publicName
@@ -1739,35 +1814,37 @@ export async function runHadamardTui(options = {}) {
             await resumeSession(selected);
     }
     async function chooseModel() {
+        const catalog = buildModelConfigurationCatalog({
+            model: sdk.config.model,
+            provider: sdk.config.provider,
+            baseURL: sdk.config.baseURL,
+        }, readBridgeConfigs().configs);
         const items = [
-            {
-                id: 'default',
-                label: 'Configured default',
-                description: sdk.config.model,
-            },
-            ...['min', 'medium', 'max']
-                .filter(tier => Boolean(sdk.config.modelTiers[tier]))
-                .map(tier => ({
-                id: `tier:${tier}`,
-                label: tier,
-                description: sdk.config.modelTiers[tier],
+            ...catalog.map(config => ({
+                id: config.id,
+                label: config.source === 'default' ? 'default' : config.name,
+                description: [
+                    config.execution === 'cli' ? `${config.runtime} CLI` : config.runtime,
+                    config.model || 'runtime default',
+                    config.models.length > 1 ? `${config.models.length} models` : '',
+                ].filter(Boolean).join(' · '),
             })),
             {
                 id: 'custom',
                 label: 'Enter a model ID',
-                description: 'Session override',
+                description: 'Use the default provider for this session',
             },
             {
                 id: 'configure',
-                label: 'Configure provider, API key, and models',
-                description: 'Updates the active Hadamard Agent settings file',
+                label: 'Manage configurations',
+                description: 'Default plus named provider configurations',
             },
         ];
         const selected = await selectItem({
             title: 'Select model',
             subtitle: `Current: ${session.model}`,
             items,
-            searchable: false,
+            searchable: true,
         });
         if (!selected)
             return;
@@ -1783,15 +1860,38 @@ export async function runHadamardTui(options = {}) {
             });
             if (!model?.trim())
                 return;
+            await disableBridge();
             await session.setModel(model.trim());
         }
-        else if (selected === 'default') {
-            await session.setModel(sdk.config.model);
-        }
         else {
-            await session.setModel(selected.slice('tier:'.length));
+            const config = findModelConfiguration(catalog, selected);
+            if (!config)
+                return;
+            if (config.source === 'default') {
+                await disableBridge();
+                await session.setModel(sdk.config.model);
+            }
+            else if (config.config) {
+                let selectedConfig = { ...config.config, model: config.model };
+                if (config.models.length > 1) {
+                    const model = await selectItem({
+                        title: config.name,
+                        subtitle: 'Select a model from this configuration',
+                        searchable: true,
+                        items: config.models.map(item => ({
+                            id: item.name,
+                            label: item.name,
+                            description: item.modality ?? 'text',
+                        })),
+                    });
+                    if (!model)
+                        return;
+                    selectedConfig = { ...selectedConfig, model };
+                }
+                await activateBridgeConfig(selectedConfig);
+            }
         }
-        appendStatic([...formatInfoLine(`model set to: ${session.model}`), '']);
+        appendStatic([...formatInfoLine(`model configuration: ${activeBridgeConfig?.name ?? 'default'} · ${bridgeModelLabel ?? session.model}`), '']);
     }
     async function configureModelSettings() {
         const store = await resolveHadamardSettingsStore({ configPath: options.configPath });
@@ -1830,11 +1930,16 @@ export async function runHadamardTui(options = {}) {
                         label: 'Base URL',
                         description: env.HADAMARD_BASE_URL || 'provider default',
                     },
-                    ...['min', 'medium', 'max'].map(tier => ({
-                        id: `tier:${tier}`,
-                        label: `${tier} model`,
-                        description: env[`HADAMARD_DEFAULT_${tier.toUpperCase()}_MODEL`] || 'not configured',
-                    })),
+                    {
+                        id: 'model',
+                        label: 'Default model',
+                        description: env.HADAMARD_MODEL || sdk.config.model || 'not configured',
+                    },
+                    {
+                        id: 'named',
+                        label: 'Named configurations',
+                        description: `${readBridgeConfigs().configs.length} configured`,
+                    },
                     {
                         id: 'save',
                         label: 'Save and apply',
@@ -1904,21 +2009,23 @@ export async function runHadamardTui(options = {}) {
                 }
                 continue;
             }
-            if (selected.startsWith('tier:')) {
-                const tier = selected.slice('tier:'.length).toUpperCase();
-                const key = `HADAMARD_DEFAULT_${tier}_MODEL`;
+            if (selected === 'model') {
                 const model = await promptText({
-                    title: `Configure ${tier.toLowerCase()} model`,
+                    title: 'Configure default model',
                     label: 'Model ID',
-                    initial: env[key] ?? '',
+                    initial: env.HADAMARD_MODEL ?? sdk.config.model,
                 });
                 if (model !== undefined) {
                     if (model.trim())
-                        env[key] = model.trim();
+                        env.HADAMARD_MODEL = model.trim();
                     else
-                        delete env[key];
+                        delete env.HADAMARD_MODEL;
                     dirty = true;
                 }
+                continue;
+            }
+            if (selected === 'named') {
+                await manageBridgeConfigs();
             }
         }
     }
@@ -2986,23 +3093,14 @@ export async function runHadamardTui(options = {}) {
         });
         appendStatic([...formatInfoLine(`effort set to: ${currentEffort() ?? 'auto'}`), '']);
     }
-    // ── /goal: session-scoped goal managed by the shared GoalService ─────
+    // ── /goal: project-scoped goal managed by the shared GoalService ─────
     // The service is the single authority over goal lifecycle (see plan/13
     // P0.2); the TUI only reads and steers it (create/clear/pause/resume).
     // Complete/blocked are runtime-only transitions, set via the Goal tools.
-    function goalService() {
-        return GoalService.forSession(session);
-    }
-    async function setGoal(objective) {
-        await goalService().create({ objective });
-    }
-    async function clearGoal() {
-        await goalService().clear();
-    }
     function goalContextLine() {
         // Normalize through the shared Goal schema while keeping status rendering
         // synchronous over the already-cached Session metadata.
-        const goal = normalizeGoal(session.metadata[GOAL_METADATA_KEY], new Date().toISOString());
+        const goal = sdk.goals.peek(session.id);
         if (!goal)
             return '';
         const marks = {
@@ -3014,28 +3112,6 @@ export async function runHadamardTui(options = {}) {
         const mark = marks[goal.status ?? 'active'] ?? '';
         return ` · goal:${mark}${A.dim}${truncateToWidth(goal.objective, 30)}${A.reset}`;
     }
-    async function chooseOutputStyle(arg) {
-        const valid = OUTPUT_STYLES.map(s => s.id);
-        if (arg) {
-            if (!valid.includes(arg)) {
-                appendStatic([...formatErrorLine(`unknown output style: ${arg}. Valid: ${valid.join(', ')}`), '']);
-                return;
-            }
-            outputStyle = arg;
-            appendStatic([...formatInfoLine(`output style → ${outputStyle}`), '']);
-            return;
-        }
-        const selected = await selectItem({
-            title: 'Select output style',
-            subtitle: `Current: ${outputStyle}`,
-            searchable: false,
-            items: OUTPUT_STYLES.map(s => ({ id: s.id, label: s.label, description: s.description })),
-        });
-        if (selected) {
-            outputStyle = selected;
-            appendStatic([...formatInfoLine(`output style → ${outputStyle}`), '']);
-        }
-    }
     async function showSkills() {
         const skills = sdk.skills.listMetadata();
         if (skills.length === 0) {
@@ -3441,6 +3517,10 @@ export async function runHadamardTui(options = {}) {
         const spaceIndex = raw.indexOf(' ');
         const name = (spaceIndex === -1 ? raw.slice(1) : raw.slice(1, spaceIndex)).toLowerCase();
         const args = spaceIndex === -1 ? '' : raw.slice(spaceIndex + 1).trim();
+        if (!canRunInteractiveCommand(name, running)) {
+            appendStatic(formatInfoLine(`/${name} requires an idle session; it will be available after this run`));
+            return;
+        }
         appendStatic(formatUserPrompt(raw));
         commandBusy = true;
         renderDynamic();
@@ -3467,6 +3547,7 @@ export async function runHadamardTui(options = {}) {
                 }
                 case 'clear':
                     process.stdout.write('\x1b[2J\x1b[H');
+                    screen.setDynamic([]);
                     renderDynamic();
                     return;
                 case 'init': {
@@ -3493,8 +3574,71 @@ export async function runHadamardTui(options = {}) {
                         await chooseRouter(args.slice('router'.length).trim());
                         return;
                     }
-                    await session.setModel(args === 'default' ? sdk.config.model : args);
-                    appendStatic([...formatInfoLine(`model set to: ${session.model}`), '']);
+                    if (args === 'custom' || args.startsWith('custom ')) {
+                        const customModel = args.slice('custom'.length).trim();
+                        if (!customModel) {
+                            appendStatic([...formatErrorLine('usage: /model custom <model-id>'), '']);
+                            return;
+                        }
+                        await disableBridge();
+                        await session.setModel(customModel);
+                        appendStatic([...formatInfoLine(`custom model: ${session.model}`), '']);
+                        return;
+                    }
+                    const catalog = buildModelConfigurationCatalog({ model: sdk.config.model, provider: sdk.config.provider, baseURL: sdk.config.baseURL }, readBridgeConfigs().configs);
+                    // `/model <config>` or `/model <config> <model-id>` — match the longest
+                    // known configuration name so model ids with spaces still work.
+                    let config = findModelConfiguration(catalog, args);
+                    let explicitModel;
+                    if (!config) {
+                        const tokens = args.split(/\s+/u).filter(Boolean);
+                        for (let i = tokens.length - 1; i >= 1; i -= 1) {
+                            const candidate = tokens.slice(0, i).join(' ');
+                            const match = findModelConfiguration(catalog, candidate);
+                            if (match) {
+                                config = match;
+                                explicitModel = tokens.slice(i).join(' ');
+                                break;
+                            }
+                        }
+                    }
+                    if (!config) {
+                        appendStatic([
+                            ...formatErrorLine(`unknown model configuration: ${args}`),
+                            ...formatInfoLine('Use /model to choose one, or /model custom <model-id>.'),
+                            '',
+                        ]);
+                        return;
+                    }
+                    if (config.source === 'default') {
+                        await disableBridge();
+                        await session.setModel(explicitModel || sdk.config.model);
+                        appendStatic([...formatInfoLine(`model configuration: default · ${session.model}`), '']);
+                        return;
+                    }
+                    if (!config.config)
+                        return;
+                    let selectedConfig = { ...config.config, model: config.model };
+                    if (explicitModel) {
+                        selectedConfig = { ...selectedConfig, model: explicitModel };
+                    }
+                    else if (config.models.length > 1) {
+                        const model = await selectItem({
+                            title: config.name,
+                            subtitle: 'Select a model from this configuration',
+                            searchable: true,
+                            items: config.models.map(item => ({
+                                id: item.name,
+                                label: item.name,
+                                description: item.modality ?? 'text',
+                            })),
+                        });
+                        if (!model)
+                            return;
+                        selectedConfig = { ...selectedConfig, model };
+                    }
+                    await activateBridgeConfig(selectedConfig);
+                    appendStatic([...formatInfoLine(`model configuration: ${activeBridgeConfig?.name ?? config.name} · ${bridgeModelLabel ?? session.model}`), '']);
                     return;
                 }
                 case 'effort':
@@ -3503,9 +3647,6 @@ export async function runHadamardTui(options = {}) {
                     else
                         await setEffort(args.toLowerCase());
                     return;
-                case 'output-style':
-                    await chooseOutputStyle(args.toLowerCase());
-                    return;
                 case 'permissions': {
                     // Three presets, selectable or named directly:
                     //   read-only  → deny mutating tools (read / search / web only)
@@ -3761,27 +3902,27 @@ export async function runHadamardTui(options = {}) {
                     ]);
                     return;
                 case 'memory': {
-                    if (/^(proposals|apply|reject)\b/u.test(args)) {
-                        try {
-                            const { MemoryProposalCommandService } = await import('../memory/memoryProposalCommandService.js');
-                            const result = await new MemoryProposalCommandService(sdk.config.homeDir, sdk.config.workDir).execute(args);
-                            appendStatic([
-                                ...formatInfoLine(result.message),
-                                ...(result.items ?? []).map(item => `  ${A.bold}${item.label}${A.reset}${item.description ? ` ${A.dim}· ${item.description}${A.reset}` : ''}`),
-                                '',
-                            ]);
-                        }
-                        catch (error) {
-                            appendStatic([...formatErrorLine(error instanceof Error ? error.message : String(error)), '']);
-                        }
-                        return;
-                    }
                     try {
-                        const state = await session.compactState();
-                        appendStatic([`${A.dim}${JSON.stringify(state, null, 2)}${A.reset}`, '']);
+                        const { HadamardMemoryCommandService } = await import('../memory/memoryCommandService.js');
+                        const result = await new HadamardMemoryCommandService({
+                            memory: sdk.memory,
+                            proposals: sdk.memoryProposals,
+                            compactConfig: sdk.config.compact,
+                            getState: () => session.compactState(),
+                        }).execute(args || 'status');
+                        appendStatic([
+                            `${A.bold}${result.title}${A.reset}`,
+                            ...formatInfoLine(result.message),
+                            ...(result.text ? result.text.split('\n').map(line => `${A.dim}${line}${A.reset}`) : []),
+                            ...(result.items ?? []).flatMap(item => [
+                                `  ${A.bold}${item.label}${A.reset}${item.description ? ` ${A.dim}· ${item.description}${A.reset}` : ''}`,
+                                ...(item.detail ? [`    ${A.dim}${item.detail}${A.reset}`] : []),
+                            ]),
+                            '',
+                        ]);
                     }
                     catch (error) {
-                        appendStatic([...formatErrorLine(error.message), '']);
+                        appendStatic([...formatErrorLine(error instanceof Error ? error.message : String(error)), '']);
                     }
                     return;
                 }
@@ -3789,7 +3930,9 @@ export async function runHadamardTui(options = {}) {
                     // Break down what is consuming the context window (gap #9 vs
                     // claude-code's /context) — usage, messages, system prompt, tools,
                     // the loaded CLAUDE.md sources, and the active config.
-                    const window = sdk.config.compact?.contextWindowTokens ?? 200_000;
+                    const { resolveHadamardCompactBudget } = await import('../runtime/hadamardCompact.js');
+                    const compactBudget = resolveHadamardCompactBudget(sdk.config.compact);
+                    const window = compactBudget.effectiveContextWindowTokens;
                     const used = lastTokenEstimate ?? 0;
                     const pct = window > 0 ? Math.min(100, Math.round((used / window) * 100)) : 0;
                     const usedK = used >= 1000 ? `${(used / 1000).toFixed(1)}k` : `${used}`;
@@ -3805,6 +3948,8 @@ export async function runHadamardTui(options = {}) {
                     appendStatic([
                         `${A.bold}Context window${A.reset}`,
                         `  ${ctxColor}${pct}% used (${usedK} / ${windowK} tokens)${A.reset}`,
+                        `  ${A.dim}raw window${A.reset}      ${compactBudget.rawContextWindowTokens}`,
+                        `  ${A.dim}compact limit${A.reset}  ${compactBudget.autoCompactTokenLimit} (${compactBudget.source})`,
                         `  ${A.dim}messages${A.reset}        ${messages}`,
                         `  ${A.dim}system prompt${A.reset}   ~${sysChars} chars`,
                         `  ${A.dim}tools${A.reset}           ${toolMetadata.length}${mcpCount > 0 ? ` (${mcpCount} MCP)` : ''}`,
@@ -3911,43 +4056,8 @@ export async function runHadamardTui(options = {}) {
                     return;
                 }
                 case 'goal': {
-                    const arg = args.trim();
-                    const svc = goalService();
-                    if (!arg) {
-                        const g = await svc.read();
-                        if (!g) {
-                            appendStatic([...formatInfoLine('no goal set — use /goal <objective> to set one'), '']);
-                        }
-                        else {
-                            const marks = { active: `${A.green}▶ active${A.reset}`, paused: `${A.yellow}‖ paused${A.reset}`, complete: `${A.dim}✓ complete${A.reset}`, blocked: `${A.red}⊘ blocked${A.reset}` };
-                            appendStatic([`${A.bold}Goal${A.reset}  ${marks[g.status] ?? ''}  ${A.dim}${g.createdAt.slice(0, 10)}${A.reset}`, `  ${g.objective}`, '']);
-                        }
-                        return;
-                    }
-                    if (arg === 'clear') {
-                        await clearGoal();
-                        appendStatic([...formatInfoLine('goal cleared'), '']);
-                        return;
-                    }
-                    if (arg === 'pause') {
-                        const r = await svc.transition('paused');
-                        appendStatic(r.ok ? [...formatInfoLine('goal paused'), ''] : [...formatInfoLine(r.message), '']);
-                        return;
-                    }
-                    if (arg === 'resume') {
-                        const r = await svc.transition('active');
-                        appendStatic(r.ok ? [...formatInfoLine('goal resumed'), ''] : [...formatInfoLine(r.message), '']);
-                        return;
-                    }
-                    if (arg === 'complete' || arg === 'done') {
-                        // Complete is a runtime-only transition requiring evidence; the UI
-                        // cannot mark a goal complete without evidence. Steer the user to
-                        // let the agent complete it via UpdateGoal, or clear it instead.
-                        appendStatic([...formatInfoLine('goal completion requires runtime evidence — ask the agent to call UpdateGoal with status "complete", or use /goal clear'), '']);
-                        return;
-                    }
-                    await setGoal(arg);
-                    appendStatic([...formatInfoLine(`goal set — ${arg}`), '']);
+                    const commandResult = await sdk.goals.command(session, args);
+                    appendStatic([...formatInfoLine(commandResult.message), '']);
                     return;
                 }
                 case 'review': {
@@ -3974,7 +4084,6 @@ export async function runHadamardTui(options = {}) {
                         `  ${A.dim}tokens${A.reset}       ${fmtTok(totalInputTokens)} in · ${fmtTok(totalOutputTokens)} out`,
                         `  ${A.dim}tools${A.reset}        ${toolMetadata.length}${toolMetadata.filter(t => t.provider === 'mcp').length ? ` (${toolMetadata.filter(t => t.provider === 'mcp').length} MCP)` : ''}`,
                         `  ${A.dim}model${A.reset}       ${session.model}${bridgeMode && activeBridgeConfig ? ` · bridge:${activeBridgeConfig.name}` : ''}`,
-                        `  ${A.dim}output style${A.reset} ${outputStyle}`,
                         `  ${A.dim}plan mode${A.reset}   ${session.permissionContext.mode === 'plan' ? 'on' : 'off'}`,
                         '',
                     ]);
@@ -4304,8 +4413,40 @@ export async function runHadamardTui(options = {}) {
                         await runSavedWorkflow(runSpace === -1 ? runRest : runRest.slice(0, runSpace), runSpace === -1 ? undefined : runRest.slice(runSpace + 1).trim());
                         return;
                     }
+                    if (args.startsWith('delete ')) {
+                        const name = args.slice(7).trim();
+                        if (!name) {
+                            appendStatic([...formatErrorLine('usage: /workflows delete <name>'), '']);
+                            return;
+                        }
+                        const removed = await deleteWorkflow(name, sdk.config.workDir);
+                        appendStatic([...formatInfoLine(removed ? `deleted workflow: ${name}` : `workflow not found: ${name}`), '']);
+                        return;
+                    }
+                    if (args.startsWith('save ')) {
+                        const rest = args.slice(5).trim();
+                        const split = rest.indexOf(' ');
+                        if (split === -1) {
+                            appendStatic([...formatErrorLine('usage: /workflows save <name> <script-path> [--overwrite]'), '']);
+                            return;
+                        }
+                        const name = rest.slice(0, split).trim();
+                        const pathParts = rest.slice(split + 1).trim().split(/\s+/);
+                        const overwrite = pathParts.includes('--overwrite');
+                        const scriptPath = pathParts.filter((part) => part !== '--overwrite').join(' ');
+                        try {
+                            const resolved = path.isAbsolute(scriptPath) ? scriptPath : path.resolve(sdk.config.workDir, scriptPath);
+                            const script = fs.readFileSync(resolved, 'utf8');
+                            const filePath = await saveWorkflow(name, script, { projectDir: sdk.config.workDir, overwrite });
+                            appendStatic([...formatInfoLine(`saved workflow: ${name} -> ${filePath}`), '']);
+                        }
+                        catch (error) {
+                            appendStatic([...formatErrorLine(error.message || String(error)), '']);
+                        }
+                        return;
+                    }
                     if (args && args !== 'list') {
-                        appendStatic([...formatErrorLine('usage: /workflows [list|run <name> [task]]'), '']);
+                        appendStatic([...formatErrorLine('usage: /workflows [list|run <name> [task]|save <name> <script-path>|delete <name>]'), '']);
                         return;
                     }
                     // No sub-command → selection picker.
@@ -4525,15 +4666,36 @@ export async function runHadamardTui(options = {}) {
                         }
                         return;
                     }
+                    if (args.startsWith('delete ')) {
+                        const teamName = args.slice(7).trim();
+                        if (!teamName) {
+                            appendStatic([...formatErrorLine('usage: /team delete <name>'), '']);
+                            return;
+                        }
+                        if (getBuiltInTeamDefinition(teamName)) {
+                            appendStatic([...formatErrorLine(`cannot delete built-in team: ${teamName}`), '']);
+                            return;
+                        }
+                        const removed = await deleteTeamDefinition(teamName, sdk.config.workDir);
+                        if (!removed) {
+                            appendStatic([...formatErrorLine(`team not found: ${teamName}`), '']);
+                            return;
+                        }
+                        if (activeTeamName === teamName) {
+                            activeTeamTool = null;
+                            activeTeamName = null;
+                        }
+                        appendStatic([...formatInfoLine(`deleted team: ${teamName}`), '']);
+                        return;
+                    }
                     if (args.startsWith('ask ')) {
                         const rest = args.slice(4).trim();
-                        const spaceIdx = rest.indexOf(' ');
-                        if (spaceIdx === -1) {
+                        const parsed = parseTeamAskArguments(rest);
+                        if (!parsed) {
                             appendStatic([...formatErrorLine('usage: /team ask <name> <prompt>'), '']);
                             return;
                         }
-                        const teamName = rest.slice(0, spaceIdx);
-                        const prompt = rest.slice(spaceIdx + 1).trim();
+                        const { name: teamName, prompt } = parsed;
                         const loaded = loadTeamDefinition(teamName, sdk.config.workDir);
                         if (!loaded) {
                             appendStatic([...formatErrorLine(`team not found: ${teamName}`), '']);
@@ -4559,7 +4721,6 @@ export async function runHadamardTui(options = {}) {
                             '',
                         ]);
                         try {
-                            const team = createModelTeam(definition);
                             const teamRunView = createTeamRunViewState(definition.name);
                             const printTeamRunTree = () => {
                                 const lines = formatTeamRunTreeLines(teamRunView);
@@ -4567,7 +4728,7 @@ export async function runHadamardTui(options = {}) {
                                     return;
                                 appendStatic([...lines.map((line) => `${A.dim}${line}${A.reset}`), '']);
                             };
-                            const result = await team.ask(prompt, undefined, {
+                            const result = await askTeamDefinition(definition, prompt, undefined, {
                                 workDir: sdk.config.workDir,
                                 onEvent: (e) => {
                                     applyTeamRunEvent(teamRunView, e);
@@ -5235,17 +5396,31 @@ export async function runHadamardTui(options = {}) {
         }
     }
     // ── Submit / key handling ──────────────────────────────────────────
-    async function submit() {
-        if (!running && applyAtCompletion()) {
+    /** If the editor was emptied after ↑-recall, put the follow-up back in queue. */
+    function restoreRecalledFollowUpIfAbandoned() {
+        if (!recalledFollowUp || !editor.isEmpty())
+            return;
+        restoreAbandonedFollowUp(session, recalledFollowUp);
+        recalledFollowUp = null;
+    }
+    async function submit(mode = 'follow-up') {
+        if (applyAtCompletion()) {
             renderDynamic();
             return;
         }
-        const selectedCommand = !running
-            ? selectInteractiveCommand(editor.text, menuSelected)
-            : undefined;
+        const selectedCommand = selectInteractiveCommand(editor.text, menuSelected);
         if (selectedCommand) {
+            const selectedName = selectedCommand.slice(1).split(/\s/u, 1)[0] ?? '';
+            // Slash completions are not a resubmit of the recalled follow-up.
+            restoreAbandonedFollowUp(session, recalledFollowUp);
+            recalledFollowUp = null;
             editor.clear();
             menuSelected = 0;
+            if (running && !canRunInteractiveCommand(selectedName, true)) {
+                appendStatic(formatInfoLine(`/${selectedName} requires an idle session; it will be available after this run`));
+                renderDynamic();
+                return;
+            }
             // A selected completion already contains its subcommand. Keeping the
             // partially typed second word would turn `/agents runs` into
             // `/agents runs runs` on Enter.
@@ -5260,17 +5435,31 @@ export async function runHadamardTui(options = {}) {
         const text = value.trim();
         menuSelected = 0;
         if (!text) {
+            restoreRecalledFollowUpIfAbandoned();
             renderDynamic();
             return;
         }
         if (running) {
             if (text.startsWith('/')) {
-                appendStatic(formatInfoLine('slash commands are unavailable while the agent is working'));
+                // Slash commands are not a resubmit of the recalled follow-up.
+                restoreAbandonedFollowUp(session, recalledFollowUp);
+                recalledFollowUp = null;
+                const command = text.slice(1).trim().split(/\s/u, 1)[0]?.toLowerCase() ?? '';
+                if (!canRunInteractiveCommand(command, true)) {
+                    appendStatic(formatInfoLine(`/${command} requires an idle session; it will be available after this run`));
+                    renderDynamic();
+                    return;
+                }
+                await runSlashCommand(text);
                 renderDynamic();
                 return;
             }
-            session.steer(text);
-            appendStatic(formatQueuedPrompt(text));
+            // Resubmit consumes the recalled draft (re-queued below).
+            recalledFollowUp = null;
+            submitActiveInput(session, text, mode);
+            appendStatic(mode === 'steer'
+                ? formatInfoLine(`steering now: ${text.replace(/\s+/g, ' ')}`)
+                : formatQueuedPrompt(text));
             renderDynamic();
             return;
         }
@@ -5279,9 +5468,12 @@ export async function runHadamardTui(options = {}) {
             return;
         }
         if (text.startsWith('/')) {
+            restoreAbandonedFollowUp(session, recalledFollowUp);
+            recalledFollowUp = null;
             await runSlashCommand(text);
             return;
         }
+        recalledFollowUp = null;
         void startRun(text);
     }
     function handleDialogKey(key) {
@@ -5462,6 +5654,7 @@ export async function runHadamardTui(options = {}) {
                     else if (!editor.isEmpty()) {
                         editor.clear();
                         menuSelected = 0;
+                        restoreRecalledFollowUpIfAbandoned();
                     }
                     renderDynamic();
                     return;
@@ -5472,6 +5665,7 @@ export async function runHadamardTui(options = {}) {
                         return;
                     }
                     editor.deleteForward();
+                    restoreRecalledFollowUpIfAbandoned();
                     break;
                 case 'a':
                     editor.moveHome();
@@ -5481,12 +5675,15 @@ export async function runHadamardTui(options = {}) {
                     break;
                 case 'k':
                     editor.killToEnd();
+                    restoreRecalledFollowUpIfAbandoned();
                     break;
                 case 'u':
                     editor.killToStart();
+                    restoreRecalledFollowUpIfAbandoned();
                     break;
                 case 'w':
                     editor.deleteWordLeft();
+                    restoreRecalledFollowUpIfAbandoned();
                     break;
                 case 'left':
                     editor.moveWordLeft();
@@ -5508,6 +5705,13 @@ export async function runHadamardTui(options = {}) {
         }
         switch (name) {
             case 'return': {
+                if (key.shift) {
+                    if (running)
+                        void submit('steer');
+                    else
+                        editor.insert('\n');
+                    return;
+                }
                 if (key.meta) {
                     editor.insert('\n');
                     break;
@@ -5516,6 +5720,10 @@ export async function runHadamardTui(options = {}) {
                 return;
             }
             case 'enter':
+                if (key.shift && running) {
+                    void submit('steer');
+                    return;
+                }
                 editor.insert('\n');
                 break;
             case 'escape': {
@@ -5525,6 +5733,7 @@ export async function runHadamardTui(options = {}) {
                 else if (!editor.isEmpty()) {
                     editor.clear();
                     menuSelected = 0;
+                    restoreRecalledFollowUpIfAbandoned();
                 }
                 break;
             }
@@ -5532,9 +5741,11 @@ export async function runHadamardTui(options = {}) {
                 editor.backspace();
                 menuSelected = 0;
                 atSelected = 0;
+                restoreRecalledFollowUpIfAbandoned();
                 break;
             case 'delete':
                 editor.deleteForward();
+                restoreRecalledFollowUpIfAbandoned();
                 break;
             case 'left':
                 if (key.meta)
@@ -5555,6 +5766,14 @@ export async function runHadamardTui(options = {}) {
                 editor.moveEnd();
                 break;
             case 'up': {
+                if (running && editor.isEmpty()) {
+                    const recalled = recallLatestFollowUp(session);
+                    if (recalled) {
+                        recalledFollowUp = recalled;
+                        editor.setText(recalled);
+                        break;
+                    }
+                }
                 const atToken = activeAtToken(editor.text, editor.cursor);
                 const atCount = atToken ? atCompletions(atToken.token).length : 0;
                 const menu = filterSlashCommands(editor.text);