pi-ui-extend 0.1.34 → 0.1.35

package/dist/app/subagents/subagents-widget-controller.js

@@ -10,7 +10,9 @@ export class AppSubagentsWidgetController {
     pollTimer;
     pollInFlight = false;
     currentRunDir;
+    currentRunDirs = [];
     state;
+    runFreshnessByRunDir = new Map();
     taskPreviewsByRunDir = new Map();
     snapshotByRunDir = new Map();
     refreshGeneration = 0;
@@ -38,6 +40,8 @@ export class AppSubagentsWidgetController {
     reset() {
         this.refreshGeneration++;
         this.currentRunDir = undefined;
+        this.currentRunDirs = [];
+        this.runFreshnessByRunDir.clear();
         this.taskPreviewsByRunDir.clear();
         this.snapshotByRunDir.clear();
         this.updateState(undefined);
@@ -59,15 +63,14 @@ export class AppSubagentsWidgetController {
         }
         this.currentRunDir = runDir;
         this.snapshotByRunDir.set(runDir, normalizedDetails);
+        this.rememberRunFreshness(runDir, this.runFreshnessFromAgents(normalizedDetails.agents) ?? Date.now());
         if (activeSubagentStates(normalizedDetails.agents).length > 0) {
-            this.state = {
-                runDir,
-                agents: normalizedDetails.agents,
-                ...(normalizedDetails.tasks === undefined ? {} : { tasks: normalizedDetails.tasks }),
+            this.currentRunDirs = this.orderRunDirs([runDir, ...this.currentRunDirs]);
+            this.updateState(this.buildStateFromRuns([normalizedDetails], {
                 live: false,
                 snapshotOnly: true,
                 checkedAt: Date.now(),
-            };
+            }));
         }
         void this.refreshFromFiles(this.refreshGeneration);
         this.schedulePoll(0);
@@ -88,6 +91,7 @@ export class AppSubagentsWidgetController {
         }))
             .filter((run) => activeSubagentStates(run.agents).length > 0);
         for (const run of activeRuns) {
+            this.rememberRunFreshness(run.runDir, this.runFreshnessFromAgents(run.agents) ?? data.checkedAt);
             this.snapshotByRunDir.set(run.runDir, {
                 runDir: run.runDir,
                 agents: run.agents,
@@ -97,22 +101,21 @@ export class AppSubagentsWidgetController {
             if (run.tasks)
                 this.taskPreviewsByRunDir.set(run.runDir, run.tasks);
         }
-        const preferred = activeRuns.find((run) => run.runDir === this.currentRunDir) ?? activeRuns[0];
-        if (!preferred) {
+        if (activeRuns.length === 0) {
             this.currentRunDir = undefined;
+            this.currentRunDirs = [];
             this.updateState(undefined);
             this.stopPolling();
             return;
         }
-        this.currentRunDir = preferred.runDir;
-        this.updateState({
-            runDir: preferred.runDir,
-            agents: preferred.agents,
-            ...(preferred.tasks === undefined ? {} : { tasks: preferred.tasks }),
+        const orderedRuns = this.orderRuns(activeRuns);
+        this.currentRunDir = orderedRuns[0]?.runDir;
+        this.currentRunDirs = orderedRuns.map((run) => run.runDir);
+        this.updateState(this.buildStateFromRuns(orderedRuns, {
             live: true,
             snapshotOnly: false,
             checkedAt: data.checkedAt,
-        });
+        }));
         this.startFileWatcher();
         this.schedulePoll(SUBAGENTS_POLL_INTERVAL_MS);
     }
@@ -182,71 +185,77 @@ export class AppSubagentsWidgetController {
         }
     }
     async refreshFromFiles(generation = this.refreshGeneration) {
-        let runDir = this.currentRunDir;
-        if (!runDir) {
-            const registry = await readSubagentRegistry(this.host.cwd);
-            if (!this.isCurrentGeneration(generation))
-                return;
-            runDir = await this.findActiveRegistryRunDirForCurrentSession(registry, generation);
-            if (!this.isCurrentGeneration(generation))
-                return;
-            if (runDir)
-                this.currentRunDir = runDir;
-        }
-        if (!runDir) {
-            if (!this.isCurrentGeneration(generation))
-                return;
-            this.updateState(undefined);
+        const registry = await readSubagentRegistry(this.host.cwd);
+        if (!this.isCurrentGeneration(generation))
             return;
-        }
-        this.currentRunDir = runDir;
-        const fileState = await readSubagentRunStateFromFiles(runDir, { includeLineCounts: false });
+        const runDirs = await this.findActiveRegistryRunDirsForCurrentSession(registry, generation);
         if (!this.isCurrentGeneration(generation))
             return;
-        if (!fileState) {
-            await this.clearMissingRunAndMaybeSelectReplacement(runDir, generation);
+        if (runDirs.length === 0) {
+            this.currentRunDir = undefined;
+            this.currentRunDirs = [];
+            this.updateState(undefined);
             return;
         }
-        const activeAgents = activeSubagentStates(fileState.agents);
-        if (activeAgents.length === 0) {
-            if (allSubagentStatesTerminal(fileState.agents) || fileState.agents.length === 0) {
+        const runs = [];
+        for (const runDir of runDirs) {
+            const fileState = await readSubagentRunStateFromFiles(runDir, { includeLineCounts: false });
+            if (!this.isCurrentGeneration(generation))
+                return;
+            if (!fileState) {
                 this.clearCachedRun(runDir);
-                this.currentRunDir = undefined;
-                this.updateState(undefined);
+                continue;
+            }
+            const activeAgents = activeSubagentStates(fileState.agents);
+            if (activeAgents.length === 0) {
+                if (allSubagentStatesTerminal(fileState.agents) || fileState.agents.length === 0)
+                    this.clearCachedRun(runDir);
+                continue;
             }
+            const tasks = this.taskPreviewsByRunDir.get(runDir);
+            runs.push({
+                runDir,
+                agents: fileState.agents,
+                ...(tasks === undefined ? {} : { tasks }),
+            });
+        }
+        if (runs.length === 0) {
+            this.currentRunDir = undefined;
+            this.currentRunDirs = [];
+            this.updateState(undefined);
             return;
         }
-        const tasks = this.taskPreviewsByRunDir.get(runDir);
-        this.updateState({
-            runDir,
-            agents: fileState.agents,
-            ...(tasks === undefined ? {} : { tasks }),
+        const orderedRuns = this.orderRuns(runs);
+        this.currentRunDir = orderedRuns[0]?.runDir;
+        this.currentRunDirs = orderedRuns.map((run) => run.runDir);
+        this.updateState(this.buildStateFromRuns(orderedRuns, {
             live: true,
             snapshotOnly: false,
             checkedAt: Date.now(),
-        });
+        }));
     }
-    async findActiveRegistryRunDirForCurrentSession(registry, generation) {
+    async findActiveRegistryRunDirsForCurrentSession(registry, generation) {
         if (!registry)
-            return undefined;
+            return [];
         const sessionFile = this.host.sessionFile();
         if (!sessionFile)
-            return undefined;
+            return [];
         const candidateRunDirs = this.registryRunDirsNewestFirst(registry);
+        const matchingRunDirs = [];
         for (const runDir of candidateRunDirs) {
             if (!this.isCurrentGeneration(generation))
-                return undefined;
+                return [];
             if (!(await subagentRunHasParentSession(runDir, sessionFile)))
                 continue;
             if (!this.isCurrentGeneration(generation))
-                return undefined;
+                return [];
             const state = await readSubagentRunStateFromFiles(runDir, { includeLineCounts: false });
             if (!this.isCurrentGeneration(generation))
-                return undefined;
+                return [];
             if (activeSubagentStates(state?.agents ?? []).length > 0)
-                return runDir;
+                matchingRunDirs.push(runDir);
         }
-        return undefined;
+        return matchingRunDirs;
     }
     registryRunDirsNewestFirst(registry) {
         const runDirs = [];
@@ -263,30 +272,89 @@ export class AppSubagentsWidgetController {
         addRunDir(registry.latestRunDir);
         Object.values(registry.runs)
             .sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt))
-            .forEach((run) => addRunDir(run.runDir));
+            .forEach((run) => {
+            this.rememberRunFreshness(run.runDir, this.parseRunTimestamp(run.updatedAt) ?? this.parseRunTimestamp(run.createdAt));
+            addRunDir(run.runDir);
+        });
         return runDirs;
     }
-    async clearMissingRunAndMaybeSelectReplacement(runDir, generation) {
-        this.clearCachedRun(runDir);
-        if (this.currentRunDir === runDir)
-            this.currentRunDir = undefined;
-        const registry = await readSubagentRegistry(this.host.cwd);
-        if (!this.isCurrentGeneration(generation))
-            return;
-        const replacementRunDir = await this.findActiveRegistryRunDirForCurrentSession(registry, generation);
-        if (!this.isCurrentGeneration(generation))
-            return;
-        if (replacementRunDir) {
-            this.currentRunDir = replacementRunDir;
-            await this.refreshFromFiles(generation);
-            return;
-        }
-        this.updateState(undefined);
-    }
     clearCachedRun(runDir) {
+        this.runFreshnessByRunDir.delete(runDir);
         this.snapshotByRunDir.delete(runDir);
         this.taskPreviewsByRunDir.delete(runDir);
     }
+    buildStateFromRuns(runs, meta) {
+        const activeRuns = runs
+            .map((run) => ({ ...run, agents: activeSubagentStates(run.agents) }))
+            .filter((run) => run.agents.length > 0);
+        if (activeRuns.length === 0)
+            return undefined;
+        const primary = activeRuns[0];
+        if (!primary)
+            return undefined;
+        return {
+            runs: activeRuns.map((run) => ({
+                runDir: run.runDir,
+                agents: run.agents,
+                ...(run.tasks === undefined ? {} : { tasks: run.tasks }),
+            })),
+            runDir: primary.runDir,
+            agents: activeRuns.flatMap((run) => run.agents),
+            ...(primary.tasks === undefined ? {} : { tasks: primary.tasks }),
+            ...meta,
+        };
+    }
+    orderRuns(runs) {
+        const order = this.orderRunDirs(runs.map((run) => run.runDir));
+        const priority = new Map(order.map((runDir, index) => [runDir, index]));
+        return [...runs].sort((a, b) => {
+            const freshness = this.runFreshness(b) - this.runFreshness(a);
+            if (freshness !== 0)
+                return freshness;
+            return (priority.get(a.runDir) ?? Number.MAX_SAFE_INTEGER) - (priority.get(b.runDir) ?? Number.MAX_SAFE_INTEGER);
+        });
+    }
+    orderRunDirs(runDirs) {
+        const seen = new Set();
+        const preferred = [this.currentRunDir, ...this.currentRunDirs, ...runDirs].filter((runDir) => Boolean(runDir));
+        const ordered = [];
+        for (const runDir of preferred) {
+            if (seen.has(runDir))
+                continue;
+            seen.add(runDir);
+            ordered.push(runDir);
+        }
+        return ordered;
+    }
+    rememberRunFreshness(runDir, freshness) {
+        if (!Number.isFinite(freshness))
+            return;
+        const next = freshness ?? 0;
+        const previous = this.runFreshnessByRunDir.get(runDir) ?? Number.NEGATIVE_INFINITY;
+        if (next >= previous)
+            this.runFreshnessByRunDir.set(runDir, next);
+    }
+    runFreshness(run) {
+        return this.runFreshnessFromAgents(run.agents)
+            ?? this.runFreshnessByRunDir.get(run.runDir)
+            ?? 0;
+    }
+    runFreshnessFromAgents(agents) {
+        let freshest;
+        for (const agent of agents) {
+            const parsed = this.parseRunTimestamp(agent.startedAt);
+            if (parsed === undefined)
+                continue;
+            freshest = freshest === undefined ? parsed : Math.max(freshest, parsed);
+        }
+        return freshest;
+    }
+    parseRunTimestamp(value) {
+        if (!value)
+            return undefined;
+        const parsed = Date.parse(value);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
     updateState(next) {
         const previous = stringifyUnknown(this.state);
         const serializedNext = stringifyUnknown(next);
@@ -298,6 +366,9 @@ export class AppSubagentsWidgetController {
         return generation === this.refreshGeneration;
     }
     shouldContinuePolling() {
+        const runs = this.state?.runs;
+        if (runs?.length)
+            return runs.some((run) => activeSubagentStates(run.agents).length > 0);
         return activeSubagentStates(this.state?.agents ?? []).length > 0;
     }
     eventMatchesCurrentSession(eventSessionFile) {

package/dist/app/terminal/terminal-controller.d.ts

@@ -24,6 +24,10 @@ export declare class AppTerminalController {
     private terminalEnabled;
     private interactiveSuspended;
     private stopPromise;
+    private keyboardProtocolNegotiationBuffer;
+    private keyboardProtocolBufferFlushTimer;
+    private kittyProtocolActive;
+    private modifyOtherKeysActive;
     private readonly enterInteractiveSequence;
     private readonly exitInteractiveSequence;
     constructor(host: AppTerminalControllerHost);
@@ -40,4 +44,10 @@ export declare class AppTerminalController {
     private scheduleForcedProcessExit;
     private readonly onResize;
     private readonly onInputData;
+    private beginKeyboardProtocolNegotiation;
+    private filterKeyboardProtocolNegotiationInput;
+    private handleKeyboardProtocolNegotiationResponse;
+    private enableModifyOtherKeysFallback;
+    private setKeyboardProtocolNegotiationBuffer;
+    private clearKeyboardProtocolNegotiationBuffer;
 }

package/dist/app/terminal/terminal-controller.js

@@ -1,10 +1,14 @@
 import { ANSI_RESET } from "../../theme.js";
-import { DISABLE_BRACKETED_PASTE, DISABLE_TERMINAL_KEY_REPORTING, DISABLE_TERMINAL_WRAP, CLEAR_TERMINAL, ENABLE_BRACKETED_PASTE, ENABLE_TERMINAL_KEY_REPORTING, ENABLE_TERMINAL_WRAP, HIDE_CURSOR, RESET_TERMINAL_VIEWPORT_STATE, RUNTIME_DISPOSE_GRACE_MS, SHOW_CURSOR, } from "../constants.js";
+import { DISABLE_BRACKETED_PASTE, DISABLE_TERMINAL_KEY_REPORTING, DISABLE_TERMINAL_WRAP, CLEAR_TERMINAL, ENABLE_BRACKETED_PASTE, ENABLE_TERMINAL_MODIFY_OTHER_KEYS, ENABLE_TERMINAL_KEY_REPORTING, ENABLE_TERMINAL_WRAP, HIDE_CURSOR, RESET_TERMINAL_VIEWPORT_STATE, RUNTIME_DISPOSE_GRACE_MS, SHOW_CURSOR, } from "../constants.js";
 export class AppTerminalController {
     host;
     terminalEnabled = false;
     interactiveSuspended = false;
     stopPromise;
+    keyboardProtocolNegotiationBuffer = "";
+    keyboardProtocolBufferFlushTimer;
+    kittyProtocolActive = false;
+    modifyOtherKeysActive = false;
     enterInteractiveSequence = `${ANSI_RESET}${RESET_TERMINAL_VIEWPORT_STATE}${CLEAR_TERMINAL}\x1b[?1049h${RESET_TERMINAL_VIEWPORT_STATE}${CLEAR_TERMINAL}${ENABLE_TERMINAL_KEY_REPORTING}${ENABLE_BRACKETED_PASTE}${DISABLE_TERMINAL_WRAP}\x1b[?1002h\x1b[?1006h${HIDE_CURSOR}`;
     exitInteractiveSequence = `${ANSI_RESET}${RESET_TERMINAL_VIEWPORT_STATE}${DISABLE_TERMINAL_KEY_REPORTING}${DISABLE_BRACKETED_PASTE}${ENABLE_TERMINAL_WRAP}\x1b[?1006l\x1b[?1002l\x1b[?1049l${SHOW_CURSOR}`;
     constructor(host) {
@@ -17,6 +21,7 @@ export class AppTerminalController {
         if (this.terminalEnabled)
             return;
         this.terminalEnabled = true;
+        this.beginKeyboardProtocolNegotiation();
         process.stdin.setRawMode(true);
         process.stdin.resume();
         process.stdin.on("data", this.onInputData);
@@ -66,6 +71,7 @@ export class AppTerminalController {
     restoreTerminal = () => {
         if (!this.terminalEnabled)
             return;
+        this.clearKeyboardProtocolNegotiationBuffer();
         this.terminalEnabled = false;
         this.interactiveSuspended = false;
         process.stdout.write(this.exitInteractiveSequence);
@@ -87,6 +93,7 @@ export class AppTerminalController {
         if (!this.terminalEnabled || !this.interactiveSuspended)
             return;
         this.interactiveSuspended = false;
+        this.beginKeyboardProtocolNegotiation();
         if (process.stdin.isTTY)
             process.stdin.setRawMode(true);
         process.stdin.resume();
@@ -99,6 +106,7 @@ export class AppTerminalController {
     async stopInternal() {
         if (!this.host.isRunning())
             return;
+        this.clearKeyboardProtocolNegotiationBuffer();
         this.host.setRunning(false);
         this.host.closeSdkMenuForStop();
         this.host.clearToastTimers();
@@ -133,6 +141,87 @@ export class AppTerminalController {
         this.host.render();
     };
     onInputData = (chunk) => {
-        this.host.handleInputChunk(chunk);
+        const input = this.filterKeyboardProtocolNegotiationInput(chunk.toString("utf8"));
+        if (input)
+            this.host.handleInputChunk(Buffer.from(input, "utf8"));
     };
+    beginKeyboardProtocolNegotiation() {
+        this.clearKeyboardProtocolNegotiationBuffer();
+        this.kittyProtocolActive = false;
+        this.modifyOtherKeysActive = false;
+    }
+    filterKeyboardProtocolNegotiationInput(data) {
+        let input = this.keyboardProtocolNegotiationBuffer + data;
+        this.clearKeyboardProtocolNegotiationBuffer();
+        let output = "";
+        while (input.length > 0) {
+            const response = readKeyboardProtocolNegotiationResponse(input);
+            if (response.kind === "complete") {
+                this.handleKeyboardProtocolNegotiationResponse(response.response);
+                input = input.slice(response.length);
+                continue;
+            }
+            if (response.kind === "pending") {
+                this.setKeyboardProtocolNegotiationBuffer(input);
+                break;
+            }
+            output += input[0];
+            input = input.slice(1);
+        }
+        return output;
+    }
+    handleKeyboardProtocolNegotiationResponse(response) {
+        if (response.type === "kitty-flags") {
+            if (response.flags !== 0) {
+                this.kittyProtocolActive = true;
+                this.modifyOtherKeysActive = false;
+            }
+            else {
+                this.enableModifyOtherKeysFallback();
+            }
+            return;
+        }
+        if (!this.kittyProtocolActive)
+            this.enableModifyOtherKeysFallback();
+    }
+    enableModifyOtherKeysFallback() {
+        if (this.kittyProtocolActive || this.modifyOtherKeysActive)
+            return;
+        process.stdout.write(ENABLE_TERMINAL_MODIFY_OTHER_KEYS);
+        this.modifyOtherKeysActive = true;
+    }
+    setKeyboardProtocolNegotiationBuffer(data) {
+        this.clearKeyboardProtocolNegotiationBuffer();
+        this.keyboardProtocolNegotiationBuffer = data;
+        this.keyboardProtocolBufferFlushTimer = setTimeout(() => {
+            this.keyboardProtocolBufferFlushTimer = undefined;
+            const buffered = this.keyboardProtocolNegotiationBuffer;
+            this.keyboardProtocolNegotiationBuffer = "";
+            if (buffered)
+                this.host.handleInputChunk(Buffer.from(buffered, "utf8"));
+        }, 150);
+    }
+    clearKeyboardProtocolNegotiationBuffer() {
+        if (this.keyboardProtocolBufferFlushTimer)
+            clearTimeout(this.keyboardProtocolBufferFlushTimer);
+        this.keyboardProtocolBufferFlushTimer = undefined;
+        this.keyboardProtocolNegotiationBuffer = "";
+    }
+}
+function readKeyboardProtocolNegotiationResponse(input) {
+    const kittyFlags = /^\x1b\[\?(\d+)u/.exec(input);
+    if (kittyFlags) {
+        return {
+            kind: "complete",
+            response: { type: "kitty-flags", flags: Number.parseInt(kittyFlags[1] ?? "0", 10) },
+            length: kittyFlags[0].length,
+        };
+    }
+    const deviceAttributes = /^\x1b\[\?[\d;]*c/.exec(input);
+    if (deviceAttributes) {
+        return { kind: "complete", response: { type: "device-attributes" }, length: deviceAttributes[0].length };
+    }
+    if (input === "\x1b[" || /^\x1b\[\?[\d;]*$/.test(input))
+        return { kind: "pending" };
+    return { kind: "none" };
 }

package/dist/app/todo/todo-model.js

@@ -59,6 +59,8 @@ export function isTodoLiveStateEvent(value) {
         return false;
     if (value.sessionFile !== undefined && typeof value.sessionFile !== "string")
         return false;
+    if (value.sessionId !== undefined && typeof value.sessionId !== "string")
+        return false;
     return typeof value.checkedAt === "number" && Number.isFinite(value.checkedAt);
 }
 export function todoStatusIcon(status) {

package/dist/app/todo/todo-widget-controller.d.ts

@@ -1,6 +1,7 @@
 import type { TodoDetails } from "../types.js";
 export type TodoWidgetControllerHost = {
     sessionFile?(): string | undefined;
+    sessionId?(): string | undefined;
     isRunning(): boolean;
     render(): void;
 };
@@ -17,5 +18,6 @@ export declare class AppTodoWidgetController {
     private updateDetailsForCurrentSession;
     private updateDetailsForSession;
     private currentSessionDetails;
+    private currentSessionKey;
     private sessionKey;
 }

package/dist/app/todo/todo-widget-controller.js

@@ -25,17 +25,21 @@ export class AppTodoWidgetController {
     observeLiveState(data) {
         if (!isTodoLiveStateEvent(data))
             return;
-        this.updateDetailsForSession(data.sessionFile ?? this.host.sessionFile?.(), this.visibleDetails(data.details));
+        const sessionFile = data.sessionFile;
+        const sessionId = data.sessionId;
+        if (!sessionFile && !sessionId && this.currentSessionKey())
+            return;
+        this.updateDetailsForSession(sessionFile, sessionId, this.visibleDetails(data.details));
     }
     visibleDetails(details) {
         return hasOpenTodoTasks(details) ? details : undefined;
     }
     updateDetailsForCurrentSession(next, options = {}) {
-        this.updateDetailsForSession(this.host.sessionFile?.(), next, options);
+        this.updateDetailsForSession(this.host.sessionFile?.(), this.host.sessionId?.(), next, options);
     }
-    updateDetailsForSession(sessionFile, next, options = {}) {
+    updateDetailsForSession(sessionFile, sessionId, next, options = {}) {
         const previous = stringifyUnknown(this.currentSessionDetails());
-        const key = this.sessionKey(sessionFile);
+        const key = this.sessionKey(sessionFile, sessionId);
         if (key) {
             if (next)
                 this.detailsBySessionFile.set(key, next);
@@ -50,10 +54,16 @@ export class AppTodoWidgetController {
             this.host.render();
     }
     currentSessionDetails() {
-        const key = this.sessionKey(this.host.sessionFile?.());
+        const key = this.currentSessionKey();
         return key ? this.detailsBySessionFile.get(key) : this.unscopedDetails;
     }
-    sessionKey(sessionFile) {
-        return sessionFile ? resolve(sessionFile) : undefined;
+    currentSessionKey() {
+        return this.sessionKey(this.host.sessionFile?.(), this.host.sessionId?.());
+    }
+    sessionKey(sessionFile, sessionId) {
+        if (sessionFile)
+            return `file:${resolve(sessionFile)}`;
+        const normalizedSessionId = sessionId?.trim();
+        return normalizedSessionId ? `id:${normalizedSessionId}` : undefined;
     }
 }

package/dist/app/types.d.ts

@@ -74,6 +74,8 @@ export type Entry = {
     expanded: boolean;
     status: "running" | "done";
     level?: string;
+    startedAt?: number;
+    finishedAt?: number;
 } | {
     id: string;
     kind: "tool";
@@ -125,6 +127,7 @@ export type TodoLiveStateEvent = {
     version: 1;
     details: TodoDetails;
     sessionFile?: string;
+    sessionId?: string;
     checkedAt: number;
 };
 export type SubagentStatus = (typeof SUBAGENT_STATUSES)[number];
@@ -193,6 +196,7 @@ export type SubagentRegistryAgent = {
     updatedAt: string;
 };
 export type SubagentsWidgetState = {
+    runs?: SubagentLiveStateRun[];
     runDir: string;
     agents: SubagentAgentState[];
     tasks?: SubagentTaskPreview[];

package/dist/bundled-extensions/question/tui.js

@@ -60,6 +60,12 @@ function wrapLine(line, width) {
         lines.push(current.trimEnd());
     return lines.length > 0 ? lines : [""];
 }
+function wrapIndentedLine(line, width) {
+    const indent = line.match(/^\s*/)?.[0] ?? "";
+    const content = line.slice(indent.length);
+    const contentWidth = Math.max(1, width - indent.length);
+    return wrapLine(content, contentWidth).map((wrapped) => `${indent}${wrapped}`);
+}
 function stripAnsi(text) {
     return text.replace(/\u001b\[[0-9;]*m/g, "");
 }
@@ -191,7 +197,8 @@ export async function runQuestionnaire(questions, ctx) {
             clickZones.push({ ...zone, row, startColumn: 1, endColumn: width + 1 });
         }
         function renderMutedLine(add, text, width) {
-            add(paintLine(theme, text, width, { foreground: "muted" }));
+            for (const line of wrapIndentedLine(text, width))
+                add(paintLine(theme, line, width, { foreground: "muted" }));
         }
         function moveToQuestion(index) {
             captureCustomDraft();