@kolisachint/hoocode-agent 0.5.57 → 0.5.59

package/dist/modes/interactive/interactive-mode.js

@@ -11,6 +11,7 @@ import { isLongRetryDelayError } from "@kolisachint/hoocode-ai";
 import { Box, CombinedAutocompleteProvider, Container, fuzzyFilter, getCapabilities, hyperlink, Loader, Markdown, matchesKey, ProcessTerminal, Spacer, setKeybindings, Text, TUI, } from "@kolisachint/hoocode-tui";
 import { spawnSync } from "child_process";
 import { APP_NAME, APP_TITLE, VERSION } from "../../config.js";
+import { TASK_TOOL_NAME } from "../../core/agent-frontmatter.js";
 import { setTerminalOwnedByTui } from "../../core/agent-log.js";
 import { loadAgentRegistry } from "../../core/agent-registry.js";
 import { parseSkillBlock } from "../../core/agent-session.js";
@@ -51,7 +52,7 @@ import { CustomEditor } from "./components/custom-editor.js";
 import { CustomMessageComponent } from "./components/custom-message.js";
 import { DynamicBorder } from "./components/dynamic-border.js";
 import { FooterComponent } from "./components/footer.js";
-import { keyHint, keyText, rawKeyHint } from "./components/keybinding-hints.js";
+import { appKeyLabel, keyHint, keyText, rawKeyHint } from "./components/keybinding-hints.js";
 import { renderSessionChip } from "./components/session-chip.js";
 import { SessionColorSelectorComponent } from "./components/session-color-selector.js";
 import { SessionSelectorComponent } from "./components/session-selector.js";
@@ -185,6 +186,8 @@ export class InteractiveMode {
     startupNoticesShown = false;
     // Status line tracking (for mutating immediately-sequential status updates)
     lastStatusSpacer = undefined;
+    /** Dial reverses already named this session; see showDialStep. */
+    dialReverseTaught = new Set();
     lastStatusText = undefined;
     // Streaming message tracking
     streamingComponent = undefined;
@@ -375,7 +378,7 @@ export class InteractiveMode {
             await this.rebindCurrentSession();
         });
         this.version = VERSION;
-        this.ui = new TUI(new ProcessTerminal(), this.settingsManager.getShowHardwareCursor());
+        this.ui = new TUI(options.terminal ?? new ProcessTerminal(), this.settingsManager.getShowHardwareCursor());
         this.ui.setClearOnShrink(this.settingsManager.getClearOnShrink());
         this.headerContainer = new Container();
         this.chatContainer = new Container();
@@ -461,6 +464,7 @@ export class InteractiveMode {
             },
             showSelector: (create) => this.showSelector(create),
             showStatus: (message) => this.showStatus(message),
+            showDialStep: (backward, message) => this.showDialStep(backward, message),
             showError: (message) => this.showError(message),
             showWarning: (message) => this.showWarning(message),
             showNotice: (title, body) => this.showNotice(title, body),
@@ -709,33 +713,53 @@ export class InteractiveMode {
                 : theme.bold(theme.fg("accent", APP_NAME)) + theme.fg("dim", ` v${this.version}`);
             // Build startup instructions using keybinding hint helpers
             const hint = (keybinding, description) => keyHint(keybinding, description);
+            // A dial as one line in one shape: the key steps it forward, the same
+            // key with shift steps it back. The banner is where that rule is first
+            // read, and it is the rule covering the most-pressed keys in the app,
+            // so the dials are listed together rather than scattered by topic.
+            // appKeyLabel, not keyText: the thinking dial answers to shift+tab as well,
+            // and splicing that into the middle of `alt+t/shift+alt+t` would hide the
+            // one shape these six lines exist to show.
+            const dial = (forward, backward, subject) => rawKeyHint(`${appKeyLabel(forward)}/${appKeyLabel(backward)}`, `to step ${subject}`);
+            // Grouped the way the map itself is (see core/keybindings.ts): by what you
+            // are trying to do, not by what the widget is. A flat list of thirty
+            // hints is a wall nobody reads; five short groups with a heading each is
+            // something a person can skim once and place a key in later.
+            const group = (title) => theme.fg("dim", `\n${title}`);
             const expandedInstructions = [
+                group("Compose — the message in your hands"),
+                hint("app.editor.external", "for external editor"),
+                hint("app.input.voiceTranscribe", "to speak instead of type"),
+                hint("app.clipboard.pasteImage", "to paste image"),
+                hint("app.message.followUp", "to queue follow-up"),
+                hint("app.message.dequeue", "to edit all queued messages"),
+                rawKeyHint("drop files", "to attach"),
+                rawKeyHint("/", "for commands"),
+                rawKeyHint("!", "to run bash"),
+                rawKeyHint("!!", "to run bash (no context)"),
+                group("Steer — what the agent is before it runs"),
+                dial("app.mode.cycleForward", "app.mode.cycleBackward", "agent mode (ask/plan/build/debug)"),
+                dial("app.model.cycleForward", "app.model.cycleBackward", "model — /model to pick one"),
+                dial("app.thinking.cycleForward", "app.thinking.cycleBackward", "thinking level"),
+                group("Read — what you see of what it did"),
+                dial("app.view.cycleForward", "app.view.cycleBackward", "tool output (radar/peek/full)"),
+                dial("app.tasks.cycleForward", "app.tasks.cycleBackward", "task panel view"),
+                hint("app.tools.expand", "to jump to full output and back"),
+                hint("app.thinking.toggle", "to show or hide thinking"),
+                ...(this.teamFocus.connected ? [hint("app.team.focus", "to focus team roster")] : []),
+                group("Go — sessions and places"),
+                hint("app.session.resume", "to resume a session"),
+                hint("app.session.changeDirectory", "to change working directory"),
+                dial("app.session.color.cycleForward", "app.session.color.cycleBackward", "session colour"),
+                hint("app.settings.open", "for settings"),
+                hint("app.hotkeys.open", "for all shortcuts"),
+                group("Flow — getting out, getting back"),
                 hint("app.interrupt", "to interrupt"),
                 hint("app.clear", "to clear"),
                 rawKeyHint(`${keyText("app.clear")} twice`, "to exit"),
                 hint("app.exit", "to exit (empty)"),
                 hint("app.suspend", "to suspend"),
                 keyHint("tui.editor.deleteToLineEnd", "to delete to end"),
-                hint("app.thinking.cycle", "to cycle thinking level"),
-                rawKeyHint(`${keyText("app.model.cycleForward")}/${keyText("app.model.cycleBackward")}`, "to cycle models"),
-                hint("app.model.select", "to select model"),
-                hint("app.tools.expand", "to jump to full output and back"),
-                hint("app.view.cycleForward", "to cycle tool output (radar/peek/full)"),
-                hint("app.thinking.toggle", "to expand thinking"),
-                hint("app.tasks.cycleView", "to cycle task panel view"),
-                ...(this.teamFocus.connected ? [hint("app.team.focus", "to focus team roster")] : []),
-                hint("app.mode.cycle", "to cycle agent mode"),
-                hint("app.session.changeDirectory", "to change working directory"),
-                hint("app.settings.open", "for settings"),
-                hint("app.hotkeys.open", "for all shortcuts"),
-                hint("app.editor.external", "for external editor"),
-                rawKeyHint("/", "for commands"),
-                rawKeyHint("!", "to run bash"),
-                rawKeyHint("!!", "to run bash (no context)"),
-                hint("app.message.followUp", "to queue follow-up"),
-                hint("app.message.dequeue", "to edit all queued messages"),
-                hint("app.clipboard.pasteImage", "to paste image"),
-                rawKeyHint("drop files", "to attach"),
             ].join("\n");
             const onboarding = theme.fg("dim", `${APP_NAME} can explain its own features and look up its docs. Ask it how to use or extend ${APP_NAME}.`);
             this.builtInHeader = new ExpandableText(() => logo(), () => `${logo()}\n${expandedInstructions}\n\n${onboarding}`, this.getStartupExpansionState(), 1, 0);
@@ -767,7 +791,7 @@ export class InteractiveMode {
         setTerminalOwnedByTui(true);
         this.isInitialized = true;
         // Initialize extensions first so resources are shown before messages
-        await this.rebindCurrentSession();
+        await this.rebindCurrentSession({ renderResources: true });
         // Render initial messages AFTER showing loaded resources
         this.renderInitialMessages();
         // Set up theme file watcher
@@ -1057,26 +1081,28 @@ export class InteractiveMode {
                 this.showExtensionError(error.extensionPath, error.error, error.stack);
             },
         });
-        setRegisteredThemes(this.session.resourceLoader.getThemes().themes);
         this.setupAutocompleteProvider();
-        const extensionRunner = this.session.extensionRunner;
-        this.setupExtensionShortcuts(extensionRunner);
-        // The startup path draws the listing here, because it renders messages
-        // without clearing. A *rebind* (/new, /resume, /fork) clears the transcript
-        // straight afterwards, so `renderCurrentSessionState` draws it again — this
-        // call is the one startup keeps.
-        this.showLoadedResources({ force: false, showDiagnosticsWhenQuiet: true });
-        this.showStartupNoticesIfNeeded();
+        this.setupExtensionShortcuts(this.session.extensionRunner);
     }
+    /**
+     * Push the current settings and session onto the chrome: keybindings, footer,
+     * editor, cursor.
+     *
+     * Startup, a session swap (/new, /resume, /fork, /cd) and /reload all rebuild
+     * the same things from disk, so they must all repaint the same way. They used
+     * to do it with two hand-kept copies of this list, and the /reload copy was
+     * missing pieces — a `compaction.enabled` edit left the footer still
+     * promising auto-compaction. One list, called from both paths; the theme is
+     * the second half, in `applySessionTheme`.
+     */
     applyRuntimeSettings() {
+        // Keybindings first: what follows is drawn with the hints they name.
+        this.keybindings.reload();
         this.footer.setSession(this.session);
         this.footer.setAutoCompactEnabled(this.session.autoCompactionEnabled);
         this.footer.setToolOutputView(this.toolOutputView);
-        // The startup banner names the cwd, which `/cd` changes under it.
-        if (this.builtInHeader instanceof ExpandableText) {
-            this.builtInHeader.refresh();
-        }
         this.footerDataProvider.setCwd(this.sessionManager.getCwd());
+        this.footerDataProvider.setSubagentEnabled(this.session.getActiveToolNames().includes(TASK_TOOL_NAME));
         this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
         this.ui.setShowHardwareCursor(this.settingsManager.getShowHardwareCursor());
         this.ui.setClearOnShrink(this.settingsManager.getClearOnShrink());
@@ -1092,15 +1118,63 @@ export class InteractiveMode {
             this.editor.setAutocompleteMaxVisible?.(autocompleteMaxVisible);
         }
     }
-    async rebindCurrentSession() {
+    /**
+     * Load the theme the settings name, and rebuild what holds colour baked in.
+     *
+     * Runs after extensions are bound (and after `session.reload()`), because a
+     * `resources_discover` handler can contribute the very theme directory the
+     * name resolves in — resolving it earlier would fall back to dark for anyone
+     * whose theme ships with an extension.
+     *
+     * The banner is rebuilt rather than invalidated: a `Text` holds its string
+     * with the escapes already in it, so invalidating only drops the line cache
+     * and the old theme's colours come straight back. It also names the working
+     * directory, which `/cd` moves.
+     */
+    applySessionTheme() {
+        setRegisteredThemes(this.session.resourceLoader.getThemes().themes);
+        const themeName = this.settingsManager.getTheme();
+        if (themeName) {
+            const themeResult = setTheme(themeName, true);
+            if (!themeResult.success) {
+                this.showError(`Failed to load theme "${themeName}": ${themeResult.error}\nFell back to dark theme.`);
+            }
+        }
+        const activeHeader = this.chrome.customHeader ?? this.builtInHeader;
+        if (isExpandable(activeHeader)) {
+            activeHeader.setExpanded(this.getStartupExpansionState());
+        }
+    }
+    /**
+     * The half of the chrome refresh that has to wait for extensions to bind:
+     * they can swap the editor out from under us, and the provider count is only
+     * final once their `registerProvider` calls have run.
+     */
+    async finishRuntimeSettings() {
+        await this.modelController.updateAvailableProviderCount();
+        this.updateEditorBorderColor();
+        this.refreshSessionIdentity();
+    }
+    /**
+     * Rebind the mode to whatever session the runtime now holds.
+     *
+     * `renderResources` belongs to startup alone: it renders into a transcript it
+     * never clears, so the listing has to be drawn here. Every other caller
+     * clears the transcript straight afterwards and draws the listing itself
+     * through `renderCurrentSessionState`.
+     */
+    async rebindCurrentSession(options) {
         this.unsubscribe?.();
         this.unsubscribe = undefined;
         this.applyRuntimeSettings();
         await this.bindCurrentSessionExtensions();
+        this.applySessionTheme();
+        if (options?.renderResources) {
+            this.showLoadedResources({ force: false, showDiagnosticsWhenQuiet: true });
+            this.showStartupNoticesIfNeeded();
+        }
         this.subscribeToAgent();
-        await this.modelController.updateAvailableProviderCount();
-        this.updateEditorBorderColor();
-        this.refreshSessionIdentity();
+        await this.finishRuntimeSettings();
     }
     async handleFatalRuntimeError(prefix, error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -1110,26 +1184,35 @@ export class InteractiveMode {
         process.exit(1);
     }
     /**
-     * Reset the transcript to whatever the (possibly just-swapped) session holds.
-     *
-     * Every caller — /new, /resume, /fork — reaches here *after* the runtime has
-     * rebound extensions, and rebinding is what renders the loaded-resource
-     * listing. Clearing the chat therefore wiped the listing a moment after it was
-     * drawn, which is why /reload showed skills, agents and plugins and starting a
-     * new session showed nothing. Re-rendering it here is what makes the surface
-     * common: one call site, so a session change of any kind reports the same
-     * capabilities /reload does.
+     * Drop every view-layer reference into the transcript that is about to be
+     * rebuilt. Shared by the session swaps and by /reload: a component that
+     * survives the clear is detached, so anything still pointing at it (the open
+     * chain the next tool call would join, the block the unfold key peels back)
+     * would be writing to a frame nobody renders.
      */
-    renderCurrentSessionState() {
+    resetTranscriptView() {
         this.chatContainer.clear();
         this.openChain = undefined;
         this.latestToolBlock = undefined;
         this.latestChain = undefined;
-        this.pendingMessagesContainer.clear();
-        this.messageQueue.resetCompactionQueue();
         this.streamingComponent = undefined;
         this.streamingMessage = undefined;
         this.pendingTools.clear();
+    }
+    /**
+     * Reset the transcript to whatever the just-swapped session holds.
+     *
+     * Every caller — /new, /resume, /fork, /cd, /import — reaches here after the
+     * runtime has rebound extensions. Drawing the listing here rather than in the
+     * rebind is what makes the surface common: one call site, so a session change
+     * of any kind reports the same capabilities /reload does, and neither path
+     * draws the listing twice.
+     */
+    renderCurrentSessionState() {
+        this.resetTranscriptView();
+        // Queues belong to the session that is going away, not to the new one.
+        this.pendingMessagesContainer.clear();
+        this.messageQueue.resetCompactionQueue();
         this.showLoadedResources({ force: false, showDiagnosticsWhenQuiet: true });
         this.renderInitialMessages();
     }
@@ -1510,7 +1593,8 @@ export class InteractiveMode {
         this.defaultEditor.onAction("app.clear", () => this.handleCtrlC());
         this.defaultEditor.onCtrlD = () => this.handleCtrlD();
         this.defaultEditor.onAction("app.suspend", () => this.handleCtrlZ());
-        this.defaultEditor.onAction("app.thinking.cycle", () => this.cycleThinkingLevel());
+        this.defaultEditor.onAction("app.thinking.cycleForward", () => this.cycleThinkingLevel("forward"));
+        this.defaultEditor.onAction("app.thinking.cycleBackward", () => this.cycleThinkingLevel("backward"));
         this.defaultEditor.onAction("app.model.cycleForward", () => this.modelController.cycleModel("forward"));
         this.defaultEditor.onAction("app.model.cycleBackward", () => this.modelController.cycleModel("backward"));
         // Global debug handler on TUI (works regardless of focus)
@@ -1520,8 +1604,11 @@ export class InteractiveMode {
         this.defaultEditor.onAction("app.view.cycleForward", () => this.cycleToolOutputView("forward"));
         this.defaultEditor.onAction("app.view.cycleBackward", () => this.cycleToolOutputView("backward"));
         this.defaultEditor.onAction("app.thinking.toggle", () => this.toggleThinkingBlockVisibility());
-        this.defaultEditor.onAction("app.tasks.cycleView", () => {
-            this.taskPanel.cycleView();
+        this.defaultEditor.onAction("app.tasks.cycleForward", () => {
+            this.taskPanel.cycleView("forward");
+        });
+        this.defaultEditor.onAction("app.tasks.cycleBackward", () => {
+            this.taskPanel.cycleView("backward");
         });
         this.defaultEditor.onAction("app.team.focus", () => this.teamFocus.enterFocus());
         this.defaultEditor.onAction("app.editor.external", () => this.openExternalEditor());
@@ -1542,7 +1629,8 @@ export class InteractiveMode {
         this.defaultEditor.onAction("app.session.color.cycleBackward", () => this.cycleSessionColor("backward"));
         this.defaultEditor.onAction("app.settings.open", () => this.showSettingsSelector());
         this.defaultEditor.onAction("app.hotkeys.open", () => this.commandExecutor.handleHotkeys());
-        this.defaultEditor.onAction("app.mode.cycle", () => void this.cycleAgentMode());
+        this.defaultEditor.onAction("app.mode.cycleForward", () => void this.cycleAgentMode("forward"));
+        this.defaultEditor.onAction("app.mode.cycleBackward", () => void this.cycleAgentMode("backward"));
         this.defaultEditor.onChange = (text) => {
             const wasBashMode = this.isBashMode;
             this.isBashMode = text.trimStart().startsWith("!");
@@ -2267,6 +2355,28 @@ export class InteractiveMode {
      * If multiple status messages are emitted back-to-back (without anything else being added to the chat),
      * we update the previous status line instead of appending new ones to avoid log spam.
      */
+    /**
+     * Report a dial step, and name the key that steps it back — once.
+     *
+     * The instant after someone moves a dial is the one moment they are primed to
+     * learn its other half: they have just used one direction and can feel the
+     * missing one. So the reverse rides along with the first step of each dial in
+     * a session and never again. A hint that repeats forever stops being read,
+     * and its cost falls entirely on the people who already know it.
+     *
+     * Only the three dials that announce their new value in the transcript come
+     * through here. The other three announce themselves where they live — the
+     * task panel prints its own key in its header, and the mode chip and view
+     * glyph change in place in the footer.
+     */
+    showDialStep(backward, message) {
+        if (this.dialReverseTaught.has(backward)) {
+            this.showStatus(message);
+            return;
+        }
+        this.dialReverseTaught.add(backward);
+        this.showStatus(theme.fg("dim", message) + theme.fg("halftone", `   ${keyText(backward)} steps back`));
+    }
     showStatus(message) {
         const children = this.chatContainer.children;
         const last = children.length > 0 ? children[children.length - 1] : undefined;
@@ -2650,15 +2760,15 @@ export class InteractiveMode {
         }
         this.ui.requestRender();
     }
-    cycleThinkingLevel() {
-        const newLevel = this.session.cycleThinkingLevel();
+    cycleThinkingLevel(direction) {
+        const newLevel = this.session.cycleThinkingLevel(direction);
         if (newLevel === undefined) {
             this.showStatus("Current model does not support thinking");
         }
         else {
             this.footer.invalidate();
             this.updateEditorBorderColor();
-            this.showStatus(`Thinking level: ${newLevel}`);
+            this.showDialStep("app.thinking.cycleBackward", `Thinking level: ${newLevel}`);
         }
     }
     /**
@@ -2834,7 +2944,7 @@ export class InteractiveMode {
      * is missing (a `--light` run strips the extension), the key says so instead
      * of guessing.
      */
-    async cycleAgentMode() {
+    async cycleAgentMode(direction) {
         const command = this.session.extensionRunner.getCommand("mode");
         if (!command) {
             this.showWarning("Modes are not available in this session");
@@ -2847,8 +2957,12 @@ export class InteractiveMode {
             return;
         }
         const current = this.footerDataProvider.getActiveMode();
+        // indexOf is -1 when the active mode is not in the list; stepping from
+        // there lands on the first mode going forward and the last going back,
+        // which is the useful answer either way.
         const index = modes.indexOf(current);
-        const next = modes[(index + 1) % modes.length];
+        const step = direction === "forward" ? 1 : -1;
+        const next = modes[(index + step + modes.length) % modes.length];
         await this.session.prompt(`/mode ${next}`);
     }
     /**
@@ -2865,7 +2979,7 @@ export class InteractiveMode {
         const slot = cycleSessionColorSlot(this.sessionManager.getSessionColorSlot(), direction);
         this.session.setSessionColor(slot);
         const name = sessionColorName(slot);
-        this.showStatus(`Session color: ${name ?? slot}`);
+        this.showDialStep("app.session.color.cycleBackward", `Session color: ${name ?? slot}`);
     }
     toggleThinkingBlockVisibility() {
         this.hideThinkingBlock = !this.hideThinkingBlock;
@@ -3635,40 +3749,25 @@ export class InteractiveMode {
         };
         try {
             await this.session.reload();
-            this.keybindings.reload();
-            const activeHeader = this.chrome.customHeader ?? this.builtInHeader;
-            if (isExpandable(activeHeader)) {
-                activeHeader.setExpanded(this.toolOutputExpanded);
-            }
-            setRegisteredThemes(this.session.resourceLoader.getThemes().themes);
-            this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
-            const themeName = this.settingsManager.getTheme();
-            const themeResult = themeName ? setTheme(themeName, true) : { success: true };
-            if (!themeResult.success) {
-                this.showError(`Failed to load theme "${themeName}": ${themeResult.error}\nFell back to dark theme.`);
-            }
-            const editorBorder = this.settingsManager.getEditorBorder();
-            const editorPaddingX = this.settingsManager.getEditorPaddingX();
-            const autocompleteMaxVisible = this.settingsManager.getAutocompleteMaxVisible();
-            this.defaultEditor.setBorder(editorBorder);
-            this.defaultEditor.setPaddingX(editorPaddingX);
-            this.defaultEditor.setAutocompleteMaxVisible(autocompleteMaxVisible);
-            if (this.editor !== this.defaultEditor) {
-                this.editor.setBorder?.(editorBorder);
-                this.editor.setPaddingX?.(editorPaddingX);
-                this.editor.setAutocompleteMaxVisible?.(autocompleteMaxVisible);
-            }
-            this.ui.setShowHardwareCursor(this.settingsManager.getShowHardwareCursor());
-            this.ui.setClearOnShrink(this.settingsManager.getClearOnShrink());
+            // The same chrome refresh a session swap runs, in the same order, so the
+            // two paths cannot report different capabilities or settings.
+            this.applyRuntimeSettings();
+            this.applySessionTheme();
             this.setupAutocompleteProvider();
-            const runner = this.session.extensionRunner;
-            this.setupExtensionShortcuts(runner);
-            this.rebuildChatFromMessages();
+            this.setupExtensionShortcuts(this.session.extensionRunner);
+            // The session itself is not replaced, so the transcript is replayed
+            // rather than rebuilt from a new one — but the view state pointing into
+            // it is just as stale, and gets the same reset.
+            this.resetTranscriptView();
+            this.renderSessionContext(this.sessionManager.buildSessionContext());
             dismissReloadBox(this.editor);
+            // Below the replayed transcript, not above it: /reload is asked for to
+            // see what just loaded, and that answer belongs where you are looking.
             this.showLoadedResources({
                 force: false,
                 showDiagnosticsWhenQuiet: true,
             });
+            await this.finishRuntimeSettings();
             const modelsJsonError = this.session.modelRegistry.getError();
             if (modelsJsonError) {
                 this.showError(`models.json error: ${modelsJsonError}`);