@undefineds.co/linx 0.3.26 → 0.3.28

package/dist/lib/pi-adapter/interactive.js

@@ -1,3191 +0,0 @@
-import { InteractiveMode } from '@earendil-works/pi-coding-agent';
-import { AssistantMessageComponent, FooterComponent, LoginDialogComponent } from '@earendil-works/pi-coding-agent';
-import { Container, getKeybindings, Spacer, Text, truncateToWidth, visibleWidth } from '@earendil-works/pi-tui';
-import { existsSync, statSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { connectAiProviderCredential } from '../ai-command.js';
-import { listArchivedAutoModeSessions, runAutoMode } from '../auto-mode/runner.js';
-import { resolveAutoModeCommandRoute, } from '../../../vendor/agent-runtime/dist/auto-mode.js';
-import { getAIConfigProviderCatalog, getAIConfigProviderMetadata } from '../models.js';
-import { runSymphony } from '../symphony-command.js';
-import { applyLinxInteractiveBranding, checkAndShowLinxUpdate, requestLinxCloudLogin } from './branding.js';
-import { installPodStatusOutputFilter } from './pod-status-output.js';
-import { createPodBackedExtensionUiContext } from './pod-approval.js';
-import { DEFAULT_SECRETARY_CHAT_ID, secretaryChatUri, secretaryThreadUri } from './pod-mirror-mapping.js';
-import { getSecretaryAutoInputController } from './auto-input-controller.js';
-import { createSymphonyIdeaRecord, listSymphonyIssues, listSymphonySessions, } from '../symphony/archive.js';
-import { listOpenSymphonyIssuesFromPod, listRecentSymphonyReportsFromPod, listRunningSymphonyWorkersFromPod, mirrorSymphonyProjectionJsonLdFromPod, persistSymphonyIdeaToPod, persistSymphonyControlStateToPod, } from '../symphony/pod-projection.js';
-import { getSessionControlManager, installSessionControlRuntimeEventBridge, } from './session-control.js';
-import { buildLinxFooterStatusLine, calculateSessionUsage, DEFAULT_STATUS_LINE_TOKENS, formatTokenCount, LINX_STATUS_LINE_TOKEN_NAMES, parseLinxStatusLineColorArg, parseLinxStatusLineTokenArgs, readLinxStatusLineConfig, resetLinxStatusLineConfig, writeLinxStatusLineConfigPatch, } from '../linx-status-line.js';
-let footerPatched = false;
-let assistantMessagePatched = false;
-let linxResumeOutputStyleRestore = null;
-const BACKEND_OWNED_SLASH_COMMANDS = new Set([
-    'commands',
-    'models',
-    'rollback',
-    'status',
-]);
-const SYMPHONY_STATUS_POD_TIMEOUT_MS = 1_200;
-const DEFAULT_SYMPHONY_WORKER_SUPERVISOR_INTERVAL_MS = 10 * 60 * 1000;
-const CODEX_STYLE_STATUS_LINE_TOKENS = [
-    'model-with-reasoning',
-    'git-branch',
-    'context-remaining',
-    'total-input-tokens',
-    'total-output-tokens',
-    'current-dir',
-];
-const COMPACT_STATUS_LINE_TOKENS = [
-    'model-with-reasoning',
-    'context-remaining',
-    'current-dir',
-];
-const STATUS_LINE_CODEX_PRESET_OPTION = 'Preset: Codex-style';
-const STATUS_LINE_COMPACT_PRESET_OPTION = 'Preset: Compact';
-const STATUS_LINE_TOGGLE_COLORS_OPTION = 'Toggle colors';
-const STATUS_LINE_RESET_OPTION = 'Reset to default';
-const STATUS_LINE_DONE_OPTION = 'Done';
-/** Module-level reference to interactive for footer mode state (set during bootstrap). */
-let _linxFooterInteractive = null;
-export function bootstrapLinxInteractiveMode(runtime, options = {}) {
-    installLinxResumeOutputStyle();
-    patchPiFooter();
-    patchPiAssistantMessageRendering();
-    const sessionCwd = runtime?.cwd || process.cwd();
-    ensureInteractiveRuntimeHost(runtime);
-    const interactive = new InteractiveMode(runtime, options);
-    interactive.runtime = runtime;
-    interactive.__autoEnabled = runtime?.autoEnabled === true;
-    interactive.__linxSymphonyModeEnabled = runtime?.symphonyEnabled === true;
-    _linxFooterInteractive = interactive;
-    if (options.onSymphonyControlChange) {
-        ;
-        interactive.__linxOnSymphonyControlChange = options.onSymphonyControlChange;
-    }
-    const sessionControlManager = getSessionControlManager(interactive, runtime, sessionCwd);
-    runtime?.backendCommandRouter?.setSessionControl?.(sessionControlManager);
-    const restorePodStatusOutputFilter = installPodStatusOutputFilter();
-    applyLinxInteractiveBranding(interactive);
-    patchInteractiveExitMessage(interactive);
-    patchInteractivePodStatusFilterCleanup(interactive, restorePodStatusOutputFilter);
-    installPodBackedExtensionUi(interactive, runtime, sessionControlManager);
-    installSymphonyAutocomplete(interactive);
-    // Register /cd slash command; workspace follows terminal while session stays.
-    installLinxGlobalCommands(interactive, runtime, sessionCwd, options);
-    installSymphonyCommand(interactive);
-    installBackendCommandRouter(interactive, runtime?.backendCommandRouter);
-    installSessionControlRuntimeEventBridge(interactive, runtime, sessionCwd);
-    installLinxSessionCommandRouter(interactive, runtime);
-    installLinxSessionCommandRouterAfterRebind(interactive, runtime);
-    if (options.restoredAuto === true && runtime?.autoEnabled === true) {
-        installLinxRestoredAutoStartup(interactive, runtime, sessionControlManager);
-    }
-    installLinxInteractivePostInitHooks(interactive, runtime);
-    const bootstrap = {
-        async init() {
-            await interactive.init();
-        },
-        async run() {
-            await bootstrap.init();
-            await withLinxResumeOutputStyle(() => interactive.run());
-        },
-        requestLogin(reason = 'manual') {
-            requestLinxCloudLogin(interactive, reason);
-        },
-        async requestBackendCredential(details) {
-            return promptForBackendCredential(interactive, details);
-        },
-        __unsafeInteractiveForTests: interactive,
-        stop() {
-            interactive.stop();
-        },
-    };
-    return bootstrap;
-}
-function installLinxInteractivePostInitHooks(interactive, runtime) {
-    if (!interactive || interactive.__linxInteractivePostInitHooksInstalled) {
-        return;
-    }
-    const originalInit = interactive.init?.bind(interactive);
-    if (typeof originalInit !== 'function') {
-        return;
-    }
-    interactive.init = async function patchedLinxInteractivePostInit(...args) {
-        if (this.__linxInteractiveInitCompleted === true) {
-            installLinxSessionCommandRouter(this, runtime);
-            installLinxInputCommandRouter(this, runtime);
-            installLinxFinalSubmitCommandRouter(this, runtime);
-            installLinxEscapeInterrupt(this);
-            return undefined;
-        }
-        const result = await originalInit(...args);
-        this.__linxInteractiveInitCompleted = true;
-        installLinxSessionCommandRouter(this, runtime);
-        installLinxInputCommandRouter(this, runtime);
-        installLinxFinalSubmitCommandRouter(this, runtime);
-        installLinxEscapeInterrupt(this);
-        return result;
-    };
-    interactive.__linxInteractivePostInitHooksInstalled = true;
-}
-/** @deprecated Use bootstrapLinxInteractiveMode. */
-export const bootstrapPiInteractiveMode = bootstrapLinxInteractiveMode;
-export function installLinxRestoredAutoStartup(interactive, runtime, sessionControl = getSessionControlManager(interactive, runtime)) {
-    if (!interactive || interactive.__linxRestoredAutoStartupInstalled) {
-        return;
-    }
-    const originalInit = interactive.init?.bind(interactive);
-    if (typeof originalInit !== 'function') {
-        return;
-    }
-    interactive.init = async function patchedLinxRestoredAutoInit(...args) {
-        const result = await originalInit(...args);
-        if (this.__autoEnabled === true && runtime?.autoEnabled === true) {
-            const controller = getSecretaryAutoInputController(this, runtime, sessionControl);
-            controller.start({ scheduleImmediately: true });
-            interactive.showStatus?.([
-                'Auto restored from the previous session.',
-                'auto · Ctrl+C or /auto off to hand control back',
-            ].join('\n'));
-            interactive.ui?.requestRender?.();
-        }
-        return result;
-    };
-    interactive.__linxRestoredAutoStartupInstalled = true;
-}
-function ensureInteractiveRuntimeHost(runtime) {
-    if (!runtime || typeof runtime !== 'object') {
-        return;
-    }
-    if (typeof runtime.setBeforeSessionInvalidate !== 'function') {
-        runtime.setBeforeSessionInvalidate = (callback) => {
-            runtime.__linxBeforeSessionInvalidate = callback;
-        };
-    }
-    if (typeof runtime.setRebindSession !== 'function') {
-        runtime.setRebindSession = (callback) => {
-            runtime.__linxRebindSession = callback;
-        };
-    }
-}
-function patchInteractivePodStatusFilterCleanup(interactive, restore) {
-    const originalStop = interactive.stop?.bind(interactive);
-    if (typeof originalStop !== 'function') {
-        return;
-    }
-    interactive.stop = function patchedStopWithPodStatusCleanup(...args) {
-        try {
-            originalStop(...args);
-        }
-        finally {
-            restore();
-        }
-    };
-}
-export function installPodBackedExtensionUi(interactive, runtime, sessionControl = getSessionControlManager(interactive, runtime)) {
-    if (interactive.__linxPodBackedExtensionUiInstalled) {
-        return;
-    }
-    const originalCreate = interactive.createExtensionUIContext?.bind(interactive);
-    if (typeof originalCreate !== 'function') {
-        return;
-    }
-    interactive.createExtensionUIContext = function patchedCreateExtensionUIContext(...args) {
-        const baseUi = originalCreate(...args);
-        if (!baseUi || typeof baseUi !== 'object') {
-            return baseUi;
-        }
-        return createPodBackedExtensionUiContext(baseUi, {
-            cwd: interactive?.session?.cwd ?? runtime?.cwd ?? process.cwd(),
-            sessionId: () => interactive?.sessionManager?.getSessionId?.()
-                ?? interactive?.session?.sessionManager?.getSessionId?.()
-                ?? interactive?.session?.sessionId,
-            sessionControl,
-            onWarning(error) {
-                const message = error instanceof Error ? error.message : String(error);
-                interactive.showWarning?.(`Pod approval sync unavailable: ${message}`);
-            },
-        });
-    };
-    interactive.__linxPodBackedExtensionUiInstalled = true;
-}
-export function installBackendCommandRouter(interactive, router) {
-    if (!router) {
-        return;
-    }
-    interactive.__linxHandleProjectedBackendCommand = async (text) => {
-        const command = text.trim();
-        if (!shouldRouteToBackendCommand(command)) {
-            return false;
-        }
-        let routed;
-        try {
-            routed = await router.execute(command);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            interactive.showError?.(`${router.backend} command failed: ${message}`);
-            return true;
-        }
-        if (!routed.handled) {
-            return false;
-        }
-        if (routed.message) {
-            interactive.showStatus?.(routed.message);
-        }
-        interactive.ui?.requestRender?.();
-        return true;
-    };
-    installProjectedCommandRouter(interactive);
-    const originalSetup = interactive.setupEditorSubmitHandler?.bind(interactive);
-    if (typeof originalSetup !== 'function') {
-        return;
-    }
-    interactive.setupEditorSubmitHandler = function patchedBackendCommandSetupEditorSubmitHandler(...args) {
-        const result = originalSetup(...args);
-        const originalSubmit = this.defaultEditor?.onSubmit?.bind(this.defaultEditor);
-        if (typeof originalSubmit !== 'function') {
-            return result;
-        }
-        this.defaultEditor.onSubmit = async (text) => {
-            const command = text.trim();
-            if (!shouldRouteToBackendCommand(command)) {
-                await originalSubmit(text);
-                return;
-            }
-            let routed;
-            try {
-                routed = await router.execute(command);
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                this.showError?.(`${router.backend} command failed: ${message}`);
-                return;
-            }
-            if (!routed.handled) {
-                await originalSubmit(text);
-                return;
-            }
-            if (routed.clearInput !== false) {
-                this.editor?.setText?.('');
-            }
-            if (routed.message) {
-                this.showStatus?.(routed.message);
-            }
-            this.ui?.requestRender?.();
-        };
-        return result;
-    };
-}
-function shouldRouteToBackendCommand(command) {
-    if (!command.startsWith('/')) {
-        return false;
-    }
-    const name = command.slice(1).split(/\s+/, 1)[0]?.toLowerCase();
-    if (!name) {
-        return false;
-    }
-    return BACKEND_OWNED_SLASH_COMMANDS.has(name);
-}
-export function installLinxGlobalCommands(interactive, runtime, sessionCwd, options = {}) {
-    installLinxCwdStartupNotice(interactive, sessionCwd);
-    installLinxAutoEditorIndicator(interactive);
-    if (options.onAutoControlChange) {
-        interactive.__linxOnAutoControlChange = options.onAutoControlChange;
-    }
-    installLinxGlobalCommandHandler(interactive, runtime);
-}
-export function installLinxAutoEditorIndicator(interactive) {
-    if (!interactive || interactive.__linxAutoEditorIndicatorInstalled) {
-        return;
-    }
-    decorateLinxAutoEditorRender(interactive.defaultEditor, interactive);
-    if (interactive.editor && interactive.editor !== interactive.defaultEditor) {
-        decorateLinxAutoEditorRender(interactive.editor, interactive);
-    }
-    const originalSetCustomEditorComponent = interactive.setCustomEditorComponent?.bind(interactive);
-    if (typeof originalSetCustomEditorComponent === 'function') {
-        interactive.setCustomEditorComponent = function patchedSetCustomEditorComponent(...args) {
-            const result = originalSetCustomEditorComponent(...args);
-            decorateLinxAutoEditorRender(this.defaultEditor, this);
-            if (this.editor && this.editor !== this.defaultEditor) {
-                decorateLinxAutoEditorRender(this.editor, this);
-            }
-            return result;
-        };
-    }
-    interactive.__linxAutoEditorIndicatorInstalled = true;
-}
-function decorateLinxAutoEditorRender(editor, interactive) {
-    if (!editor || editor.__linxAutoEditorIndicatorRenderInstalled || typeof editor.render !== 'function') {
-        return;
-    }
-    const originalRender = editor.render.bind(editor);
-    editor.render = function linxAutoEditorIndicatorRender(width) {
-        const lines = originalRender(width);
-        if (interactive.__autoEnabled !== true) {
-            return lines;
-        }
-        return decorateLinxAutoEditorLines(lines, width);
-    };
-    editor.__linxAutoEditorIndicatorRenderInstalled = true;
-}
-function decorateLinxAutoEditorLines(lines, width) {
-    const rendered = Array.isArray(lines) ? [...lines] : [];
-    const indicator = buildLinxAutoEditorIndicatorLine(width);
-    if (rendered.length === 0) {
-        return [indicator];
-    }
-    rendered[0] = indicator;
-    return rendered;
-}
-export function buildLinxAutoEditorIndicatorLine(width) {
-    if (width <= 0) {
-        return '';
-    }
-    const label = ' 托管中 · Secretary 自动输入 · Ctrl+C 接管 · /auto off ';
-    const fitted = truncateToWidth(label, width);
-    const padded = fitted + ' '.repeat(Math.max(0, width - visibleWidth(fitted)));
-    return `\x1b[1m\x1b[38;5;230m\x1b[48;5;58m${padded}\x1b[0m`;
-}
-function installLinxGlobalCommandHandler(interactive, runtime) {
-    if (interactive.__linxGlobalCommandHandlerInstalled) {
-        return;
-    }
-    const originalSetup = interactive.setupEditorSubmitHandler?.bind(interactive);
-    if (typeof originalSetup !== 'function') {
-        return;
-    }
-    interactive.setupEditorSubmitHandler = function patchedLinxGlobalSetupEditorSubmitHandler(...args) {
-        const result = originalSetup(...args);
-        const originalSubmit = this.defaultEditor?.onSubmit?.bind(this.defaultEditor);
-        if (typeof originalSubmit !== 'function') {
-            return result;
-        }
-        this.defaultEditor.onSubmit = async (text) => {
-            const command = parseLinxGlobalCommand(text.trim());
-            if (!command) {
-                recordSubmittedUserMessage(this, runtime, text);
-                await originalSubmit(text);
-                return;
-            }
-            this.editor?.setText?.('');
-            await handleLinxGlobalCommand(this, runtime, command);
-        };
-        return result;
-    };
-    interactive.__linxGlobalCommandHandlerInstalled = true;
-    interactive.__linxHandleProjectedGlobalCommand = async (text) => {
-        const command = parseLinxGlobalCommand(text.trim());
-        if (!command) {
-            return false;
-        }
-        await handleLinxGlobalCommand(interactive, runtime, command);
-        if (command.action === 'peer-command') {
-            return 'peer-command';
-        }
-        return true;
-    };
-    installProjectedCommandRouter(interactive);
-}
-export function installLinxInputCommandRouter(interactive, runtime) {
-    if (!interactive || interactive.__linxInputCommandRouterInstalled) {
-        return;
-    }
-    const originalGetUserInput = interactive.getUserInput?.bind(interactive);
-    if (typeof originalGetUserInput !== 'function') {
-        return;
-    }
-    interactive.getUserInput = async function patchedLinxGetUserInput(...args) {
-        while (true) {
-            const input = await originalGetUserInput(...args);
-            if (typeof input !== 'string') {
-                return input;
-            }
-            const command = parseLinxGlobalCommand(input.trim());
-            if (!command) {
-                return input;
-            }
-            this.editor?.setText?.('');
-            await handleLinxGlobalCommand(this, runtime, command);
-        }
-    };
-    interactive.__linxInputCommandRouterInstalled = true;
-}
-export function installLinxFinalSubmitCommandRouter(interactive, runtime) {
-    if (!interactive) {
-        return;
-    }
-    const wrapEditor = (editor) => {
-        if (!editor || typeof editor.onSubmit !== 'function') {
-            return;
-        }
-        if (editor.onSubmit.__linxFinalSubmitCommandRouterWrapped === true) {
-            return;
-        }
-        const originalSubmit = editor.onSubmit.bind(editor);
-        const wrappedSubmit = async (text) => {
-            const command = parseLinxGlobalCommand(String(text ?? '').trim());
-            if (!command) {
-                await originalSubmit(text);
-                return;
-            }
-            interactive.editor?.setText?.('');
-            await handleLinxGlobalCommand(interactive, runtime, command);
-        };
-        wrappedSubmit.__linxFinalSubmitCommandRouterWrapped = true;
-        editor.onSubmit = wrappedSubmit;
-    };
-    wrapEditor(interactive.defaultEditor);
-    if (interactive.editor !== interactive.defaultEditor) {
-        wrapEditor(interactive.editor);
-    }
-    const originalSetCustomEditorComponent = interactive.setCustomEditorComponent?.bind(interactive);
-    if (typeof originalSetCustomEditorComponent === 'function'
-        && interactive.__linxFinalSubmitSetCustomEditorComponentPatched !== true) {
-        interactive.setCustomEditorComponent = function patchedLinxFinalSubmitSetCustomEditorComponent(...args) {
-            const result = originalSetCustomEditorComponent(...args);
-            wrapEditor(this.defaultEditor);
-            if (this.editor !== this.defaultEditor) {
-                wrapEditor(this.editor);
-            }
-            return result;
-        };
-        interactive.__linxFinalSubmitSetCustomEditorComponentPatched = true;
-    }
-    interactive.__linxFinalSubmitCommandRouterInstalled = true;
-}
-export function installLinxSessionCommandRouter(interactive, runtime) {
-    const session = interactive?.session ?? runtime?.session;
-    if (!session || typeof session !== 'object' || session.__linxSessionCommandRouterInstalled === true) {
-        return;
-    }
-    const originalPrompt = typeof session.prompt === 'function'
-        ? session.prompt.bind(session)
-        : undefined;
-    const originalSendUserMessage = typeof session.sendUserMessage === 'function'
-        ? session.sendUserMessage.bind(session)
-        : undefined;
-    if (!originalPrompt && !originalSendUserMessage) {
-        return;
-    }
-    if (originalPrompt) {
-        session.__linxPromptWithoutCommandRouting = originalPrompt;
-        session.prompt = async (text, ...args) => {
-            if (await maybeHandleLinxSessionCommand(interactive, runtime, text)) {
-                return undefined;
-            }
-            return originalPrompt(text, ...args);
-        };
-    }
-    if (originalSendUserMessage) {
-        session.__linxSendUserMessageWithoutCommandRouting = originalSendUserMessage;
-        session.sendUserMessage = async (text, ...args) => {
-            if (await maybeHandleLinxSessionCommand(interactive, runtime, text)) {
-                return undefined;
-            }
-            return originalSendUserMessage(text, ...args);
-        };
-    }
-    session.__linxSessionCommandRouterInstalled = true;
-}
-function installLinxSessionCommandRouterAfterRebind(interactive, runtime) {
-    if (!interactive || interactive.__linxSessionCommandRouterAfterRebindInstalled === true) {
-        return;
-    }
-    const originalRebind = interactive.rebindCurrentSession?.bind(interactive);
-    if (typeof originalRebind !== 'function') {
-        return;
-    }
-    interactive.rebindCurrentSession = async function patchedLinxRebindCurrentSession(...args) {
-        const result = await originalRebind(...args);
-        installLinxSessionCommandRouter(this, runtime);
-        return result;
-    };
-    interactive.__linxSessionCommandRouterAfterRebindInstalled = true;
-}
-async function maybeHandleLinxSessionCommand(interactive, runtime, text) {
-    if (typeof text !== 'string') {
-        return false;
-    }
-    const command = parseLinxGlobalCommand(text.trim());
-    if (!command) {
-        return false;
-    }
-    interactive.editor?.setText?.('');
-    await handleLinxGlobalCommand(interactive, runtime, command);
-    return true;
-}
-function recordSubmittedUserMessage(interactive, runtime, text) {
-    const input = text.trim();
-    if (!input || input.startsWith('/')) {
-        return;
-    }
-    try {
-        getSessionControlManager(interactive, runtime).recordUserMessage({ text: input });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        interactive.showWarning?.(`Thread reconciliation unavailable: ${message}`);
-    }
-}
-function parseLinxGlobalCommand(input) {
-    const autoModeRoute = resolveAutoModeCommandRoute(input);
-    if (autoModeRoute?.kind === 'control-command') {
-        return { action: 'auto', route: autoModeRoute };
-    }
-    if (autoModeRoute?.kind === 'peer-command') {
-        return { action: 'peer-command', route: autoModeRoute };
-    }
-    if (input === '/cd') {
-        return { action: 'cd' };
-    }
-    if (input.startsWith('/cd ')) {
-        return { action: 'cd', target: input.slice('/cd'.length).trim() };
-    }
-    if (input === '/ai connect') {
-        return { action: 'ai-connect' };
-    }
-    if (input.startsWith('/ai connect ')) {
-        return { action: 'ai-connect', ...parseInteractiveAiConnectArgs(input.slice('/ai connect'.length).trim()) };
-    }
-    if (input === '/statusline' || input === '/status-line') {
-        return { action: 'statusline', args: [] };
-    }
-    if (input.startsWith('/statusline ') || input.startsWith('/status-line ')) {
-        const body = input.startsWith('/statusline ')
-            ? input.slice('/statusline'.length).trim()
-            : input.slice('/status-line'.length).trim();
-        return { action: 'statusline', args: splitInteractiveCommandArgs(body) };
-    }
-    if (input === '/update' || input === '/upgrade') {
-        return { action: 'update' };
-    }
-    if (input === '/rewind') {
-        return { action: 'rewind-select' };
-    }
-    if (input.startsWith('/rewind ')) {
-        const turns = parseRewindTurnCount(input.slice('/rewind'.length).trim());
-        return { action: 'rewind-turns', turns: turns ?? 0 };
-    }
-    return null;
-}
-function parseRewindTurnCount(input) {
-    if (!/^\d+$/.test(input)) {
-        return null;
-    }
-    const value = Number.parseInt(input, 10);
-    return Number.isSafeInteger(value) && value > 0 ? value : null;
-}
-function parseInteractiveAiConnectArgs(input) {
-    const tokens = splitInteractiveCommandArgs(input);
-    let provider;
-    let baseUrl;
-    let model;
-    for (let index = 0; index < tokens.length; index += 1) {
-        const token = tokens[index];
-        if (!token) {
-            continue;
-        }
-        if (token === '--base-url') {
-            baseUrl = tokens[index + 1];
-            index += 1;
-            continue;
-        }
-        if (token.startsWith('--base-url=')) {
-            baseUrl = token.slice('--base-url='.length);
-            continue;
-        }
-        if (token === '--model') {
-            model = tokens[index + 1];
-            index += 1;
-            continue;
-        }
-        if (token.startsWith('--model=')) {
-            model = token.slice('--model='.length);
-            continue;
-        }
-        if (!token.startsWith('-') && !provider) {
-            provider = token;
-        }
-    }
-    return {
-        ...(provider?.trim() ? { provider: provider.trim() } : {}),
-        ...(baseUrl?.trim() ? { baseUrl: baseUrl.trim() } : {}),
-        ...(model?.trim() ? { model: model.trim() } : {}),
-    };
-}
-function splitInteractiveCommandArgs(input) {
-    const tokens = [];
-    let current = '';
-    let quote = null;
-    let escaping = false;
-    for (const char of input) {
-        if (escaping) {
-            current += char;
-            escaping = false;
-            continue;
-        }
-        if (char === '\\') {
-            escaping = true;
-            continue;
-        }
-        if (quote) {
-            if (char === quote) {
-                quote = null;
-            }
-            else {
-                current += char;
-            }
-            continue;
-        }
-        if (char === '"' || char === "'") {
-            quote = char;
-            continue;
-        }
-        if (/\s/.test(char)) {
-            if (current) {
-                tokens.push(current);
-                current = '';
-            }
-            continue;
-        }
-        current += char;
-    }
-    if (escaping) {
-        current += '\\';
-    }
-    if (current) {
-        tokens.push(current);
-    }
-    return tokens;
-}
-async function handleLinxGlobalCommand(interactive, runtime, command) {
-    if (command.action === 'auto') {
-        const auto = command.route.auto;
-        const enabled = auto?.action === 'set' ? auto.enabled : undefined;
-        const initialInput = auto?.action === 'set' ? auto.initialInput : undefined;
-        await handleInteractiveAutoCommand(interactive, runtime, enabled, {
-            scheduleImmediately: initialInput === undefined,
-        });
-        if (initialInput) {
-            const controller = getSecretaryAutoInputController(interactive, runtime, getSessionControlManager(interactive, runtime));
-            await controller.submit(initialInput, { reason: 'auto-on' });
-        }
-        return;
-    }
-    if (command.action === 'peer-command') {
-        await handleInteractivePeerCommand(interactive, runtime, command.route);
-        return;
-    }
-    if (command.action === 'ai-connect') {
-        await handleInteractiveAiConnectCommand(interactive, runtime, command);
-        return;
-    }
-    if (command.action === 'statusline') {
-        await handleInteractiveStatusLineCommand(interactive, command.args);
-        return;
-    }
-    if (command.action === 'update') {
-        await checkAndShowLinxUpdate(interactive, { manual: true });
-        return;
-    }
-    if (command.action === 'rewind-select') {
-        await handleInteractiveRewindSelector(interactive, runtime);
-        return;
-    }
-    if (command.action === 'rewind-turns') {
-        await handleInteractiveRewindTurnsCommand(interactive, runtime, command.turns);
-        return;
-    }
-    await changeInteractiveCwd(interactive, runtime, command.target);
-}
-async function handleInteractiveStatusLineCommand(interactive, args) {
-    if (args.length > 0) {
-        handleInteractiveStatusLineArgs(interactive, args);
-        return;
-    }
-    const summary = formatInteractiveStatusLineSummary();
-    if (typeof interactive.showSelector === 'function') {
-        await showInteractiveStatusLineMultiSelect(interactive);
-        return;
-    }
-    if (typeof interactive.showExtensionSelector === 'function') {
-        await showInteractiveStatusLineFallbackSelector(interactive);
-        return;
-    }
-    {
-        interactive.showStatus?.(`${summary} · Use /statusline set <tokens...>, /statusline tokens, /statusline colors <on|off>, or /statusline reset.`);
-        interactive.ui?.requestRender?.();
-        return;
-    }
-}
-async function showInteractiveStatusLineFallbackSelector(interactive) {
-    while (true) {
-        const currentSummary = formatInteractiveStatusLineSummary();
-        const config = readLinxStatusLineConfig();
-        const options = buildInteractiveStatusLineOptions(config);
-        const choice = await interactive.showExtensionSelector(`Status line\n${currentSummary}`, options);
-        if (!choice || choice === STATUS_LINE_DONE_OPTION) {
-            return;
-        }
-        const token = parseInteractiveStatusLineTokenChoice(choice);
-        if (token) {
-            toggleInteractiveStatusLineToken(interactive, token);
-            continue;
-        }
-        if (choice === STATUS_LINE_CODEX_PRESET_OPTION) {
-            writeInteractiveStatusLineConfig(interactive, {
-                statusLine: CODEX_STYLE_STATUS_LINE_TOKENS,
-                message: 'Status line set to Codex-style preset.',
-            });
-            continue;
-        }
-        if (choice === STATUS_LINE_COMPACT_PRESET_OPTION) {
-            writeInteractiveStatusLineConfig(interactive, {
-                statusLine: COMPACT_STATUS_LINE_TOKENS,
-                message: 'Status line set to compact preset.',
-            });
-            continue;
-        }
-        if (choice === STATUS_LINE_TOGGLE_COLORS_OPTION) {
-            const current = readLinxStatusLineConfig();
-            writeInteractiveStatusLineConfig(interactive, {
-                statusLineUseColors: !current.useColors,
-                message: `Status line colors ${current.useColors ? 'disabled' : 'enabled'}.`,
-            });
-            continue;
-        }
-        if (choice === STATUS_LINE_RESET_OPTION) {
-            resetLinxStatusLineConfig();
-            finishInteractiveStatusLineUpdate(interactive, `Status line reset to default: ${DEFAULT_STATUS_LINE_TOKENS.join(', ')}`);
-        }
-    }
-}
-async function showInteractiveStatusLineMultiSelect(interactive) {
-    await new Promise((resolvePromise, rejectPromise) => {
-        let resolved = false;
-        const resolveOnce = () => {
-            if (!resolved) {
-                resolved = true;
-                resolvePromise();
-            }
-        };
-        try {
-            interactive.showSelector((done) => {
-                const close = () => {
-                    done();
-                    resolveOnce();
-                };
-                const selector = new LinxStatusLineSelectorComponent(readLinxStatusLineConfig(), ({ tokens, useColors }) => {
-                    writeInteractiveStatusLineConfig(interactive, {
-                        statusLine: tokens,
-                        statusLineUseColors: useColors,
-                        message: `Status line updated: ${tokens.join(', ')}`,
-                    });
-                    close();
-                }, () => {
-                    close();
-                    interactive.ui?.requestRender?.();
-                });
-                return { component: selector, focus: selector.getList() };
-            });
-        }
-        catch (error) {
-            rejectPromise(error);
-        }
-    });
-}
-function buildInteractiveStatusLineOptions(config = readLinxStatusLineConfig()) {
-    const enabled = new Set(config.tokens);
-    return [
-        ...LINX_STATUS_LINE_TOKEN_NAMES.map((token) => `${enabled.has(token) ? '✓' : '○'} ${token}`),
-        STATUS_LINE_CODEX_PRESET_OPTION,
-        STATUS_LINE_COMPACT_PRESET_OPTION,
-        STATUS_LINE_TOGGLE_COLORS_OPTION,
-        STATUS_LINE_RESET_OPTION,
-        STATUS_LINE_DONE_OPTION,
-    ];
-}
-function parseInteractiveStatusLineTokenChoice(choice) {
-    if (typeof choice !== 'string') {
-        return null;
-    }
-    const token = choice.replace(/^[✓○]\s*/u, '').trim();
-    if (!token) {
-        return null;
-    }
-    return LINX_STATUS_LINE_TOKEN_NAMES.includes(token)
-        ? token
-        : null;
-}
-function toggleInteractiveStatusLineToken(interactive, token) {
-    const current = readLinxStatusLineConfig().tokens;
-    const exists = current.includes(token);
-    if (exists && current.length <= 1) {
-        interactive.showError?.('Status line needs at least one item.');
-        return;
-    }
-    const next = exists
-        ? current.filter((item) => item !== token)
-        : [...current, token];
-    writeInteractiveStatusLineConfig(interactive, {
-        statusLine: next,
-        message: `Status line ${exists ? 'removed' : 'added'}: ${token}`,
-    });
-}
-function handleInteractiveStatusLineArgs(interactive, args) {
-    const action = args[0]?.toLowerCase();
-    if (action === 'tokens' || action === 'list') {
-        showInteractiveStatusLineTokens(interactive);
-        return;
-    }
-    if (action === 'reset') {
-        resetLinxStatusLineConfig();
-        finishInteractiveStatusLineUpdate(interactive, `Status line reset to default: ${DEFAULT_STATUS_LINE_TOKENS.join(', ')}`);
-        return;
-    }
-    if (action === 'colors' || action === 'color') {
-        const value = parseLinxStatusLineColorArg(args[1]);
-        if (value === undefined) {
-            interactive.showError?.('Usage: /statusline colors <on|off>');
-            return;
-        }
-        writeInteractiveStatusLineConfig(interactive, {
-            statusLineUseColors: value,
-            message: `Status line colors ${value ? 'enabled' : 'disabled'}.`,
-        });
-        return;
-    }
-    const tokenArgs = action === 'set' ? args.slice(1) : args;
-    try {
-        const tokens = parseLinxStatusLineTokenArgs(tokenArgs);
-        writeInteractiveStatusLineConfig(interactive, {
-            statusLine: tokens,
-            message: `Status line updated: ${tokens.join(', ')}`,
-        });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        interactive.showError?.(`${message}. Use /statusline tokens to list valid tokens.`);
-    }
-}
-function writeInteractiveStatusLineConfig(interactive, patch) {
-    writeLinxStatusLineConfigPatch({
-        ...(patch.statusLine ? { statusLine: patch.statusLine } : {}),
-        ...(patch.statusLineUseColors !== undefined ? { statusLineUseColors: patch.statusLineUseColors } : {}),
-    });
-    finishInteractiveStatusLineUpdate(interactive, patch.message);
-}
-function finishInteractiveStatusLineUpdate(interactive, message) {
-    interactive.footer?.invalidate?.();
-    interactive.showStatus?.(message);
-    interactive.ui?.requestRender?.();
-}
-function showInteractiveStatusLineTokens(interactive) {
-    interactive.showStatus?.(`Status line tokens: ${LINX_STATUS_LINE_TOKEN_NAMES.join(', ')}`);
-    interactive.ui?.requestRender?.();
-}
-function formatInteractiveStatusLineSummary() {
-    const config = readLinxStatusLineConfig();
-    return `Current: ${config.tokens.join(', ')} · colors ${config.useColors ? 'on' : 'off'} · source ${config.tokenSource}`;
-}
-async function handleInteractiveRewindSelector(interactive, runtime) {
-    const session = resolveInteractiveSession(interactive, runtime);
-    const sessionManager = resolveInteractiveSessionManager(interactive, runtime);
-    if (!sessionManager) {
-        interactive.showError?.('Cannot rewind: no active LinX session history.');
-        interactive.ui?.requestRender?.();
-        return;
-    }
-    if (typeof interactive.showSelector !== 'function') {
-        await handleInteractiveRewindTurnsCommand(interactive, runtime, 1);
-        return;
-    }
-    const userMessages = collectRewindUserMessages(session, sessionManager);
-    if (userMessages.length === 0) {
-        interactive.showStatus?.('Nothing to rewind: no user turns in the active branch.');
-        interactive.ui?.requestRender?.();
-        return;
-    }
-    const initialSelectedId = userMessages[userMessages.length - 1]?.id;
-    interactive.showSelector((done) => {
-        const selector = new LinxRewindMessageSelectorComponent(userMessages, async (entryId) => {
-            try {
-                await rewindSessionManagerBeforeUserEntry(interactive, runtime, session, sessionManager, entryId);
-                done();
-            }
-            catch (error) {
-                done();
-                interactive.showError?.(error instanceof Error ? error.message : String(error));
-            }
-        }, () => {
-            done();
-            interactive.ui?.requestRender?.();
-        }, initialSelectedId);
-        return { component: selector, focus: selector.getMessageList() };
-    });
-}
-async function handleInteractiveRewindTurnsCommand(interactive, runtime, turns) {
-    if (!Number.isSafeInteger(turns) || turns <= 0) {
-        interactive.showStatus?.('Usage: /rewind [turns] where turns is a positive integer.');
-        interactive.ui?.requestRender?.();
-        return;
-    }
-    const session = resolveInteractiveSession(interactive, runtime);
-    const sessionManager = resolveInteractiveSessionManager(interactive, runtime);
-    if (!sessionManager) {
-        interactive.showError?.('Cannot rewind: no active LinX session history.');
-        interactive.ui?.requestRender?.();
-        return;
-    }
-    await stopActiveSessionWorkForRewind(session);
-    resetPendingAutoInputForRewind(interactive, runtime);
-    const previousState = captureRewindSessionState(sessionManager);
-    const previousBranch = getActiveSessionBranch(sessionManager);
-    const result = rewindSessionManagerByTurns(sessionManager, turns);
-    if (result.rewound === 0) {
-        interactive.showStatus?.('Nothing to rewind: no user turns in the active branch.');
-        interactive.ui?.requestRender?.();
-        return;
-    }
-    const cleanResult = materializeCleanRewindSession(sessionManager, result.targetLeafId, previousState);
-    syncAgentStateFromSessionManager(session, sessionManager);
-    refreshInteractiveTranscriptFromSessionManager(interactive);
-    await syncRewindProjection(interactive, runtime, {
-        previousState,
-        cleanResult,
-        abandonedEntries: collectAbandonedRewindEntries(previousBranch, result.targetLeafId),
-    });
-    const remainingMessages = Array.isArray(session?.agent?.state?.messages)
-        ? session.agent.state.messages.length
-        : undefined;
-    const target = describeRewindTarget(result.targetLeafId, cleanResult);
-    const suffix = remainingMessages === undefined ? '' : ` Active context now has ${remainingMessages} message${remainingMessages === 1 ? '' : 's'}.`;
-    interactive.showStatus?.(`Rewound ${result.rewound} turn${result.rewound === 1 ? '' : 's'} to ${target}.${suffix}`);
-    interactive.ui?.requestRender?.();
-}
-async function rewindSessionManagerBeforeUserEntry(interactive, runtime, session, sessionManager, entryId) {
-    const entry = typeof sessionManager?.getEntry === 'function'
-        ? sessionManager.getEntry(entryId)
-        : getActiveSessionBranch(sessionManager).find((candidate) => candidate?.id === entryId);
-    if (!entry || entry.type !== 'message' || entry.message?.role !== 'user') {
-        throw new Error('Cannot rewind: selected message is not a user turn in the active branch.');
-    }
-    const previousState = captureRewindSessionState(sessionManager);
-    const previousBranch = getActiveSessionBranch(sessionManager);
-    await stopActiveSessionWorkForRewind(session);
-    resetPendingAutoInputForRewind(interactive, runtime);
-    const targetLeafId = typeof entry.parentId === 'string' && entry.parentId ? entry.parentId : null;
-    moveSessionManagerLeaf(sessionManager, targetLeafId);
-    const cleanResult = materializeCleanRewindSession(sessionManager, targetLeafId, previousState);
-    syncAgentStateFromSessionManager(session, sessionManager);
-    refreshInteractiveTranscriptFromSessionManager(interactive);
-    await syncRewindProjection(interactive, runtime, {
-        previousState,
-        cleanResult,
-        abandonedEntries: collectAbandonedRewindEntries(previousBranch, targetLeafId),
-    });
-    const remainingMessages = Array.isArray(session?.agent?.state?.messages)
-        ? session.agent.state.messages.length
-        : undefined;
-    const target = describeRewindTarget(targetLeafId, cleanResult);
-    const suffix = remainingMessages === undefined ? '' : ` Active context now has ${remainingMessages} message${remainingMessages === 1 ? '' : 's'}.`;
-    interactive.showStatus?.(`Rewound to before selected message at ${target}.${suffix}`);
-    interactive.ui?.requestRender?.();
-}
-function resolveInteractiveSession(interactive, runtime) {
-    return interactive?.session ?? runtime?.session;
-}
-function resolveInteractiveSessionManager(interactive, runtime) {
-    return interactive?.session?.sessionManager
-        ?? interactive?.sessionManager
-        ?? runtime?.session?.sessionManager
-        ?? runtime?.sessionManager;
-}
-async function stopActiveSessionWorkForRewind(session) {
-    if (!session) {
-        return;
-    }
-    const shouldWait = session.isStreaming === true || session.isBashRunning === true;
-    try {
-        if (session.isBashRunning === true && typeof session.abortBash === 'function') {
-            session.abortBash();
-        }
-        if (session.isStreaming === true && typeof session.abort === 'function') {
-            session.abort();
-        }
-    }
-    catch {
-        // Rewind should still repair the active branch even if abort reporting fails.
-    }
-    if (!shouldWait || typeof session.agent?.waitForIdle !== 'function') {
-        return;
-    }
-    await Promise.race([
-        Promise.resolve(session.agent.waitForIdle()).catch(() => undefined),
-        new Promise((resolve) => setTimeout(resolve, 1_500)),
-    ]);
-}
-function resetPendingAutoInputForRewind(interactive, runtime) {
-    if (interactive?.__autoEnabled !== true || !interactive?.__linxAutoInputController) {
-        return;
-    }
-    try {
-        interactive.__linxAutoInputController.stop();
-        interactive.__linxAutoInputController.start({ scheduleImmediately: false });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        interactive.showWarning?.(`Auto input reset after rewind failed: ${message}`);
-    }
-    if (runtime && typeof runtime === 'object') {
-        runtime.autoEnabled = true;
-    }
-}
-function rewindSessionManagerByTurns(sessionManager, turns) {
-    let rewound = 0;
-    let targetLeafId = resolveSessionManagerLeafId(sessionManager);
-    for (; rewound < turns; rewound += 1) {
-        const branch = getActiveSessionBranch(sessionManager);
-        const latestUserEntry = findLatestUserMessageEntry(branch);
-        if (!latestUserEntry) {
-            break;
-        }
-        targetLeafId = typeof latestUserEntry.parentId === 'string' && latestUserEntry.parentId
-            ? latestUserEntry.parentId
-            : null;
-        moveSessionManagerLeaf(sessionManager, targetLeafId);
-    }
-    return { rewound, targetLeafId };
-}
-function resolveSessionManagerLeafId(sessionManager) {
-    return typeof sessionManager?.getLeafId === 'function'
-        ? sessionManager.getLeafId()
-        : null;
-}
-function getActiveSessionBranch(sessionManager) {
-    const hasLeafApi = typeof sessionManager?.getLeafId === 'function';
-    const leafId = hasLeafApi ? sessionManager.getLeafId() : undefined;
-    if (hasLeafApi && leafId === null) {
-        return [];
-    }
-    if (typeof sessionManager?.getBranch === 'function') {
-        const branch = hasLeafApi ? sessionManager.getBranch(leafId) : sessionManager.getBranch();
-        return Array.isArray(branch) ? branch : [];
-    }
-    const entries = typeof sessionManager?.getEntries === 'function' ? sessionManager.getEntries() : [];
-    return Array.isArray(entries) ? entries : [];
-}
-function findLatestUserMessageEntry(branch) {
-    for (let index = branch.length - 1; index >= 0; index -= 1) {
-        const entry = branch[index];
-        if (entry?.type === 'message' && entry.message?.role === 'user') {
-            return entry;
-        }
-    }
-    return null;
-}
-function moveSessionManagerLeaf(sessionManager, leafId) {
-    if (leafId) {
-        sessionManager.branch?.(leafId);
-        return;
-    }
-    sessionManager.resetLeaf?.();
-}
-function captureRewindSessionState(sessionManager) {
-    return {
-        id: normalizeRewindString(sessionManager?.getSessionId?.()),
-        file: normalizeRewindString(sessionManager?.getSessionFile?.()),
-        createdAt: resolveRewindSessionCreatedAt(sessionManager),
-    };
-}
-function materializeCleanRewindSession(sessionManager, targetLeafId, previousState) {
-    const beforeId = previousState.id;
-    let materialized = false;
-    let warning;
-    try {
-        if (targetLeafId && typeof sessionManager?.createBranchedSession === 'function') {
-            sessionManager.createBranchedSession(targetLeafId);
-            materialized = true;
-        }
-        else if (!targetLeafId && typeof sessionManager?.newSession === 'function') {
-            sessionManager.newSession(previousState.file ? { parentSession: previousState.file } : undefined);
-            materialized = true;
-        }
-    }
-    catch (error) {
-        warning = error instanceof Error ? error.message : String(error);
-    }
-    const id = normalizeRewindString(sessionManager?.getSessionId?.());
-    const file = normalizeRewindString(sessionManager?.getSessionFile?.());
-    return {
-        materialized,
-        sessionChanged: Boolean(beforeId && id && beforeId !== id),
-        id,
-        file,
-        ...(warning ? { warning } : {}),
-    };
-}
-function describeRewindTarget(targetLeafId, cleanResult) {
-    const target = targetLeafId ? `leaf ${targetLeafId}` : 'session root';
-    if (!cleanResult.materialized) {
-        return target;
-    }
-    if (cleanResult.sessionChanged && cleanResult.id) {
-        return `${target} in clean session ${cleanResult.id}`;
-    }
-    return `${target} in clean session`;
-}
-function collectAbandonedRewindEntries(previousBranch, targetLeafId) {
-    if (!Array.isArray(previousBranch) || previousBranch.length === 0) {
-        return [];
-    }
-    if (!targetLeafId) {
-        return previousBranch;
-    }
-    const targetIndex = previousBranch.findIndex((entry) => entry?.id === targetLeafId);
-    return targetIndex >= 0 ? previousBranch.slice(targetIndex + 1) : previousBranch;
-}
-async function syncRewindProjection(interactive, runtime, input) {
-    if (input.cleanResult.warning) {
-        interactive.showWarning?.(`Clean rewind history materialization skipped: ${input.cleanResult.warning}`);
-    }
-    const mirror = runtime?.__linxPodMirror ?? interactive?.__linxPodMirror;
-    if (!mirror || typeof mirror.syncRewindProjection !== 'function') {
-        return;
-    }
-    try {
-        await mirror.syncRewindProjection({
-            previousSessionId: input.previousState.id,
-            previousSessionFile: input.previousState.file,
-            previousCreatedAt: input.previousState.createdAt,
-            cleanSessionId: input.cleanResult.id,
-            cleanSessionFile: input.cleanResult.file,
-            abandonedEntries: input.abandonedEntries,
-        });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        interactive.showWarning?.(`Pod rewind projection unavailable: ${message}`);
-    }
-}
-function resolveRewindSessionCreatedAt(sessionManager) {
-    const headerTimestamp = normalizeRewindString(sessionManager?.getHeader?.()?.timestamp);
-    const headerDate = toValidRewindDate(headerTimestamp);
-    if (headerDate) {
-        return headerDate;
-    }
-    const entries = Array.isArray(sessionManager?.getEntries?.()) ? sessionManager.getEntries() : [];
-    for (const entry of entries) {
-        const timestamp = normalizeRewindString(entry?.timestamp);
-        const date = toValidRewindDate(timestamp);
-        if (date) {
-            return date;
-        }
-    }
-    const sessionId = normalizeRewindString(sessionManager?.getSessionId?.());
-    return sessionId ? parseRewindDateFromSessionId(sessionId) ?? undefined : undefined;
-}
-function parseRewindDateFromSessionId(sessionId) {
-    const prefix = sessionId.replace(/-/g, '').slice(0, 12);
-    if (!/^[\da-f]{12}$/i.test(prefix)) {
-        return null;
-    }
-    const millis = Number.parseInt(prefix, 16);
-    if (!Number.isFinite(millis) || millis <= 0) {
-        return null;
-    }
-    return toValidRewindDate(millis);
-}
-function toValidRewindDate(value) {
-    if (value instanceof Date) {
-        return Number.isNaN(value.getTime()) ? null : value;
-    }
-    if (typeof value === 'number' || typeof value === 'string') {
-        const date = new Date(value);
-        return Number.isNaN(date.getTime()) ? null : date;
-    }
-    return null;
-}
-function normalizeRewindString(value) {
-    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
-}
-function syncAgentStateFromSessionManager(session, sessionManager) {
-    const context = sessionManager.buildSessionContext?.();
-    if (!context || !session?.agent?.state) {
-        return;
-    }
-    if (Array.isArray(context.messages)) {
-        session.agent.state.messages = context.messages;
-    }
-}
-function refreshInteractiveTranscriptFromSessionManager(interactive) {
-    try {
-        if (typeof interactive?.rebuildChatFromMessages === 'function') {
-            interactive.rebuildChatFromMessages();
-            return;
-        }
-        if (typeof interactive?.renderInitialMessages === 'function') {
-            interactive.chatContainer?.clear?.();
-            interactive.renderInitialMessages();
-        }
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        interactive?.showWarning?.(`Rewind transcript refresh failed: ${message}`);
-    }
-}
-class LinxMultiSelectList {
-    getRows;
-    onToggle;
-    onAction;
-    onCancel;
-    selectedIndex = 0;
-    constructor(getRows, onToggle, onAction, onCancel) {
-        this.getRows = getRows;
-        this.onToggle = onToggle;
-        this.onAction = onAction;
-        this.onCancel = onCancel;
-    }
-    invalidate() {
-        // No cached render state.
-    }
-    render(width) {
-        const rows = this.normalizedRows();
-        if (rows.length === 0) {
-            return ['  No options'];
-        }
-        const lines = [];
-        for (let index = 0; index < rows.length; index += 1) {
-            const row = rows[index];
-            const cursor = index === this.selectedIndex ? '> ' : '  ';
-            const label = row.kind === 'item'
-                ? `${row.selected ? '✓' : '○'} ${row.label}`
-                : row.label;
-            lines.push(`${cursor}${truncateToWidth(label, Math.max(1, width - 2))}`);
-            if (row.description) {
-                lines.push(`  ${truncateToWidth(row.description, Math.max(1, width - 2))}`);
-            }
-        }
-        lines.push('');
-        lines.push('↑↓ navigate  Enter toggles items/actions  Escape/Ctrl+C cancel');
-        return lines;
-    }
-    handleInput(keyData) {
-        const rows = this.normalizedRows();
-        if (rows.length === 0) {
-            return;
-        }
-        const keybindings = getKeybindings();
-        if (keybindings.matches(keyData, 'tui.select.up')) {
-            this.selectedIndex = this.selectedIndex === 0 ? rows.length - 1 : this.selectedIndex - 1;
-            return;
-        }
-        if (keybindings.matches(keyData, 'tui.select.down')) {
-            this.selectedIndex = this.selectedIndex === rows.length - 1 ? 0 : this.selectedIndex + 1;
-            return;
-        }
-        if (keybindings.matches(keyData, 'tui.select.confirm')) {
-            const selected = rows[this.selectedIndex];
-            if (selected?.kind === 'item') {
-                this.onToggle(selected.id);
-            }
-            else if (selected?.kind === 'action') {
-                this.onAction(selected.id);
-            }
-            return;
-        }
-        if (keybindings.matches(keyData, 'tui.select.cancel')) {
-            this.onCancel();
-        }
-    }
-    normalizedRows() {
-        const rows = this.getRows();
-        if (this.selectedIndex >= rows.length) {
-            this.selectedIndex = Math.max(0, rows.length - 1);
-        }
-        return rows;
-    }
-}
-class LinxStatusLineSelectorComponent extends Container {
-    list;
-    draftTokens;
-    draftUseColors;
-    notice = null;
-    constructor(config, onCommit, onCancel) {
-        super();
-        this.draftTokens = [...config.tokens];
-        this.draftUseColors = config.useColors;
-        this.addChild(new Spacer(1));
-        this.addChild(new Text('Status line', 1, 0));
-        this.addChild(new Text('Select the items that appear in the bottom TUI status line.', 1, 0));
-        this.addChild(new Text(`Current source: tokens ${config.tokenSource}, colors ${config.colorSource}.`, 1, 0));
-        this.addChild(new Spacer(1));
-        this.list = new LinxMultiSelectList(() => this.rows(), (id) => this.toggleToken(id), (id) => this.handleAction(id, onCommit), onCancel);
-        this.addChild(this.list);
-    }
-    getList() {
-        return this.list;
-    }
-    rows() {
-        const enabled = new Set(this.draftTokens);
-        const rows = LINX_STATUS_LINE_TOKEN_NAMES.map((token) => ({
-            kind: 'item',
-            id: token,
-            label: token,
-            selected: enabled.has(token),
-        }));
-        rows.push({
-            kind: 'action',
-            id: 'preset-codex',
-            label: STATUS_LINE_CODEX_PRESET_OPTION,
-            description: CODEX_STYLE_STATUS_LINE_TOKENS.join(', '),
-        }, {
-            kind: 'action',
-            id: 'preset-compact',
-            label: STATUS_LINE_COMPACT_PRESET_OPTION,
-            description: COMPACT_STATUS_LINE_TOKENS.join(', '),
-        }, {
-            kind: 'action',
-            id: 'toggle-colors',
-            label: `${STATUS_LINE_TOGGLE_COLORS_OPTION}: ${this.draftUseColors ? 'on' : 'off'}`,
-        }, {
-            kind: 'action',
-            id: 'reset',
-            label: STATUS_LINE_RESET_OPTION,
-            description: DEFAULT_STATUS_LINE_TOKENS.join(', '),
-        }, {
-            kind: 'action',
-            id: 'done',
-            label: STATUS_LINE_DONE_OPTION,
-            description: this.notice ?? 'Save changes and close.',
-        });
-        return rows;
-    }
-    toggleToken(id) {
-        const token = id;
-        if (!LINX_STATUS_LINE_TOKEN_NAMES.includes(token)) {
-            return;
-        }
-        const exists = this.draftTokens.includes(token);
-        if (exists && this.draftTokens.length <= 1) {
-            this.notice = 'Status line needs at least one item.';
-            return;
-        }
-        this.draftTokens = exists
-            ? this.draftTokens.filter((item) => item !== token)
-            : [...this.draftTokens, token];
-        this.notice = null;
-    }
-    handleAction(id, onCommit) {
-        if (id === 'preset-codex') {
-            this.draftTokens = [...CODEX_STYLE_STATUS_LINE_TOKENS];
-            this.notice = 'Draft changed to Codex-style preset.';
-            return;
-        }
-        if (id === 'preset-compact') {
-            this.draftTokens = [...COMPACT_STATUS_LINE_TOKENS];
-            this.notice = 'Draft changed to compact preset.';
-            return;
-        }
-        if (id === 'toggle-colors') {
-            this.draftUseColors = !this.draftUseColors;
-            this.notice = `Draft colors ${this.draftUseColors ? 'enabled' : 'disabled'}.`;
-            return;
-        }
-        if (id === 'reset') {
-            this.draftTokens = [...DEFAULT_STATUS_LINE_TOKENS];
-            this.draftUseColors = true;
-            this.notice = 'Draft reset to default.';
-            return;
-        }
-        if (id === 'done') {
-            onCommit({
-                tokens: this.draftTokens,
-                useColors: this.draftUseColors,
-            });
-        }
-    }
-}
-function collectRewindUserMessages(_session, sessionManager) {
-    return getActiveSessionBranch(sessionManager)
-        .filter((entry) => entry?.type === 'message' && entry.message?.role === 'user')
-        .map((entry) => ({
-        id: String(entry.id),
-        text: extractRewindMessageText(entry.message?.content) || '(empty user message)',
-    }));
-}
-function extractRewindMessageText(content) {
-    if (typeof content === 'string') {
-        return content;
-    }
-    if (!Array.isArray(content)) {
-        return '';
-    }
-    return content
-        .filter((part) => typeof part === 'object' && part !== null && part.type === 'text')
-        .map((part) => typeof part.text === 'string' ? part.text : '')
-        .join('');
-}
-class LinxRewindMessageList {
-    messages;
-    selectedIndex;
-    onSelect;
-    onCancel;
-    maxVisible = 10;
-    constructor(messages, initialSelectedId) {
-        this.messages = messages;
-        const initialIndex = initialSelectedId
-            ? messages.findIndex((message) => message.id === initialSelectedId)
-            : -1;
-        this.selectedIndex = initialIndex >= 0 ? initialIndex : Math.max(0, messages.length - 1);
-    }
-    invalidate() {
-        // No cached render state.
-    }
-    render(width) {
-        const lines = [];
-        if (this.messages.length === 0) {
-            return ['  No user messages found'];
-        }
-        const startIndex = Math.max(0, Math.min(this.selectedIndex - Math.floor(this.maxVisible / 2), this.messages.length - this.maxVisible));
-        const endIndex = Math.min(startIndex + this.maxVisible, this.messages.length);
-        for (let index = startIndex; index < endIndex; index += 1) {
-            const message = this.messages[index];
-            const isSelected = index === this.selectedIndex;
-            const cursor = isSelected ? '> ' : '  ';
-            const normalized = message.text.replace(/\n/g, ' ').trim();
-            lines.push(`${cursor}${truncateToWidth(normalized, Math.max(1, width - 2))}`);
-            lines.push(`  Rewind before message ${index + 1} of ${this.messages.length}`);
-            lines.push('');
-        }
-        if (startIndex > 0 || endIndex < this.messages.length) {
-            lines.push(`  (${this.selectedIndex + 1}/${this.messages.length})`);
-        }
-        return lines;
-    }
-    handleInput(keyData) {
-        const keybindings = getKeybindings();
-        if (keybindings.matches(keyData, 'tui.select.up')) {
-            this.selectedIndex = this.selectedIndex === 0 ? this.messages.length - 1 : this.selectedIndex - 1;
-            return;
-        }
-        if (keybindings.matches(keyData, 'tui.select.down')) {
-            this.selectedIndex = this.selectedIndex === this.messages.length - 1 ? 0 : this.selectedIndex + 1;
-            return;
-        }
-        if (keybindings.matches(keyData, 'tui.select.confirm')) {
-            const selected = this.messages[this.selectedIndex];
-            if (selected) {
-                this.onSelect?.(selected.id);
-            }
-            return;
-        }
-        if (keybindings.matches(keyData, 'tui.select.cancel')) {
-            this.onCancel?.();
-        }
-    }
-}
-class LinxRewindMessageSelectorComponent extends Container {
-    messageList;
-    constructor(messages, onSelect, onCancel, initialSelectedId) {
-        super();
-        this.addChild(new Spacer(1));
-        this.addChild(new Text('Rewind to Message', 1, 0));
-        this.addChild(new Text('Select the first user message to remove from the active branch.', 1, 0));
-        this.addChild(new Text('The selected message and everything after it stay in history but leave the active context.', 1, 0));
-        this.addChild(new Spacer(1));
-        this.messageList = new LinxRewindMessageList(messages, initialSelectedId);
-        this.messageList.onSelect = onSelect;
-        this.messageList.onCancel = onCancel;
-        this.addChild(this.messageList);
-        this.addChild(new Spacer(1));
-        if (messages.length === 0) {
-            setTimeout(() => onCancel(), 100);
-        }
-    }
-    getMessageList() {
-        return this.messageList;
-    }
-}
-function installProjectedCommandRouter(interactive) {
-    interactive.__linxHandleProjectedCommand = async (text) => {
-        const command = text.trim();
-        if (!command.startsWith('/')) {
-            return false;
-        }
-        if (typeof interactive.__linxHandleProjectedGlobalCommand === 'function') {
-            const handled = await interactive.__linxHandleProjectedGlobalCommand(command);
-            if (handled === 'peer-command') {
-                return 'peer-command';
-            }
-            if (handled === true) {
-                return true;
-            }
-        }
-        if (typeof interactive.__linxHandleProjectedBackendCommand === 'function') {
-            const handled = await interactive.__linxHandleProjectedBackendCommand(command);
-            if (handled === true) {
-                return true;
-            }
-        }
-        return false;
-    };
-}
-async function handleInteractivePeerCommand(interactive, runtime, route) {
-    const goalMode = route.secretaryBehavior?.goalMode;
-    if (goalMode !== undefined) {
-        applyInteractiveGoalMode(interactive, runtime, goalMode);
-        interactive.showStatus?.(`Peer command routed; Secretary goal supervision mirror is ${goalMode ? 'active' : 'paused'}.`);
-    }
-    else {
-        interactive.showStatus?.('Peer command routed to current chat peer.');
-    }
-    await submitProjectedBackendInput(interactive, route.text);
-    interactive.ui?.requestRender?.();
-}
-function applyInteractiveGoalMode(interactive, runtime, enabled) {
-    interactive.__linxGoalModeEnabled = enabled;
-    if (enabled) {
-        interactive.__linxGoalModeSupervisorLastAt = Date.now();
-    }
-    else {
-        delete interactive.__linxGoalModeSupervisorLastAt;
-    }
-    if (runtime && typeof runtime === 'object') {
-        runtime.goalMode = enabled;
-        if (enabled) {
-            runtime.goalModeSupervisorLastAt = interactive.__linxGoalModeSupervisorLastAt;
-        }
-        else {
-            delete runtime.goalModeSupervisorLastAt;
-        }
-    }
-}
-async function submitProjectedBackendInput(interactive, text) {
-    const session = interactive?.session;
-    const sendUserMessage = typeof session?.__linxSendUserMessageWithoutCommandRouting === 'function'
-        ? session.__linxSendUserMessageWithoutCommandRouting
-        : session?.sendUserMessage;
-    if (typeof sendUserMessage === 'function') {
-        await sendUserMessage(text, session.isStreaming ? { deliverAs: 'followUp' } : undefined);
-        return;
-    }
-    const prompt = typeof session?.__linxPromptWithoutCommandRouting === 'function'
-        ? session.__linxPromptWithoutCommandRouting
-        : session?.prompt;
-    if (typeof prompt === 'function') {
-        await prompt(text, session.isStreaming ? { streamingBehavior: 'followUp' } : undefined);
-        return;
-    }
-    throw new Error('Active LinX session cannot accept peer goal input');
-}
-async function handleInteractiveAutoCommand(interactive, runtime, enabled, options = {}) {
-    if (enabled === undefined) {
-        const active = interactive.__autoEnabled === true;
-        interactive.showStatus?.(formatAutoModeChangeStatus(active));
-        interactive.ui?.requestRender?.();
-        return;
-    }
-    const control = getSessionControlManager(interactive, runtime);
-    control.setAutoEnabled(enabled);
-    interactive.__autoEnabled = enabled;
-    if (runtime && typeof runtime === 'object') {
-        runtime.autoEnabled = enabled;
-    }
-    const controller = getSecretaryAutoInputController(interactive, runtime, control);
-    if (enabled) {
-        controller.start({ scheduleImmediately: options.scheduleImmediately !== false });
-    }
-    else {
-        controller.stop();
-    }
-    interactive.showStatus?.(formatAutoModeChangeStatus(enabled));
-    interactive.ui?.requestRender?.();
-    await interactive.__linxOnAutoControlChange?.(enabled);
-}
-function formatAutoModeChangeStatus(enabled) {
-    return enabled
-        ? [
-            'Auto is on.',
-            'Auto on: Secretary drives the current session input loop.',
-            'What changed: backend prompts and blocked approval/input requests go to Secretary first; Secretary answers in-policy and asks you only when blocked.',
-            'User-visible state: the input bar shows auto; Ctrl+C or /auto off hands control back to you.',
-            'Backend approval policy is unchanged.',
-        ].join('\n')
-        : [
-            'Auto is off.',
-            'Auto off: you drive the current session directly.',
-            'What changed: backend prompts, approvals, and free-form input return to the local TUI unless another explicit control path handles them.',
-            'Auto only controls input ownership; it does not change whether the current chat peer is Secretary or worker/backend.',
-            'Use /auto on to hand control back to Secretary.',
-        ].join('\n');
-}
-async function changeInteractiveCwd(interactive, runtime, target) {
-    if (!target) {
-        interactive.showStatus?.(`Current workspace: ${resolveInteractiveCwd(interactive, runtime)}`);
-        interactive.ui?.requestRender?.();
-        return;
-    }
-    const nextCwd = resolve(resolveInteractiveCwd(interactive, runtime), target);
-    if (!existsSync(nextCwd)) {
-        interactive.showError?.(`Workspace not found: ${nextCwd}`);
-        interactive.ui?.requestRender?.();
-        return;
-    }
-    if (!statSync(nextCwd).isDirectory()) {
-        interactive.showError?.(`Workspace is not a directory: ${nextCwd}`);
-        interactive.ui?.requestRender?.();
-        return;
-    }
-    process.chdir(nextCwd);
-    setRuntimeCwd(interactive, runtime, nextCwd);
-    await runtime?.backendCommandRouter?.setCwd?.(nextCwd);
-    interactive.showStatus?.(`Workspace changed to ${nextCwd}. Session history stays in the current thread.`);
-    interactive.ui?.requestRender?.();
-}
-function resolveInteractiveCwd(interactive, runtime) {
-    const candidates = [
-        interactive?.session?.cwd,
-        runtime?.cwd,
-        interactive?.sessionManager?.getCwd?.(),
-        interactive?.session?.sessionManager?.getCwd?.(),
-        process.cwd(),
-    ];
-    for (const candidate of candidates) {
-        if (typeof candidate === 'string' && candidate.trim()) {
-            return candidate.trim();
-        }
-    }
-    return process.cwd();
-}
-function setRuntimeCwd(interactive, runtime, cwd) {
-    if (interactive?.session && typeof interactive.session === 'object') {
-        interactive.session.cwd = cwd;
-    }
-    if (runtime && typeof runtime === 'object') {
-        runtime.cwd = cwd;
-    }
-}
-export function installSymphonyCommand(interactive) {
-    if (interactive.__linxSymphonyCommandInstalled) {
-        return;
-    }
-    const originalSetup = interactive.setupEditorSubmitHandler?.bind(interactive);
-    if (typeof originalSetup !== 'function') {
-        return;
-    }
-    interactive.setupEditorSubmitHandler = function patchedSymphonySetupEditorSubmitHandler(...args) {
-        const result = originalSetup(...args);
-        const originalSubmit = this.defaultEditor?.onSubmit?.bind(this.defaultEditor);
-        if (typeof originalSubmit !== 'function') {
-            return result;
-        }
-        this.defaultEditor.onSubmit = async (text) => {
-            const input = text.trim();
-            const command = parseSymphonyCommand(input);
-            if (command) {
-                this.editor?.setText?.('');
-                await handleSymphonyCommand(this, command);
-                return;
-            }
-            if (this.__linxSymphonyModeEnabled && shouldProjectSymphonyInput(input)) {
-                getSessionControlManager(this, this.runtime).recordUserMessage({ text: input });
-                await originalSubmit(renderSymphonySecretaryProjection(input));
-                return;
-            }
-            await originalSubmit(text);
-        };
-        return result;
-    };
-    interactive.__linxSymphonyCommandInstalled = true;
-}
-export function installSymphonyAutocomplete(interactive) {
-    installLinxCommandAutocomplete(interactive);
-}
-export function installLinxCommandAutocomplete(interactive) {
-    if (interactive.__linxCommandAutocompleteInstalled || interactive.__linxSymphonyAutocompleteInstalled) {
-        return;
-    }
-    const setupName = typeof interactive.setupAutocompleteProvider === 'function'
-        ? 'setupAutocompleteProvider'
-        : 'setupAutocomplete';
-    const originalSetup = interactive[setupName]?.bind(interactive);
-    if (typeof originalSetup !== 'function') {
-        return;
-    }
-    interactive[setupName] = function patchedLinxSetupAutocompleteProvider(...args) {
-        const result = originalSetup(...args);
-        installLinxAutocompleteCommands(this.autocompleteProvider);
-        return result;
-    };
-    interactive.__linxCommandAutocompleteInstalled = true;
-    interactive.__linxSymphonyAutocompleteInstalled = true;
-}
-function installLinxAutocompleteCommands(provider) {
-    if (!Array.isArray(provider?.commands)) {
-        return;
-    }
-    for (const command of LINX_INTERACTIVE_SLASH_COMMANDS) {
-        if (!provider.commands.some((existing) => getAutocompleteCommandName(existing) === command.name)) {
-            provider.commands.push(command);
-        }
-    }
-}
-const LINX_INTERACTIVE_SLASH_COMMANDS = [
-    {
-        name: 'auto',
-        argumentHint: 'on|off|status',
-        description: 'toggle AI Secretary driving for this session',
-        getArgumentCompletions: (prefix) => completeStaticArguments(prefix, [
-            { value: 'on', description: 'Secretary drives the session and asks when blocked' },
-            { value: 'off', description: 'User drives the session directly' },
-            { value: 'status', description: 'Show whether Secretary driving is enabled' },
-        ]),
-    },
-    {
-        name: 'cd',
-        argumentHint: '<dir>',
-        description: 'change workspace for this LinX session',
-    },
-    {
-        name: 'goal',
-        argumentHint: '<peer-command>',
-        description: 'send a goal command to the current chat peer',
-    },
-    {
-        name: 'rewind',
-        description: 'select a user message and rewind the active branch before it',
-    },
-    {
-        name: 'statusline',
-        argumentHint: 'set|colors|tokens|reset',
-        description: 'configure which items appear in the status line',
-        getArgumentCompletions: (prefix) => completeStaticArguments(prefix, [
-            { value: 'set', description: 'Set status line tokens' },
-            { value: 'colors', description: 'Enable or disable status line colors' },
-            { value: 'tokens', description: 'List available status line tokens' },
-            { value: 'reset', description: 'Restore default status line tokens' },
-        ]),
-    },
-    {
-        name: 'update',
-        description: 'check for a LinX CLI update and install from the TUI',
-    },
-    {
-        name: 'ai',
-        argumentHint: 'connect <provider>',
-        description: 'connect AI provider credentials to LinX Pod settings',
-        getArgumentCompletions: completeAiArguments,
-    },
-    {
-        name: 'symphony',
-        argumentHint: 'on|off|status',
-        description: 'turn Secretary task handoff on/off, or show status',
-        getArgumentCompletions: (prefix) => completeStaticArguments(prefix, [
-            { value: 'on', description: 'Secretary can plan and hand off larger tasks' },
-            { value: 'off', description: 'Return to direct chat' },
-            { value: 'status', description: 'Show whether Symphony task handoff is enabled' },
-        ]),
-    },
-];
-function completeStaticArguments(prefix, options) {
-    const normalized = prefix.trimStart().toLowerCase();
-    const matches = options.filter((option) => option.value.startsWith(normalized));
-    if (matches.length === 0) {
-        return null;
-    }
-    return matches.map((option) => ({
-        value: option.value,
-        label: option.value,
-        description: option.description,
-    }));
-}
-function completeAiArguments(prefix) {
-    const input = prefix.trimStart().toLowerCase();
-    if (!input || 'connect'.startsWith(input)) {
-        return [{
-                value: 'connect ',
-                label: 'connect',
-                description: 'Connect an AI provider key to LinX Pod AI settings',
-            }];
-    }
-    const connectPrefix = 'connect ';
-    if (!input.startsWith(connectPrefix)) {
-        return null;
-    }
-    const providerPrefix = input.slice(connectPrefix.length);
-    const providers = getAiConnectCompletionProviders();
-    const matches = providers.filter((provider) => provider.startsWith(providerPrefix));
-    if (matches.length === 0) {
-        return null;
-    }
-    return matches.map((provider) => ({
-        value: `connect ${provider}`,
-        label: provider,
-        description: `Connect ${provider} credentials`,
-    }));
-}
-function getAiConnectCompletionProviders() {
-    const providerIds = [];
-    const aliases = [];
-    for (const entry of getAIConfigProviderCatalog()) {
-        providerIds.push(entry.id);
-        aliases.push(...(entry.aliases ?? []));
-    }
-    return Array.from(new Set([...providerIds, ...aliases]));
-}
-function getAutocompleteCommandName(command) {
-    if (!command || typeof command !== 'object') {
-        return undefined;
-    }
-    const value = 'name' in command
-        ? command.name
-        : 'value' in command
-            ? command.value
-            : undefined;
-    return typeof value === 'string' ? value : undefined;
-}
-function parseSymphonyCommand(input) {
-    if (input !== '/symphony' && !input.startsWith('/symphony ')) {
-        return null;
-    }
-    const args = input === '/symphony' ? '' : input.slice('/symphony'.length).trim();
-    if (!args || args.toLowerCase() === 'on' || args.toLowerCase() === 'enable') {
-        return { action: 'enable' };
-    }
-    const normalized = args.toLowerCase();
-    if (normalized === 'off' || normalized === 'disable' || normalized === 'exit') {
-        return { action: 'disable' };
-    }
-    if (normalized === 'status') {
-        return { action: 'status' };
-    }
-    return { action: 'usage', input: args };
-}
-async function handleSymphonyCommand(interactive, command) {
-    if (command.action === 'enable') {
-        interactive.__linxSymphonyModeEnabled = true;
-        interactive.__linxSymphonyModeGeneration = (Number(interactive.__linxSymphonyModeGeneration) || 0) + 1;
-        if (interactive.runtime && typeof interactive.runtime === 'object') {
-            interactive.runtime.symphonyEnabled = true;
-        }
-        interactive.showStatus?.(formatSymphonyModeChangeStatus(true));
-        interactive.ui?.requestRender?.();
-        await interactive.__linxOnSymphonyControlChange?.(true);
-        return;
-    }
-    if (command.action === 'disable') {
-        interactive.__linxSymphonyModeEnabled = false;
-        interactive.__linxSymphonyModeGeneration = (Number(interactive.__linxSymphonyModeGeneration) || 0) + 1;
-        abortInteractiveSymphonyDispatches(interactive);
-        if (interactive.runtime && typeof interactive.runtime === 'object') {
-            interactive.runtime.symphonyEnabled = false;
-        }
-        interactive.showStatus?.(formatSymphonyModeChangeStatus(false));
-        interactive.ui?.requestRender?.();
-        await interactive.__linxOnSymphonyControlChange?.(false);
-        return;
-    }
-    if (command.action === 'status') {
-        interactive.showStatus?.(await formatSymphonyStatus(interactive));
-        interactive.ui?.requestRender?.();
-        return;
-    }
-    interactive.showStatus?.(formatSymphonyUsage(command.input));
-    interactive.ui?.requestRender?.();
-}
-function formatSymphonyModeChangeStatus(enabled) {
-    return enabled
-        ? 'Symphony is on. I will keep ordinary chat ordinary and only plan or hand off real work.'
-        : 'Symphony is off. Back to direct chat. Active handoffs from this window were stopped.';
-}
-function formatSymphonyUsage(input) {
-    return [
-        `Unsupported /symphony argument: ${input}`,
-        'Use /symphony on to chat with Secretary, /symphony off to chat with the worker/backend peer, or /symphony status to inspect workers.',
-        'After enabling Symphony, send the objective as a normal chat message to Secretary; Secretary will decide whether it is an Issue, update existing work, split tasks, and dispatch workers.',
-    ].join('\n');
-}
-function shouldProjectSymphonyInput(input) {
-    return Boolean(input)
-        && !input.startsWith('/')
-        && !input.startsWith('!');
-}
-function renderSymphonySecretaryProjection(input) {
-    return [
-        '# AI Secretary Symphony request',
-        '',
-        'Symphony is on: the user is chatting with Secretary, not directly with the worker/backend peer.',
-        'Treat the user message below as a Secretary-facing product message.',
-        'Decide whether it is ordinary chat, an Idea, a change to existing work, or delegable work.',
-        'Default response style: reply like normal chat.',
-        'Do not print internal Symphony binding, Issue/Task routing, worker selection, or report-style sections unless a visible state change or blocker must be surfaced.',
-        'If the message is ordinary chat or early exploration, answer directly and do not explain that it was not delegated.',
-        'If real delegation is needed, summarize the visible handoff result briefly after updating control state.',
-        'When you need to inspect or mutate Symphony Pod resources from the AI side, use the xpod CLI as the direct Pod tool surface.',
-        'Prefer model-backed xpod obj commands for Idea, Issue, Task, Delivery, Run, RunStep, Report, Evidence, ApprovalRequest, InputRequest, and InboxNotification resources.',
-        'xpod uses the same Solid authority as LinX inside the Agent Runtime; do not ask the model to handle tokens or client secrets.',
-        'Before mutating Pod resources from tools, verify xpod auth status/whoami reports the same acting WebID/Pod root as the LinX session; stop on mismatch.',
-        'Do not hand-patch TTL or guess Pod paths for modeled product resources; use xpod/model descriptors or inspect existing links first.',
-        '',
-        'User message:',
-        input,
-    ].join('\n');
-}
-async function dispatchSymphonyWorkerFromInteractive(interactive, objective, source) {
-    const backend = resolveSymphonyWorkerBackend(interactive, objective);
-    const agentRuntime = resolveSymphonyControlAgentRuntime(interactive);
-    const workerModel = resolveSymphonyWorkerModel(interactive, objective, backend);
-    const workerCredentialSource = resolveSymphonyWorkerCredentialSource(interactive, backend);
-    const workerGoalMode = interactive.__autoEnabled === true;
-    const workerSupervisorIntervalMs = workerGoalMode ? resolveSymphonyWorkerSupervisorIntervalMs(interactive) : undefined;
-    const cwd = resolveInteractiveCwd(interactive, interactive.runtime);
-    const dispatchGeneration = Number(interactive.__linxSymphonyModeGeneration) || 0;
-    const dispatches = Array.isArray(interactive.__linxSymphonyDispatches)
-        ? interactive.__linxSymphonyDispatches
-        : [];
-    interactive.__linxSymphonyDispatches = dispatches;
-    const controller = new AbortController();
-    const controllers = getInteractiveSymphonyDispatchControllers(interactive);
-    controllers.add(controller);
-    interactive.showStatus?.(`Symphony handoff started: ${backend}${workerModel ? ` · ${workerModel}` : ''}`
-        + `${workerGoalMode ? ` · supervised every ${formatSymphonySupervisorInterval(workerSupervisorIntervalMs)}` : ''}.`
-        + ' Use /symphony status for details.');
-    interactive.ui?.requestRender?.();
-    const run = typeof interactive.__linxRunSymphony === 'function'
-        ? interactive.__linxRunSymphony
-        : runSymphony;
-    const dispatchArgs = {
-        objective: [objective],
-        backend,
-        auto: interactive.__autoEnabled === true,
-        cwd,
-        plain: true,
-        print: false,
-        quietProjectionErrors: true,
-        quietWorkers: true,
-        credentialSource: workerCredentialSource,
-        agentRuntime,
-        workerModel,
-        workerGoalMode,
-        workerSupervisorIntervalMs,
-        signal: controller.signal,
-        ...(source?.chat ? { chat: source.chat } : {}),
-        ...(source?.thread ? { thread: source.thread } : {}),
-        target: {
-            source: 'active-session',
-            backend,
-            agent: `${backend}-worker`,
-            label: `${backend} worker`,
-            ...(source?.chat ? { chat: source.chat } : {}),
-            ...(source?.thread ? { thread: source.thread } : {}),
-        },
-    };
-    const runtime = createInteractiveSymphonyRuntime(interactive);
-    const dispatch = run(dispatchArgs, runtime)
-        .then((plan) => {
-        if (!isCurrentSymphonyDispatch(interactive, dispatchGeneration)) {
-            return;
-        }
-        interactive.showStatus?.(formatSymphonyDispatchResult(plan));
-    })
-        .catch((error) => {
-        if (!isCurrentSymphonyDispatch(interactive, dispatchGeneration)) {
-            return;
-        }
-        if (isSymphonyAbortError(error)) {
-            interactive.showStatus?.('Symphony dispatch cancelled.');
-            return;
-        }
-        const message = error instanceof Error ? error.message : String(error);
-        interactive.showError?.(`Symphony dispatch failed: ${message}`);
-    })
-        .finally(() => {
-        controllers.delete(controller);
-        if (!isCurrentSymphonyDispatch(interactive, dispatchGeneration)) {
-            return;
-        }
-        interactive.ui?.requestRender?.();
-    });
-    dispatches.push(dispatch);
-    await Promise.resolve();
-}
-function getInteractiveSymphonyDispatchControllers(interactive) {
-    if (!(interactive.__linxSymphonyDispatchControllers instanceof Set)) {
-        interactive.__linxSymphonyDispatchControllers = new Set();
-    }
-    return interactive.__linxSymphonyDispatchControllers;
-}
-function abortInteractiveSymphonyDispatches(interactive) {
-    const controllers = getInteractiveSymphonyDispatchControllers(interactive);
-    for (const controller of controllers) {
-        if (!controller.signal.aborted) {
-            controller.abort(new Error('Symphony dispatch aborted by /symphony off'));
-        }
-    }
-    controllers.clear();
-}
-function isSymphonyAbortError(error) {
-    return error instanceof Error
-        && (error.name === 'AbortError' || error.message.toLowerCase().includes('aborted'));
-}
-function isCurrentSymphonyDispatch(interactive, generation) {
-    return interactive.__linxSymphonyModeEnabled === true
-        && (Number(interactive.__linxSymphonyModeGeneration) || 0) === generation;
-}
-function createInteractiveSymphonyRuntime(interactive) {
-    const projectionRuntime = interactive?.__linxSymphonyPodProjectionRuntime;
-    if (!projectionRuntime) {
-        return undefined;
-    }
-    return {
-        runAutoMode,
-        listAutoModeSessions: listArchivedAutoModeSessions,
-        persistSymphonyControlStateToPod(plan, options) {
-            return persistSymphonyControlStateToPod(plan, {
-                ...options,
-                runtime: projectionRuntime,
-            });
-        },
-        listOpenSymphonyIssuesFromPod() {
-            return listOpenSymphonyIssuesFromPod({ runtime: projectionRuntime });
-        },
-        mirrorSymphonyProjectionJsonLdFromPod(result) {
-            return mirrorSymphonyProjectionJsonLdFromPod(result, { runtime: projectionRuntime });
-        },
-    };
-}
-function resolveSymphonyWorkerBackend(interactive, objective) {
-    const candidates = [
-        interactive?.__linxSymphonyWorkerBackend,
-        interactive?.runtime?.symphonyWorkerBackend,
-        extractSymphonyWorkerBackendFromText(objective),
-        interactive?.runtime?.runtimeBackend,
-        interactive?.runtime?.workerBackend,
-        interactive?.runtime?.backendCommandRouter?.backend,
-        interactive?.runtime?.backendSessionRef?.backend,
-    ];
-    for (const candidate of candidates) {
-        if (candidate === 'cc') {
-            return 'claude';
-        }
-        if (isSymphonyWorkerBackend(candidate)) {
-            return candidate;
-        }
-    }
-    return 'codex';
-}
-function isSymphonyWorkerBackend(value) {
-    return value === 'linx' || value === 'codex' || value === 'claude' || value === 'codebuddy';
-}
-function resolveSymphonyWorkerCredentialSource(interactive, backend) {
-    const configured = normalizeSymphonyCredentialSource(interactive?.__linxSymphonyWorkerCredentialSource, interactive?.runtime?.symphonyWorkerCredentialSource, interactive?.runtime?.workerCredentialSource);
-    if (configured) {
-        return configured;
-    }
-    return backend === 'linx' ? 'cloud' : 'local';
-}
-function normalizeSymphonyCredentialSource(...values) {
-    for (const value of values) {
-        if (value === 'local' || value === 'cloud') {
-            return value;
-        }
-        if (typeof value === 'string') {
-            const normalized = value.trim().toLowerCase();
-            if (normalized === 'local' || normalized === 'cloud') {
-                return normalized;
-            }
-        }
-    }
-    return undefined;
-}
-function extractSymphonyWorkerBackendFromText(input) {
-    const normalized = input?.trim().toLowerCase();
-    if (!normalized) {
-        return undefined;
-    }
-    if (/\b(?:linx|pi)\s*(?:runtime|backend|worker|agent)\b/u.test(normalized)
-        || /\b(?:runtime|backend|worker|agent)\s*(?:=|:|：|是|用|使用|设为|指定为)\s*(?:linx|pi)\b/u.test(normalized)
-        || /(用|使用|让|派)\s*(linx|pi)\s*(runtime|后端|worker|agent|模型)?/u.test(normalized)) {
-        return 'linx';
-    }
-    if (/\b(?:claude|cc)\s*(?:code\s*)?(?:runtime|backend|worker|agent)\b/u.test(normalized)
-        || /\b(?:runtime|backend|worker|agent)\s*(?:=|:|：|是|用|使用|设为|指定为)\s*(?:claude|cc)\b/u.test(normalized)
-        || /(用|使用|让|派)\s*(?:claude|cc)\s*(?:code|runtime|后端|worker|agent|模型)?/u.test(normalized)) {
-        return 'claude';
-    }
-    if (/\bcodex\s*(?:runtime|backend|worker|agent)?\b/u.test(normalized)) {
-        return 'codex';
-    }
-    if (/\b(?:claude|cc)\s*(?:code|runtime|backend|worker|agent)?\b/u.test(normalized)) {
-        return 'claude';
-    }
-    if (/\bcodebuddy\s*(?:runtime|backend|worker|agent)?\b/u.test(normalized)) {
-        return 'codebuddy';
-    }
-    return undefined;
-}
-function resolveSymphonyControlAgentRuntime(interactive) {
-    const configured = normalizeSymphonyAgentRuntimeConfig(interactive?.__linxAgentRuntime, interactive?.__linxAgentRuntimeConfig, interactive?.runtime?.agentRuntime, interactive?.runtime?.agentRuntimeConfig);
-    const model = configured?.model ?? normalizeSymphonyConfigString(interactive?.session?.model?.id, interactive?.runtime?.model);
-    if (!configured && !model) {
-        return undefined;
-    }
-    return {
-        backend: configured?.backend ?? 'linx',
-        credentialSource: configured?.credentialSource ?? 'cloud',
-        ...configured,
-        ...(model ? { model } : {}),
-    };
-}
-function normalizeSymphonyAgentRuntimeConfig(...values) {
-    for (const value of values) {
-        if (!isRecord(value)) {
-            continue;
-        }
-        const metadata = isRecord(value.metadata) ? { ...value.metadata } : undefined;
-        const resolved = {
-            ...(normalizeSymphonyConfigString(value.backend) ? { backend: normalizeSymphonyConfigString(value.backend) } : {}),
-            ...(normalizeSymphonyConfigString(value.model) ? { model: normalizeSymphonyConfigString(value.model) } : {}),
-            ...(normalizeSymphonyConfigString(value.credentialSource) ? { credentialSource: normalizeSymphonyConfigString(value.credentialSource) } : {}),
-            ...(normalizeSymphonyConfigString(value.runtime) ? { runtime: normalizeSymphonyConfigString(value.runtime) } : {}),
-            ...(normalizeSymphonyConfigString(value.transport) ? { transport: normalizeSymphonyConfigString(value.transport) } : {}),
-            ...(normalizeSymphonyConfigString(value.endpoint) ? { endpoint: normalizeSymphonyConfigString(value.endpoint) } : {}),
-            ...(metadata ? { metadata } : {}),
-        };
-        if (Object.keys(resolved).length > 0) {
-            return resolved;
-        }
-    }
-    return undefined;
-}
-function formatSymphonyControlRuntime(runtime) {
-    return [
-        runtime.backend ?? 'linx',
-        runtime.model,
-        runtime.credentialSource ? `credentials=${runtime.credentialSource}` : undefined,
-    ].filter(Boolean).join(' · ');
-}
-function resolveSymphonyWorkerModel(interactive, objective, backend) {
-    const configured = normalizeSymphonyConfigString(interactive?.__linxSymphonyWorkerModel, interactive?.runtime?.symphonyWorkerModel, interactive?.runtime?.workerModel, extractSymphonyWorkerModelFromText(objective));
-    if (backend === 'claude' && configured && isProviderRoutedModel(configured)) {
-        return 'opus';
-    }
-    return configured;
-}
-function resolveSymphonyWorkerSupervisorIntervalMs(interactive) {
-    const value = Number(interactive?.__linxSymphonyWorkerSupervisorIntervalMs
-        ?? interactive?.runtime?.symphonyWorkerSupervisorIntervalMs
-        ?? DEFAULT_SYMPHONY_WORKER_SUPERVISOR_INTERVAL_MS);
-    if (!Number.isFinite(value) || value <= 0) {
-        return DEFAULT_SYMPHONY_WORKER_SUPERVISOR_INTERVAL_MS;
-    }
-    return Math.trunc(value);
-}
-function formatSymphonySupervisorInterval(value) {
-    const intervalMs = Number(value);
-    if (!Number.isFinite(intervalMs) || intervalMs <= 0) {
-        return `${DEFAULT_SYMPHONY_WORKER_SUPERVISOR_INTERVAL_MS / 60_000}m`;
-    }
-    if (intervalMs % 60_000 === 0) {
-        return `${intervalMs / 60_000}m`;
-    }
-    if (intervalMs % 1000 === 0) {
-        return `${intervalMs / 1000}s`;
-    }
-    return `${intervalMs}ms`;
-}
-function normalizeSymphonyConfigString(...values) {
-    for (const value of values) {
-        const normalized = typeof value === 'string' ? value.trim() : '';
-        if (normalized) {
-            return normalized;
-        }
-    }
-    return undefined;
-}
-function extractSymphonyWorkerModelFromText(input) {
-    const patterns = [
-        /(?:worker|agent|模型|model)\s*(?:=|:|：|是|用|使用|设为|指定为)\s*([A-Za-z0-9][A-Za-z0-9._/-]{1,80})/iu,
-        /(?:用|使用|让|派)\s*([A-Za-z0-9][A-Za-z0-9._/-]{1,80})\s*(?:作为)?\s*(?:worker|agent|模型|model)/iu,
-        /\b((?:deepseek|gpt|claude|qwen|gemini)[A-Za-z0-9._/-]{1,80})\s*(?:worker|agent)?/iu,
-    ];
-    for (const pattern of patterns) {
-        const match = input.match(pattern);
-        const normalized = normalizeSymphonyModelToken(match?.[1]);
-        if (normalized) {
-            return normalized;
-        }
-    }
-    return undefined;
-}
-function normalizeSymphonyModelToken(value) {
-    const normalized = typeof value === 'string'
-        ? value.trim().replace(/[，。,.、;；:：!?！？)）\]}】]+$/u, '')
-        : '';
-    return normalized || undefined;
-}
-function isProviderRoutedModel(model) {
-    return /(?:deepseek|qwen|gemini|kimi|moonshot|mistral|grok|glm|minimax)/iu.test(model);
-}
-function formatSymphonyDispatchResult(plan) {
-    const worker = plan.workers[0];
-    const session = worker?.session ?? plan.session;
-    const delivery = worker?.delivery ?? plan.delivery;
-    const lines = [
-        plan.issue.status === 'resolved' && delivery.status === 'completed'
-            ? `Symphony handoff completed: ${plan.issue.title}.`
-            : `Symphony handoff recorded: ${plan.issue.title}.`,
-        'Use /symphony status for details.',
-    ];
-    if (session.error) {
-        lines.push(`Error: ${session.error}`);
-    }
-    return lines.join('\n');
-}
-async function captureSymphonyIdeaIfNeeded(input, source) {
-    if (!shouldCaptureSymphonyIdeaInput(input)) {
-        return undefined;
-    }
-    try {
-        const affectedArea = inferSymphonyIdeaAffectedArea(input);
-        const captureInput = {
-            input,
-            commitment: 'thought',
-            status: 'captured',
-            currentUnderstanding: input.trim(),
-            nextStep: 'Bind this Idea against existing control records before promoting it to work.',
-            ...(source?.chat ? { chat: source.chat } : {}),
-            ...(source?.thread ? { thread: source.thread } : {}),
-            ...(affectedArea ? { affectedArea } : {}),
-        };
-        const idea = createSymphonyIdeaRecord(captureInput);
-        const persisted = await persistSymphonyIdeaToPod(idea);
-        if (!persisted) {
-            throw new Error('No active Pod session; Symphony Idea records must be written to Pod in LinX runtime.');
-        }
-        return {
-            uri: idea.uri,
-            summary: idea.summary,
-            status: idea.status,
-            commitment: idea.commitment,
-        };
-    }
-    catch (error) {
-        process.emitWarning(error instanceof Error
-            ? new Error(`LinX Symphony Idea Pod write failed: ${error.message}`)
-            : new Error(`LinX Symphony Idea Pod write failed: ${String(error)}`));
-        return undefined;
-    }
-}
-function shouldCaptureSymphonyIdeaInput(input) {
-    const normalized = input.trim();
-    if (normalized.length < 12) {
-        return false;
-    }
-    return /\b(idea|maybe|perhaps|could we|should we|what if|proposal|direction)\b/iu.test(normalized)
-        || /(我觉得|感觉|也许|可能|考虑|想法|方向|要不要|能不能|是不是|是否|应该)/u.test(normalized);
-}
-function inferSymphonyIdeaAffectedArea(input) {
-    const normalized = input.toLowerCase();
-    if (/symphony|secretary|auto|approval|grant|pod|xpod|skill|worker|agent/u.test(normalized)) {
-        return normalized.match(/symphony|secretary|auto|approval|grant|pod|xpod|skill|worker|agent/u)?.[0];
-    }
-    if (/(建模|模型|数据|同步|权限|审批|托管|多端|工作流|指标|质检)/u.test(input)) {
-        return input.match(/建模|模型|数据|同步|权限|审批|托管|多端|工作流|指标|质检/u)?.[0];
-    }
-    return undefined;
-}
-async function formatSymphonyStatus(interactive) {
-    const enabled = interactive.__linxSymphonyModeEnabled === true;
-    const [source, workersRead, issuesRead, reportsRead] = await Promise.all([
-        resolveSymphonySourceContext(interactive),
-        listRunningSymphonyWorkers(interactive),
-        listOpenSymphonyIssues(interactive),
-        listRecentSymphonyReports(interactive),
-    ]);
-    const workers = workersRead.items;
-    const issues = issuesRead.items;
-    const reports = reportsRead.items;
-    const controlStateErrors = Array.from(new Set([
-        workersRead.error,
-        issuesRead.error,
-        reportsRead.error,
-    ].filter((item) => Boolean(item))));
-    const controlStateSources = new Set([workersRead.source, issuesRead.source, reportsRead.source]);
-    const lines = [
-        `Symphony is ${enabled ? 'on' : 'off'}.`,
-        `Current chat peer: ${enabled ? 'Secretary' : 'worker/backend peer'}.`,
-        `Open issues: ${issues.length}`,
-        `Running workers: ${workers.length}`,
-        `Recent reports: ${reports.length}`,
-        controlStateErrors.length > 0
-            ? `Pod control state: unavailable (${formatSymphonyStatusError(controlStateErrors[0])})`
-            : controlStateSources.has('pod')
-                ? 'Pod control state: active.'
-                : 'Pod control state: portable local archive mode.',
-        'Skills: issue triage, existing issue lookup, create/update/ask decision, task split, worker dispatch, status/report tracking.',
-        'Delegation target: AI Secretary must choose a Chat resource before dispatch.',
-        'Allowed targets: personal AI contact chat or group chat.',
-        'Thread role: concrete work timeline under the selected Chat.',
-        'Session role: backend runtime lifecycle only.',
-    ];
-    for (const issue of issues.slice(0, 5)) {
-        lines.push(`  - ${formatSymphonyIssueStatus(issue)}`);
-    }
-    if (issues.length > 5) {
-        lines.push(`  ... ${issues.length - 5} more open issue(s)`);
-    }
-    for (const worker of workers.slice(0, 5)) {
-        lines.push(`  - ${formatSymphonyWorkerStatus(worker)}`);
-    }
-    if (workers.length > 5) {
-        lines.push(`  ... ${workers.length - 5} more running worker(s)`);
-    }
-    for (const report of reports.slice(0, 5)) {
-        lines.push(`  - ${formatSymphonyReportStatus(report)}`);
-    }
-    if (reports.length > 5) {
-        lines.push(`  ... ${reports.length - 5} more recent report(s)`);
-    }
-    if (source) {
-        lines.push('Source conversation:', `  Chat: ${source.chat}`, `  Thread: ${source.thread}`, ...(source.sessionId ? [`  Runtime session: ${source.sessionId}`] : []));
-    }
-    else {
-        lines.push('Source conversation: unavailable until LinX has WebID and session id.');
-    }
-    lines.push('Commands: /symphony on chat with Secretary, /symphony status inspect workers, /symphony off chat with worker/backend.');
-    return lines.join('\n');
-}
-function formatSymphonyStatusError(message) {
-    return message.replace(/\s+/gu, ' ').trim().slice(0, 180);
-}
-function resolveSymphonyStatusPodTimeoutMs(interactive) {
-    const value = Number(interactive?.__linxSymphonyStatusPodTimeoutMs);
-    return Number.isFinite(value) && value > 0 ? value : SYMPHONY_STATUS_POD_TIMEOUT_MS;
-}
-async function withSymphonyStatusTimeout(interactive, label, task) {
-    const timeoutMs = resolveSymphonyStatusPodTimeoutMs(interactive);
-    let timer = null;
-    try {
-        return await Promise.race([
-            task,
-            new Promise((_, reject) => {
-                timer = setTimeout(() => {
-                    reject(new Error(`${label} timed out after ${timeoutMs}ms`));
-                }, timeoutMs);
-            }),
-        ]);
-    }
-    finally {
-        if (timer) {
-            clearTimeout(timer);
-        }
-    }
-}
-async function listOpenSymphonyIssues(interactive) {
-    const controlRuntime = interactive?.__linxSymphonyPodProjectionRuntime;
-    try {
-        if (controlRuntime?.issueResource) {
-            const podIssues = await withSymphonyStatusTimeout(interactive, 'Symphony Pod issue status', listOpenSymphonyIssuesFromPod({ runtime: controlRuntime }));
-            if (podIssues) {
-                return { items: podIssues, source: 'pod' };
-            }
-        }
-    }
-    catch (error) {
-        return { items: [], source: 'none', error: error instanceof Error ? error.message : String(error) };
-    }
-    if (controlRuntime?.issueResource) {
-        return {
-            items: [],
-            source: 'none',
-            error: 'No active Pod session; Symphony control-plane state is Pod-authoritative.',
-        };
-    }
-    try {
-        const issues = typeof interactive?.__linxListSymphonyIssues === 'function'
-            ? interactive.__linxListSymphonyIssues()
-            : listSymphonyIssues();
-        return {
-            items: issues.filter((issue) => issue.status !== 'closed' && issue.status !== 'resolved'),
-            source: 'local',
-        };
-    }
-    catch {
-        return { items: [], source: 'none' };
-    }
-}
-async function listRunningSymphonyWorkers(interactive) {
-    const controlRuntime = interactive?.__linxSymphonyPodProjectionRuntime;
-    try {
-        if (controlRuntime?.sessionResource) {
-            const podWorkers = await withSymphonyStatusTimeout(interactive, 'Symphony Pod worker status', listRunningSymphonyWorkersFromPod({ runtime: controlRuntime }));
-            if (podWorkers) {
-                return { items: podWorkers, source: 'pod' };
-            }
-        }
-    }
-    catch (error) {
-        return { items: [], source: 'none', error: error instanceof Error ? error.message : String(error) };
-    }
-    if (controlRuntime?.sessionResource) {
-        return {
-            items: [],
-            source: 'none',
-            error: 'No active Pod session; Symphony control-plane state is Pod-authoritative.',
-        };
-    }
-    try {
-        if (typeof interactive?.__linxListSymphonySessions === 'function') {
-            const sessions = interactive.__linxListSymphonySessions();
-            return {
-                items: sessions.filter((session) => session.status === 'running'),
-                source: 'local',
-            };
-        }
-        return {
-            items: listSymphonySessions()
-                .filter((session) => session.status === 'running'),
-            source: 'local',
-        };
-    }
-    catch {
-        return { items: [], source: 'none' };
-    }
-}
-async function listRecentSymphonyReports(interactive) {
-    const controlRuntime = interactive?.__linxSymphonyPodProjectionRuntime;
-    try {
-        if (controlRuntime?.deliveryResource) {
-            const podReports = await withSymphonyStatusTimeout(interactive, 'Symphony Pod report status', listRecentSymphonyReportsFromPod({
-                runtime: controlRuntime,
-                limit: 5,
-            }));
-            if (podReports) {
-                return { items: podReports, source: 'pod' };
-            }
-        }
-    }
-    catch (error) {
-        return { items: [], source: 'none', error: error instanceof Error ? error.message : String(error) };
-    }
-    if (controlRuntime?.deliveryResource) {
-        return {
-            items: [],
-            source: 'none',
-            error: 'No active Pod session; Symphony control-plane state is Pod-authoritative.',
-        };
-    }
-    try {
-        const sessions = typeof interactive?.__linxListSymphonySessions === 'function'
-            ? interactive.__linxListSymphonySessions()
-            : listSymphonySessions();
-        return {
-            items: sessions
-                .filter((session) => session.status === 'completed' || session.status === 'failed')
-                .slice(0, 5),
-            source: 'local',
-        };
-    }
-    catch {
-        return { items: [], source: 'none' };
-    }
-}
-function formatSymphonyWorkerStatus(session) {
-    const target = session.target?.label
-        ?? session.target?.agent
-        ?? session.target?.chat
-        ?? session.backend;
-    const suffix = [
-        session.autoModeSessionId ? `runtime=${session.autoModeSessionId}` : undefined,
-        session.target?.chat ? `chat=${session.target.chat}` : undefined,
-        session.cwd ? `cwd=${session.cwd}` : undefined,
-    ].filter(Boolean).join(' · ');
-    return `${session.backend}/${session.mode} -> ${target}${suffix ? ` (${suffix})` : ''}`;
-}
-function formatSymphonyReportStatus(report) {
-    const status = report.status;
-    const reportRecord = report;
-    const target = reportRecord.agent
-        ?? reportRecord.target?.label
-        ?? reportRecord.target?.agent
-        ?? report.backend;
-    const title = 'summary' in report && report.summary
-        ? report.summary
-        : 'title' in report && report.title
-            ? report.title
-            : 'task' in report && report.task
-                ? formatSymphonyResourceTail(report.task)
-                : undefined;
-    const suffix = [
-        report.autoModeSessionId ? `runtime=${report.autoModeSessionId}` : undefined,
-        'thread' in report && report.thread ? `thread=${report.thread}` : undefined,
-        'completedAt' in report && report.completedAt ? `completed=${report.completedAt}` : undefined,
-        report.error ? `error=${report.error}` : undefined,
-    ].filter(Boolean).join(' · ');
-    return `${status} ${report.backend} -> ${target}${title ? `: ${title}` : ''}${suffix ? ` (${suffix})` : ''}`;
-}
-function formatSymphonyIssueStatus(issue) {
-    const taskCount = issue.tasks?.length ?? 0;
-    const suffix = [
-        formatSymphonyResourceTail(issue.uri),
-        taskCount > 0 ? `${taskCount} task${taskCount === 1 ? '' : 's'}` : undefined,
-        issue.thread ? `thread=${issue.thread}` : undefined,
-    ].filter(Boolean).join(' · ');
-    return `${issue.status} ${issue.title}${suffix ? ` (${suffix})` : ''}`;
-}
-function formatSymphonyResourceTail(uri) {
-    if (!uri) {
-        return undefined;
-    }
-    return uri.trim().match(/[:/#]([^:/#]+)$/u)?.[1] ?? uri;
-}
-async function resolveSymphonySourceContext(interactive) {
-    const sessionId = interactive?.sessionManager?.getSessionId?.()
-        ?? interactive?.session?.sessionManager?.getSessionId?.()
-        ?? interactive?.session?.sessionId;
-    const webId = await resolveSymphonyWebId(interactive);
-    if (typeof sessionId !== 'string' || !sessionId.trim() || !webId) {
-        return undefined;
-    }
-    const trimmedSessionId = sessionId.trim();
-    return {
-        chat: secretaryChatUri(webId),
-        thread: secretaryThreadUri(webId, trimmedSessionId, DEFAULT_SECRETARY_CHAT_ID),
-        sessionId: trimmedSessionId,
-    };
-}
-async function resolveSymphonyWebId(interactive) {
-    const candidates = [
-        interactive?.podSession?.webId,
-        interactive?.runtime?.podSession?.webId,
-        interactive?.session?.podSession?.webId,
-        interactive?.session?.runtime?.podSession?.webId,
-        interactive?.session?.state?.webId,
-        interactive?.state?.webId,
-    ];
-    for (const candidate of candidates) {
-        if (typeof candidate === 'string' && candidate.trim()) {
-            return candidate.trim();
-        }
-    }
-    const podSession = await interactive?.runtime?.getPodDataSession?.().catch(() => null);
-    if (typeof podSession?.webId === 'string' && podSession.webId.trim()) {
-        interactive.runtime.podSession = podSession;
-        return podSession.webId.trim();
-    }
-    return undefined;
-}
-async function promptForBackendCredential(interactive, details) {
-    const reason = details.reason ?? 'missing';
-    const repairLabel = formatBackendCredentialRepairReason(reason);
-    interactive.showStatus?.(`AI Secretary detected ${repairLabel} ${details.providerLabel} credentials before this backend can answer. ` +
-        'Enter them here; LinX will save them to your Pod AI settings and retry the message.');
-    if (canRenderPiLoginDialog(interactive)) {
-        return promptForApiCredentialWithPiDialog(interactive, {
-            title: `Connect ${details.providerLabel}`,
-            providerId: details.providerId,
-            providerLabel: details.providerLabel,
-            providerIdPrompt: details.providerIdPrompt,
-            apiKeyPrompt: details.apiKeyPrompt,
-            baseUrlPrompt: details.baseUrlPrompt,
-            progress: [
-                `AI Secretary detected ${repairLabel} credentials.`,
-                'LinX will save this with `linx ai connect` semantics into your Pod AI settings.',
-            ],
-            errorPrefix: `Failed to collect ${details.providerLabel} credentials`,
-        });
-    }
-    return promptForBackendCredentialWithExtensionInput(interactive, details, repairLabel);
-}
-async function handleInteractiveAiConnectCommand(interactive, runtime, command) {
-    const providerId = command.provider?.trim();
-    if (!providerId) {
-        interactive.showStatus?.('Usage: /ai connect <provider> [--base-url <url>] [--model <model>] - connect an AI provider key to LinX Pod AI settings.');
-        interactive.ui?.requestRender?.();
-        return;
-    }
-    const metadata = getAIConfigProviderMetadata(providerId);
-    const providerLabel = metadata.displayName ?? metadata.id;
-    const credential = canRenderPiLoginDialog(interactive)
-        ? await promptForApiCredentialWithPiDialog(interactive, {
-            title: `Connect ${providerLabel}`,
-            providerId: metadata.id,
-            providerLabel,
-            apiKeyPrompt: `${providerLabel} API key`,
-            baseUrlPrompt: command.baseUrl ? undefined : 'API base URL',
-            progress: [
-                `Connect ${providerLabel} with LinX AI connect.`,
-                'LinX will save this provider key to your Pod AI settings, not Pi auth.json.',
-                ...(command.model ? [`Default model: ${command.model}`] : []),
-            ],
-            errorPrefix: `Failed to connect ${providerLabel}`,
-        })
-        : await promptForApiCredentialWithExtensionInput(interactive, {
-            providerId: metadata.id,
-            providerLabel,
-            apiKeyPrompt: `${providerLabel} API key`,
-            baseUrlPrompt: command.baseUrl ? undefined : 'API base URL',
-            repairLabel: 'connect',
-        });
-    const apiKey = credential?.apiKey?.trim();
-    if (!apiKey) {
-        interactive.showStatus?.(`${providerLabel} AI connect cancelled.`);
-        interactive.ui?.requestRender?.();
-        return;
-    }
-    try {
-        const saveCredential = resolveInteractiveAiConnectCredentialSaver(interactive, runtime);
-        const credentialProviderId = credential?.providerId?.trim();
-        const credentialBaseUrl = credential?.baseUrl?.trim() || command.baseUrl?.trim();
-        const model = command.model?.trim();
-        const result = await saveCredential({
-            provider: credentialProviderId || metadata.id,
-            apiKey,
-            ...(credentialBaseUrl ? { baseUrl: credentialBaseUrl } : {}),
-            ...(model ? { model } : {}),
-        });
-        interactive.showStatus?.(`Connected AI provider ${result.providerId} to LinX Pod AI settings. api-key: ${result.maskedApiKey}`);
-        interactive.session?.modelRegistry?.refresh?.();
-        await interactive.updateAvailableProviderCount?.();
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        interactive.showError?.(`LinX AI connect failed: ${message}`);
-    }
-    finally {
-        interactive.ui?.requestRender?.();
-    }
-}
-function resolveInteractiveAiConnectCredentialSaver(interactive, runtime) {
-    const candidates = [
-        runtime?.connectAiProviderCredential,
-        interactive?.__linxConnectAiProviderCredential,
-        interactive?.runtime?.connectAiProviderCredential,
-    ];
-    for (const candidate of candidates) {
-        if (typeof candidate === 'function') {
-            return candidate;
-        }
-    }
-    return connectAiProviderCredential;
-}
-async function promptForApiCredentialWithPiDialog(interactive, details) {
-    const dialog = new LoginDialogComponent(interactive.ui, details.providerId, () => undefined, details.providerLabel, details.title);
-    const restoreEditor = () => {
-        interactive.editorContainer.clear();
-        interactive.editorContainer.addChild(interactive.editor);
-        interactive.ui?.setFocus?.(interactive.editor);
-        interactive.ui?.requestRender?.();
-    };
-    interactive.editorContainer.clear();
-    interactive.editorContainer.addChild(dialog);
-    interactive.ui?.setFocus?.(dialog);
-    interactive.ui?.requestRender?.();
-    try {
-        for (const line of details.progress ?? []) {
-            dialog.showProgress(line);
-        }
-        let providerId = details.providerId;
-        if (details.providerIdPrompt) {
-            const providerIdValue = await dialog.showPrompt(`Enter ${details.providerIdPrompt}:`, details.providerId);
-            providerId = typeof providerIdValue === 'string' && providerIdValue.trim()
-                ? providerIdValue.trim()
-                : details.providerId;
-        }
-        const apiKeyValue = await dialog.showPrompt(`Enter ${details.apiKeyPrompt}:`);
-        const apiKey = typeof apiKeyValue === 'string' ? apiKeyValue.trim() : '';
-        if (!apiKey) {
-            return null;
-        }
-        let baseUrl;
-        if (details.baseUrlPrompt) {
-            const baseUrlValue = await dialog.showPrompt(`Enter ${details.baseUrlPrompt} (optional):`);
-            baseUrl = typeof baseUrlValue === 'string' && baseUrlValue.trim()
-                ? baseUrlValue.trim()
-                : undefined;
-        }
-        return { providerId, apiKey, ...(baseUrl ? { baseUrl } : {}) };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        if (message !== 'Login cancelled') {
-            interactive.showError?.(`${details.errorPrefix}: ${message}`);
-        }
-        return null;
-    }
-    finally {
-        restoreEditor();
-    }
-}
-function canRenderPiLoginDialog(interactive) {
-    return Boolean(interactive?.isInitialized === true
-        && interactive?.ui
-        && interactive?.editor
-        && typeof interactive?.editorContainer?.clear === 'function'
-        && typeof interactive?.editorContainer?.addChild === 'function'
-        && typeof interactive?.ui?.setFocus === 'function'
-        && typeof interactive?.ui?.requestRender === 'function');
-}
-async function promptForBackendCredentialWithExtensionInput(interactive, details, repairLabel) {
-    return promptForApiCredentialWithExtensionInput(interactive, {
-        providerId: details.providerId,
-        providerLabel: details.providerLabel,
-        providerIdPrompt: details.providerIdPrompt,
-        apiKeyPrompt: details.apiKeyPrompt,
-        baseUrlPrompt: details.baseUrlPrompt,
-        repairLabel,
-    });
-}
-async function promptForApiCredentialWithExtensionInput(interactive, details) {
-    const repairLabel = details.repairLabel;
-    const apiKeyTitle = [
-        `${details.providerLabel} ${repairLabel} credential`,
-        `Paste an ${details.apiKeyPrompt}; LinX will save it to your Pod AI settings.`,
-        'Press Escape to cancel.',
-    ].join('\n');
-    if (typeof interactive.showExtensionInput !== 'function') {
-        interactive.showError?.(`This terminal cannot collect ${details.providerLabel} credentials inside the TUI. Run \`linx ai connect ${details.providerId}\` first.`);
-        return null;
-    }
-    let providerId = details.providerId;
-    if (details.providerIdPrompt) {
-        const providerIdTitle = [
-            `${details.providerLabel} ${repairLabel} provider`,
-            'Enter the provider id to store under /settings/providers/{provider}.ttl.',
-            `Default: ${details.providerId}`,
-            'Press Escape to cancel.',
-        ].join('\n');
-        const providerIdValue = await interactive.showExtensionInput(providerIdTitle, details.providerIdPrompt);
-        providerId = typeof providerIdValue === 'string' && providerIdValue.trim()
-            ? providerIdValue.trim()
-            : details.providerId;
-    }
-    const apiKeyValue = await interactive.showExtensionInput(apiKeyTitle, details.apiKeyPrompt);
-    const apiKey = typeof apiKeyValue === 'string' ? apiKeyValue.trim() : '';
-    if (!apiKey) {
-        return null;
-    }
-    let baseUrl;
-    if (details.baseUrlPrompt) {
-        const baseUrlTitle = [
-            `${details.providerLabel} ${repairLabel} base URL`,
-            'Optional. Leave empty to use the shared provider default.',
-            'Press Escape to cancel.',
-        ].join('\n');
-        const baseUrlValue = await interactive.showExtensionInput(baseUrlTitle, details.baseUrlPrompt);
-        baseUrl = typeof baseUrlValue === 'string' && baseUrlValue.trim()
-            ? baseUrlValue.trim()
-            : undefined;
-    }
-    return { providerId, apiKey, ...(baseUrl ? { baseUrl } : {}) };
-}
-function formatBackendCredentialRepairReason(reason) {
-    return reason === 'invalid' ? 'invalid' : 'missing';
-}
-function installLinxCwdStartupNotice(interactive, sessionCwd) {
-    const originalInit = interactive.init?.bind(interactive);
-    if (typeof originalInit !== 'function')
-        return;
-    interactive.init = async function patchedInit(...args) {
-        const result = await originalInit(...args);
-        const storedCwd = interactive?.session?.cwd ?? sessionCwd;
-        const currentCwd = process.cwd();
-        if (currentCwd !== storedCwd) {
-            setTimeout(() => {
-                process.stdout.write(`\n\x1b[33m  Session was at ${storedCwd}\x1b[0m\n` +
-                    `\x1b[33m  You're now at  ${currentCwd}\x1b[0m\n`);
-            }, 300);
-        }
-        return result;
-    };
-}
-export function installLinxEscapeInterrupt(interactive) {
-    const editor = interactive?.defaultEditor;
-    if (!editor || editor.__linxEscapeInterruptInstalled) {
-        return;
-    }
-    const initialOnEscape = typeof editor.onEscape === 'function'
-        ? editor.onEscape
-        : undefined;
-    let currentOnEscape = isLinxEscapeInterruptWrapper(initialOnEscape)
-        ? undefined
-        : initialOnEscape;
-    let lastIdleEscapeTime = 0;
-    const linxEscapeInterrupt = function linxEscapeInterrupt() {
-        const session = interactive?.session;
-        if (handBackAutoControlOnInterrupt(interactive)) {
-            lastIdleEscapeTime = 0;
-            return;
-        }
-        if (session?.isBashRunning && typeof session.abortBash === 'function') {
-            lastIdleEscapeTime = 0;
-            void session.abortBash();
-            return;
-        }
-        if (isLinxSessionRunning(interactive) && typeof session?.abort === 'function') {
-            lastIdleEscapeTime = 0;
-            void session.abort();
-            return;
-        }
-        if (shouldHandleLinxIdleDoubleEscape(interactive)) {
-            const now = Date.now();
-            if (now - lastIdleEscapeTime < 500) {
-                lastIdleEscapeTime = 0;
-                void openInteractiveRewindFromEscape(interactive);
-            }
-            else {
-                lastIdleEscapeTime = now;
-                interactive?.showStatus?.('Press Escape again to rewind this session.');
-                interactive?.ui?.requestRender?.();
-            }
-            return;
-        }
-        lastIdleEscapeTime = 0;
-        currentOnEscape?.call(editor);
-    };
-    Object.defineProperty(linxEscapeInterrupt, '__linxEscapeInterruptWrapper', {
-        value: true,
-    });
-    Object.defineProperty(editor, 'onEscape', {
-        configurable: true,
-        get() {
-            return linxEscapeInterrupt;
-        },
-        set(next) {
-            if (isLinxEscapeInterruptWrapper(next)) {
-                return;
-            }
-            currentOnEscape = typeof next === 'function' ? next : undefined;
-        },
-    });
-    installLinxClearInterrupt(interactive, editor);
-    editor.__linxEscapeInterruptInstalled = true;
-}
-function shouldHandleLinxIdleDoubleEscape(interactive) {
-    if (typeof interactive?.editor?.getText !== 'function') {
-        return false;
-    }
-    const text = String(interactive.editor.getText() ?? '');
-    return text.trim().length === 0;
-}
-async function openInteractiveRewindFromEscape(interactive) {
-    try {
-        await handleInteractiveRewindSelector(interactive, interactive?.runtime);
-    }
-    catch (error) {
-        interactive?.showError?.(error instanceof Error ? error.message : String(error));
-    }
-}
-function isLinxEscapeInterruptWrapper(value) {
-    return typeof value === 'function'
-        && value.__linxEscapeInterruptWrapper === true;
-}
-function installLinxClearInterrupt(interactive, editor) {
-    const handlers = editor?.actionHandlers;
-    if (!(handlers instanceof Map) || editor.__linxClearInterruptInstalled) {
-        return;
-    }
-    const originalClear = handlers.get('app.clear');
-    handlers.set('app.clear', () => {
-        if (handBackAutoControlOnInterrupt(interactive)) {
-            return;
-        }
-        originalClear?.call(editor);
-    });
-    editor.__linxClearInterruptInstalled = true;
-}
-function handBackAutoControlOnInterrupt(interactive) {
-    if (interactive?.__autoEnabled !== true) {
-        return false;
-    }
-    const session = interactive?.session;
-    if (session?.isBashRunning && typeof session.abortBash === 'function') {
-        void session.abortBash();
-    }
-    else if (isLinxSessionRunning(interactive) && typeof session?.abort === 'function') {
-        void session.abort();
-    }
-    void handleInteractiveAutoCommand(interactive, interactive?.runtime, false);
-    return true;
-}
-function isLinxSessionRunning(interactive) {
-    return interactive?.session?.isStreaming === true
-        || Boolean(interactive?.loadingAnimation)
-        || Boolean(interactive?.autoCompactionEscapeHandler)
-        || Boolean(interactive?.retryEscapeHandler);
-}
-function patchInteractiveExitMessage(interactive) {
-    const originalInit = interactive.init?.bind(interactive);
-    const originalStop = interactive.stop?.bind(interactive);
-    let initialized = false;
-    let exitMessageWritten = false;
-    if (typeof originalInit === 'function') {
-        interactive.init = async function patchedInit(...args) {
-            const result = await originalInit(...args);
-            initialized = true;
-            return result;
-        };
-    }
-    if (typeof originalStop !== 'function') {
-        return;
-    }
-    interactive.stop = function patchedStop(...args) {
-        originalStop(...args);
-        if (!initialized || exitMessageWritten || process.env.LINX_TUI_NO_EXIT_MESSAGE === '1') {
-            return;
-        }
-        exitMessageWritten = true;
-        if (process.stdout.isTTY) {
-            process.stdout.write(`\n${buildLinxExitMessage(this)}\n`);
-        }
-    };
-}
-export function buildLinxExitMessage(interactive) {
-    const sessionId = interactive?.session?.sessionId
-        ?? interactive?.sessionManager?.getSessionId?.()
-        ?? interactive?.session?.sessionManager?.getSessionId?.();
-    const usage = calculateSessionUsage(interactive?.session);
-    const lines = ['LinX session closed.'];
-    if (usage.input > 0 || usage.output > 0 || usage.cacheRead > 0 || usage.cacheWrite > 0) {
-        const usageParts = [
-            `input ${formatTokenCount(usage.input)}`,
-            `output ${formatTokenCount(usage.output)}`,
-        ];
-        if (usage.cacheRead > 0 || usage.cacheWrite > 0) {
-            usageParts.push(`cache ${usage.cacheRate ?? 0}%`);
-        }
-        lines.push(`Token usage: ${usageParts.join(' · ')}`);
-    }
-    if (typeof sessionId === 'string' && sessionId.trim()) {
-        lines.push(`Resume: linx --session ${sessionId}`);
-    }
-    return lines.join('\n');
-}
-export function installLinxResumeOutputStyle() {
-    if (linxResumeOutputStyleRestore) {
-        return linxResumeOutputStyleRestore;
-    }
-    const originalWrite = process.stdout.write;
-    const originalErrorWrite = process.stderr.write;
-    const stdoutFilter = createPiResumeOutputFilter();
-    const stderrFilter = createPiResumeOutputFilter();
-    const patchedStdoutWrite = function patchedPersistentLinxStdoutWrite(chunk, encodingOrCallback, callback) {
-        return writeWithPiResumeFilter(process.stdout, originalWrite, stdoutFilter, chunk, encodingOrCallback, callback);
-    };
-    const patchedStderrWrite = function patchedPersistentLinxStderrWrite(chunk, encodingOrCallback, callback) {
-        return writeWithPiResumeFilter(process.stderr, originalErrorWrite, stderrFilter, chunk, encodingOrCallback, callback);
-    };
-    process.stdout.write = patchedStdoutWrite;
-    process.stderr.write = patchedStderrWrite;
-    linxResumeOutputStyleRestore = () => {
-        flushPiResumeOutputFilter(process.stdout, originalWrite, stdoutFilter);
-        flushPiResumeOutputFilter(process.stderr, originalErrorWrite, stderrFilter);
-        if (process.stdout.write === patchedStdoutWrite) {
-            process.stdout.write = originalWrite;
-        }
-        if (process.stderr.write === patchedStderrWrite) {
-            process.stderr.write = originalErrorWrite;
-        }
-        linxResumeOutputStyleRestore = null;
-    };
-    return linxResumeOutputStyleRestore;
-}
-export async function withLinxResumeOutputStyle(run) {
-    const originalWrite = process.stdout.write;
-    const originalErrorWrite = process.stderr.write;
-    const stdoutFilter = createPiResumeOutputFilter();
-    const stderrFilter = createPiResumeOutputFilter();
-    process.stdout.write = function patchedLinxStdoutWrite(chunk, encodingOrCallback, callback) {
-        return writeWithPiResumeFilter(process.stdout, originalWrite, stdoutFilter, chunk, encodingOrCallback, callback);
-    };
-    process.stderr.write = function patchedLinxStderrWrite(chunk, encodingOrCallback, callback) {
-        return writeWithPiResumeFilter(process.stderr, originalErrorWrite, stderrFilter, chunk, encodingOrCallback, callback);
-    };
-    try {
-        const result = await run();
-        await new Promise((resolve) => setImmediate(resolve));
-        return result;
-    }
-    finally {
-        flushPiResumeOutputFilter(process.stdout, originalWrite, stdoutFilter);
-        flushPiResumeOutputFilter(process.stderr, originalErrorWrite, stderrFilter);
-        process.stdout.write = originalWrite;
-        process.stderr.write = originalErrorWrite;
-    }
-}
-/** @deprecated Use withLinxResumeOutputStyle. */
-export const withSuppressedPiResumeOutput = withLinxResumeOutputStyle;
-function createPiResumeOutputFilter() {
-    return { pending: '', suppressing: false };
-}
-function writeWithPiResumeFilter(stream, originalWrite, filter, chunk, encodingOrCallback, callback) {
-    const text = typeof chunk === 'string'
-        ? chunk
-        : Buffer.isBuffer(chunk) || chunk instanceof Uint8Array
-            ? Buffer.from(chunk).toString('utf8')
-            : '';
-    if (!text) {
-        return originalWrite.call(stream, chunk, encodingOrCallback, callback);
-    }
-    const output = filterPiResumeOutputText(text, filter);
-    if (!output) {
-        const done = typeof encodingOrCallback === 'function' ? encodingOrCallback : callback;
-        done?.();
-        return true;
-    }
-    if (output === text && !filter.pending) {
-        return originalWrite.call(stream, chunk, encodingOrCallback, callback);
-    }
-    return originalWrite.call(stream, output, encodingOrCallback, callback);
-}
-function flushPiResumeOutputFilter(stream, originalWrite, filter) {
-    const pending = filter.pending;
-    filter.pending = '';
-    if (filter.suppressing) {
-        filter.suppressing = false;
-        return;
-    }
-    if (!pending || isPotentialPiResumeOutput(pending)) {
-        return;
-    }
-    originalWrite.call(stream, pending);
-}
-function filterPiResumeOutputText(text, filter) {
-    let input = filter.pending + text;
-    filter.pending = '';
-    let output = '';
-    while (input) {
-        const newlineIndex = input.indexOf('\n');
-        if (newlineIndex >= 0) {
-            const line = input.slice(0, newlineIndex + 1);
-            if (filter.suppressing) {
-                filter.suppressing = false;
-            }
-            else if (!isPiResumeOutput(line)) {
-                output += line;
-            }
-            input = input.slice(newlineIndex + 1);
-            continue;
-        }
-        if (filter.suppressing) {
-            return output;
-        }
-        if (isPiResumeOutput(input)) {
-            filter.suppressing = true;
-            return output;
-        }
-        if (isPotentialPiResumeOutput(input)) {
-            filter.pending = input;
-            return output;
-        }
-        output += input;
-        return output;
-    }
-    return output;
-}
-function isPiResumeOutput(text) {
-    if (!text) {
-        return false;
-    }
-    const plain = stripAnsi(text);
-    return /To resume this session:\s*pi\s+--session(?:-dir|\s)/u.test(plain)
-        || /To resume this session:\s*pi\s+/u.test(plain);
-}
-function isPotentialPiResumeOutput(text) {
-    const plain = stripAnsi(text).trimStart();
-    if (!plain || plain.length >= 512) {
-        return false;
-    }
-    const marker = 'To resume this session:';
-    if (marker.startsWith(plain)) {
-        return true;
-    }
-    if (!plain.startsWith(marker)) {
-        return false;
-    }
-    const commandPrefix = plain.slice(marker.length).trimStart();
-    return !commandPrefix
-        || 'pi --session-dir'.startsWith(commandPrefix)
-        || 'pi --session'.startsWith(commandPrefix);
-}
-function stripAnsi(text) {
-    return text.replace(/\x1b\[[0-9;]*m/gu, '');
-}
-function patchPiFooter() {
-    if (footerPatched) {
-        return;
-    }
-    const originalRender = FooterComponent.prototype.render;
-    FooterComponent.prototype.render = function patchedRender(width) {
-        const lines = originalRender.call(this, width);
-        if (Array.isArray(lines) && lines.length > 1 && typeof lines[1] === 'string') {
-            const session = this.session;
-            const autoCompactEnabled = this.autoCompactEnabled !== false;
-            const footerData = this.footerData;
-            const modePrefix = buildLinxFooterModePrefix();
-            const modeLen = visibleWidth(modePrefix);
-            const bulletLen = modeLen > 0 ? 3 : 0;
-            const statusWidth = Math.max(0, width - modeLen - bulletLen);
-            lines[1] = buildLinxFooterStatusLine({
-                session,
-                width: statusWidth,
-                autoCompactEnabled,
-                footerData: footerData,
-            });
-            if (modePrefix) {
-                lines[1] = modePrefix + ' • ' + lines[1];
-            }
-        }
-        return lines;
-    };
-    footerPatched = true;
-}
-function buildLinxFooterModePrefix() {
-    if (!_linxFooterInteractive)
-        return '';
-    const autoOn = _linxFooterInteractive.__autoEnabled === true;
-    const symphonyOn = _linxFooterInteractive.__linxSymphonyModeEnabled === true;
-    if (!autoOn && !symphonyOn)
-        return '';
-    if (autoOn && symphonyOn)
-        return 'Symphony · Auto';
-    if (autoOn)
-        return 'Auto';
-    return 'Symphony';
-}
-export function patchPiAssistantMessageRendering() {
-    if (assistantMessagePatched) {
-        return;
-    }
-    const originalUpdateContent = AssistantMessageComponent.prototype.updateContent;
-    AssistantMessageComponent.prototype.updateContent = function patchedUpdateContent(message) {
-        const sanitizedMessage = stripLinxHiddenAssistantContent(message);
-        return originalUpdateContent.call(this, sanitizedMessage);
-    };
-    assistantMessagePatched = true;
-}
-function stripLinxHiddenAssistantContent(message) {
-    if (!isRecord(message) || !Array.isArray(message.content)) {
-        return message;
-    }
-    const content = message.content.filter((part) => !isLinxHiddenAssistantContentPart(part));
-    if (content.length === message.content.length) {
-        return message;
-    }
-    return {
-        ...message,
-        content,
-    };
-}
-function isLinxHiddenAssistantContentPart(part) {
-    return isRecord(part) && part.type === 'thinking';
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
-//# sourceMappingURL=interactive.js.map