pilotswarm 0.5.0 → 0.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pilotswarm",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "PilotSwarm application package: terminal UI, browser portal + Web API server, and MCP server — one install, three bins.",
   "type": "module",
   "license": "MIT",
@@ -77,7 +77,7 @@
     "hono": "^4.12.10",
     "ink": "^6.8.0",
     "jose": "^6.2.2",
-    "pilotswarm-sdk": "^0.5.0",
+    "pilotswarm-sdk": "^0.5.1",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",
     "ws": "^8.18.2"

package/tui/src/app.js

@@ -264,6 +264,14 @@ export function PilotSwarmTuiApp({ controller, platform, onRequestExit }) {
             requestExit();
             return;
         }
+        // Stop the current turn — the TUI equivalent of the portal Stop button.
+        // ctrl-x is reliable across terminals; ctrl-esc also fires where the
+        // terminal sends it distinctly from a bare Esc. The controller no-ops
+        // (status message) when no turn is running.
+        if (key.ctrl && (input === "x" || key.escape)) {
+            controller.handleCommand(UI_COMMANDS.STOP_TURN).catch(() => {});
+            return;
+        }
         if (focus !== "prompt" && input === "q" && quitStateRef.current.armedUntil > Date.now()) {
             clearQuitArm(false);
             requestExit();
@@ -398,7 +406,7 @@ export function PilotSwarmTuiApp({ controller, platform, onRequestExit }) {
                 }
                 return;
             }
-            if (key.escape || input === "q" || (modal.type === "artifactPicker" && input === "a")) {
+            if (key.escape || input === "q" || (modal.type === "artifactPicker" && input === "a") || (modal.type === "help" && input === "?")) {
                 controller.handleCommand(UI_COMMANDS.CLOSE_MODAL).catch(() => {});
                 return;
             }
@@ -602,21 +610,40 @@ export function PilotSwarmTuiApp({ controller, platform, onRequestExit }) {
                 return;
             }
         }
+        // Sequence tab: j/k move the turn cursor across completed turns, enter
+        // expands/collapses the selected turn (paging/g-G still scroll).
+        if (focus === "inspector" && inspectorTab === "sequence") {
+            if (key.return) {
+                controller.handleCommand(UI_COMMANDS.TOGGLE_SEQUENCE_TURN).catch(() => {});
+                return;
+            }
+            if (key.upArrow || input === "k") {
+                controller.handleCommand(UI_COMMANDS.SEQUENCE_SELECT_PREV).catch(() => {});
+                return;
+            }
+            if (key.downArrow || input === "j") {
+                controller.handleCommand(UI_COMMANDS.SEQUENCE_SELECT_NEXT).catch(() => {});
+                return;
+            }
+        }
 
+        // [ / ] resize the vertical pane of whatever is focused (sessions/chat
+        // share the left split; inspector/activity share the right split).
+        // { / } resize the horizontal left/right column split.
         if (focus !== "prompt" && input === "[") {
-            controller.handleCommand(UI_COMMANDS.GROW_LEFT_PANE).catch(() => {});
+            controller.handleCommand(UI_COMMANDS.SHRINK_FOCUSED_PANE).catch(() => {});
             return;
         }
         if (focus !== "prompt" && input === "]") {
-            controller.handleCommand(UI_COMMANDS.GROW_RIGHT_PANE).catch(() => {});
+            controller.handleCommand(UI_COMMANDS.GROW_FOCUSED_PANE).catch(() => {});
             return;
         }
         if (focus !== "prompt" && input === "{") {
-            controller.handleCommand(UI_COMMANDS.SHRINK_SESSION_PANE).catch(() => {});
+            controller.handleCommand(UI_COMMANDS.GROW_LEFT_PANE).catch(() => {});
             return;
         }
         if (focus !== "prompt" && input === "}") {
-            controller.handleCommand(UI_COMMANDS.GROW_SESSION_PANE).catch(() => {});
+            controller.handleCommand(UI_COMMANDS.GROW_RIGHT_PANE).catch(() => {});
             return;
         }
 
@@ -718,6 +745,10 @@ export function PilotSwarmTuiApp({ controller, platform, onRequestExit }) {
             controller.handleCommand(UI_COMMANDS.OPEN_ARTIFACT_PICKER).catch(() => {});
             return;
         }
+        if (focus !== "prompt" && input === "?") {
+            controller.handleCommand(UI_COMMANDS.OPEN_HELP).catch(() => {});
+            return;
+        }
         if (plainShortcut && input === "m") {
             controller.handleCommand(UI_COMMANDS.CYCLE_INSPECTOR_TAB).catch(() => {});
             return;

package/ui/core/src/commands.js

@@ -45,7 +45,13 @@ export const UI_COMMANDS = {
     GROW_RIGHT_PANE: "growRightPane",
     GROW_SESSION_PANE: "growSessionPane",
     SHRINK_SESSION_PANE: "shrinkSessionPane",
+    GROW_FOCUSED_PANE: "growFocusedPane",
+    SHRINK_FOCUSED_PANE: "shrinkFocusedPane",
     OPEN_ARTIFACT_PICKER: "openArtifactPicker",
+    OPEN_HELP: "openHelp",
+    SEQUENCE_SELECT_PREV: "sequenceSelectPrev",
+    SEQUENCE_SELECT_NEXT: "sequenceSelectNext",
+    TOGGLE_SEQUENCE_TURN: "toggleSequenceTurn",
     TOGGLE_LOG_TAIL: "toggleLogTail",
     TOGGLE_STATS_VIEW: "toggleStatsView",
     OPEN_LOG_FILTER: "openLogFilter",

package/ui/core/src/controller.js

@@ -18,6 +18,10 @@ import {
     getFocusRightTarget,
     getPromptInputRows,
     MIN_SESSION_PANE_HEIGHT,
+    MIN_CHAT_PANE_HEIGHT,
+    MIN_ACTIVITY_PANE_HEIGHT,
+    MIN_INSPECTOR_PANE_HEIGHT,
+    DEFAULT_ACTIVITY_PANE_RATIO,
     normalizeFocusRegion,
 } from "./layout.js";
 import { parseTerminalMarkupRuns } from "./formatting.js";
@@ -25,6 +29,7 @@ import {
     selectActiveArtifactLinks,
     selectActiveHttpLinks,
     selectActivityPane,
+    selectLiveActivityLines,
     selectChatLines,
     selectFileBrowserItems,
     selectFileSessionIdsForScope,
@@ -2883,6 +2888,10 @@ export class PilotSwarmUiController {
                 this.exitPendingPromptEdit({ restoreDraft: true });
             }
             this.dispatch({ type: "sessions/selected", sessionId });
+            // Sequence-tab turn selection/expansion is per-session; clear it on
+            // switch so a stale turn index doesn't carry into another session.
+            this.dispatch({ type: "ui/sequenceExpandedTurns", turns: [] });
+            this.dispatch({ type: "ui/sequenceSelectedTurn", turn: null });
         }
         if (this.getState().sessions.byId[sessionId]?.isGroup) {
             this.detachActiveSession();
@@ -3534,6 +3543,19 @@ export class PilotSwarmUiController {
         await this.refreshSessions();
     }
 
+    openHelpModal() {
+        this.dispatch({
+            type: "ui/modal",
+            modal: {
+                type: "help",
+                title: "Keybindings",
+                selectedIndex: 0,
+                previousFocus: this.getState().ui.focusRegion,
+            },
+        });
+        this.dispatch({ type: "ui/status", text: "Keybindings — ? or Esc to close" });
+    }
+
     openThemePicker() {
         const themes = listThemes().map((theme) => ({
             id: theme.id,
@@ -4160,7 +4182,13 @@ export class PilotSwarmUiController {
 
     moveModalSelection(delta) {
         const modal = this.getState().ui.modal;
-        if (!modal || !Array.isArray(modal.items) || modal.items.length === 0) return;
+        if (!modal) return;
+        if (modal.type === "help") {
+            const current = Math.max(0, Number(modal.selectedIndex) || 0);
+            this.dispatch({ type: "ui/modalSelection", index: Math.max(0, current + delta) });
+            return;
+        }
+        if (!Array.isArray(modal.items) || modal.items.length === 0) return;
         if (modal.type === "logFilter" || modal.type === "filesFilter" || modal.type === "historyFormat") {
             const currentPaneIndex = Math.max(0, Math.min(Number(modal.selectedIndex) || 0, modal.items.length - 1));
             const selected = modal.items[currentPaneIndex];
@@ -4216,6 +4244,10 @@ export class PilotSwarmUiController {
     async confirmModal() {
         const modal = this.getState().ui.modal;
         if (!modal) return;
+        if (modal.type === "help") {
+            this.closeModal();
+            return;
+        }
         if (modal.type === "confirm") {
             const previousFocus = modal.previousFocus;
             this.dispatch({ type: "ui/modal", modal: null });
@@ -4782,6 +4814,88 @@ export class PilotSwarmUiController {
         }
     }
 
+    // Focus-aware vertical resize: [ / ] grow or shrink whichever pane is
+    // focused. Sessions and chat share the left-column vertical split;
+    // inspector and activity share the right-column vertical split. A positive
+    // delta always grows the focused pane at the expense of its sibling.
+    resizeFocusedPane(delta) {
+        const focus = this.getState().ui.focusRegion;
+        const layoutState = this.getState().ui.layout || {};
+        const bodyHeight = this.getCurrentLayout().bodyHeight ?? (layoutState.viewportHeight ?? 40);
+        const totalHeight = layoutState.viewportHeight ?? 40;
+        // Bound the adjust so BOTH panes stay strictly ABOVE their collapse
+        // thresholds (the collapse check is `<=`, hence the +1). A keyboard
+        // resize then never hides a pane — which would drop it from the Tab
+        // cycle — and never lands on a dead plateau. A positive delta grows the
+        // focused pane.
+        const clamp = (current, signed, min, max) => {
+            const hi = Math.max(min, max);
+            return Math.max(min, Math.min(hi, (current || 0) + signed));
+        };
+        if (focus === FOCUS_REGIONS.SESSIONS || focus === FOCUS_REGIONS.CHAT) {
+            const base = getBaseSessionPaneHeight(bodyHeight);
+            const minH = MIN_SESSION_PANE_HEIGHT + 1;
+            const maxH = Math.min(getMaxSessionPaneHeight(totalHeight, bodyHeight), bodyHeight - MIN_CHAT_PANE_HEIGHT - 1);
+            const signed = focus === FOCUS_REGIONS.CHAT ? -delta : delta;
+            const next = clamp(layoutState.sessionPaneAdjust, signed, minH - base, maxH - base);
+            this.dispatch({ type: "ui/sessionPaneAdjust", sessionPaneAdjust: next });
+        } else if (focus === FOCUS_REGIONS.INSPECTOR || focus === FOCUS_REGIONS.ACTIVITY) {
+            const base = Math.max(MIN_ACTIVITY_PANE_HEIGHT, Math.floor(bodyHeight * DEFAULT_ACTIVITY_PANE_RATIO));
+            const minH = MIN_ACTIVITY_PANE_HEIGHT + 1;
+            const maxH = bodyHeight - MIN_INSPECTOR_PANE_HEIGHT - 1;
+            const signed = focus === FOCUS_REGIONS.INSPECTOR ? -delta : delta;
+            const next = clamp(layoutState.activityPaneAdjust, signed, minH - base, maxH - base);
+            this.dispatch({ type: "ui/activityPaneAdjust", activityPaneAdjust: next });
+        }
+    }
+
+    getActiveSequenceCompletedTurns() {
+        const state = this.getState();
+        const sid = state.sessions.activeSessionId;
+        if (!sid) return [];
+        const history = state.history.bySessionId?.get?.(sid);
+        const turns = [];
+        const seen = new Set();
+        for (const event of history?.events || []) {
+            if (event?.eventType !== "session.turn_completed") continue;
+            const turn = Number(event?.data?.turnIndex ?? event?.data?.iteration);
+            if (!Number.isFinite(turn) || seen.has(turn)) continue;
+            seen.add(turn);
+            turns.push(turn);
+        }
+        turns.sort((a, b) => a - b);
+        return turns;
+    }
+
+    // Move the sequence-tab turn cursor among completed turns. First press with
+    // no selection lands on the latest turn; subsequent presses step.
+    moveSequenceSelection(delta) {
+        const turns = this.getActiveSequenceCompletedTurns();
+        if (turns.length === 0) return;
+        const at = turns.indexOf(Number(this.getState().ui.sequenceSelectedTurn));
+        const index = at === -1
+            ? turns.length - 1
+            : Math.max(0, Math.min(turns.length - 1, at + delta));
+        this.dispatch({ type: "ui/sequenceSelectedTurn", turn: turns[index] });
+    }
+
+    toggleSequenceTurnExpanded() {
+        const turns = this.getActiveSequenceCompletedTurns();
+        if (turns.length === 0) return;
+        let selected = Number(this.getState().ui.sequenceSelectedTurn);
+        if (!turns.includes(selected)) {
+            selected = turns[turns.length - 1];
+            this.dispatch({ type: "ui/sequenceSelectedTurn", turn: selected });
+        }
+        const expanded = Array.isArray(this.getState().ui.sequenceExpandedTurns)
+            ? this.getState().ui.sequenceExpandedTurns.map(Number)
+            : [];
+        const next = expanded.includes(selected)
+            ? expanded.filter((turn) => turn !== selected)
+            : [...expanded, selected];
+        this.dispatch({ type: "ui/sequenceExpandedTurns", turns: next });
+    }
+
     nextInspectorTab() {
         const current = this.getState().ui.inspectorTab;
         const inspectorTab = cycleValue(INSPECTOR_TABS, current, 1);
@@ -5058,7 +5172,10 @@ export class PilotSwarmUiController {
 
         const contentWidth = Math.max(20, layout.leftWidth - 4);
         const contentHeight = Math.max(1, layout.chatPaneHeight - 2);
-        const lines = selectChatLines(state, contentWidth);
+        const lines = [
+            ...selectChatLines(state, contentWidth),
+            ...selectLiveActivityLines(state),
+        ];
         const bottomStickyLines = selectOutboxOverlayLines(state, contentWidth);
         const bottomStickyHeight = Math.min(
             Math.max(0, Math.floor(contentHeight * 0.34)),
@@ -6030,9 +6147,27 @@ export class PilotSwarmUiController {
             case UI_COMMANDS.SHRINK_SESSION_PANE:
                 this.adjustSessionPaneSplit(-2);
                 return;
+            case UI_COMMANDS.GROW_FOCUSED_PANE:
+                this.resizeFocusedPane(2);
+                return;
+            case UI_COMMANDS.SHRINK_FOCUSED_PANE:
+                this.resizeFocusedPane(-2);
+                return;
             case UI_COMMANDS.OPEN_ARTIFACT_PICKER:
                 await this.openArtifactPicker();
                 return;
+            case UI_COMMANDS.OPEN_HELP:
+                this.openHelpModal();
+                return;
+            case UI_COMMANDS.SEQUENCE_SELECT_PREV:
+                this.moveSequenceSelection(-1);
+                return;
+            case UI_COMMANDS.SEQUENCE_SELECT_NEXT:
+                this.moveSequenceSelection(1);
+                return;
+            case UI_COMMANDS.TOGGLE_SEQUENCE_TURN:
+                this.toggleSequenceTurnExpanded();
+                return;
             case UI_COMMANDS.TOGGLE_LOG_TAIL:
                 this.toggleLogTail();
                 return;

package/ui/core/src/reducer.js

@@ -670,6 +670,24 @@ export function appReducer(state, action) {
                 },
             };
 
+        case "ui/sequenceExpandedTurns":
+            return {
+                ...state,
+                ui: {
+                    ...state.ui,
+                    sequenceExpandedTurns: Array.isArray(action.turns) ? action.turns : [],
+                },
+            };
+
+        case "ui/sequenceSelectedTurn":
+            return {
+                ...state,
+                ui: {
+                    ...state.ui,
+                    sequenceSelectedTurn: action.turn == null ? null : Number(action.turn),
+                },
+            };
+
         case "sessions/filterQuery":
             {
                 const nextSessions = {
@@ -701,7 +719,19 @@ export function appReducer(state, action) {
 
         case "ui/modalSelection": {
             const modal = state.ui.modal;
-            if (!modal || !Array.isArray(modal.items) || modal.items.length === 0) {
+            if (!modal) return state;
+            if (modal.type === "help") {
+                // The help overlay has no `items`; the row-count upper bound is
+                // clamped by selectHelpModal, so just track the scroll anchor.
+                return {
+                    ...state,
+                    ui: {
+                        ...state.ui,
+                        modal: { ...modal, selectedIndex: Math.max(0, Number(action.index) || 0) },
+                    },
+                };
+            }
+            if (!Array.isArray(modal.items) || modal.items.length === 0) {
                 return state;
             }
             const nextIndex = Math.max(0, Math.min(action.index ?? 0, modal.items.length - 1));