@undefineds.co/linx 0.3.5 → 0.3.7

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

@@ -1,33 +1,2411 @@
-import { InteractiveMode } from '@mariozechner/pi-coding-agent';
-import { FooterComponent } from '@mariozechner/pi-coding-agent';
-import { truncateToWidth, visibleWidth } from '@mariozechner/pi-tui';
+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, 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, writeSymphonyIdea, } from '../symphony/archive.js';
+import { listOpenSymphonyIssuesFromPod, listRecentSymphonyReportsFromPod, listRunningSymphonyWorkersFromPod, mirrorSymphonyProjectionJsonLdFromPod, persistSymphonyIdeaToPod, persistSymphonyProjectionToPod, } from '../symphony/pod-projection.js';
+import { getSessionControlManager, installSessionControlRuntimeEventBridge, } from './session-control.js';
 let footerPatched = false;
-export function bootstrapPiInteractiveMode(runtime) {
+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;
+export function bootstrapLinxInteractiveMode(runtime, options = {}) {
+    installLinxResumeOutputStyle();
     patchPiFooter();
+    patchPiAssistantMessageRendering();
     const sessionCwd = runtime?.cwd || process.cwd();
-    const interactive = new InteractiveMode(runtime, {});
+    ensureInteractiveRuntimeHost(runtime);
+    const interactive = new InteractiveMode(runtime, options);
+    interactive.runtime = runtime;
+    interactive.__autoEnabled = runtime?.autoEnabled === true;
+    interactive.__linxSymphonyModeEnabled = runtime?.symphonyEnabled === true;
+    if (options.onSymphonyControlChange) {
+        ;
+        interactive.__linxOnSymphonyControlChange = options.onSymphonyControlChange;
+    }
+    const sessionControlManager = getSessionControlManager(interactive, runtime, sessionCwd);
+    runtime?.backendCommandRouter?.setSessionControl?.(sessionControlManager);
+    const restorePodStatusOutputFilter = installPodStatusOutputFilter();
     applyLinxInteractiveBranding(interactive);
     patchInteractiveExitMessage(interactive);
-    // Register /cd slash command — workspace follows terminal, session stays
-    installLinxCdCommand(interactive, sessionCwd);
-    return {
+    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();
-            installLinxEscapeInterrupt(interactive);
         },
-        async run() {
-            await interactive.run();
+        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.',
+                '托管中 · Secretary 自动输入 · Ctrl+C 接管 · /auto off',
+            ].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 === '/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 === '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 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);
+    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);
+    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 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托管中; 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)) {
+                const source = await resolveSymphonySourceContext(this);
+                const idea = await captureSymphonyIdeaIfNeeded(input, source);
+                getSessionControlManager(this, this.runtime).recordUserMessage({ text: input });
+                if (shouldDispatchSymphonyWorkerInput(input)) {
+                    await dispatchSymphonyWorkerFromInteractive(this, input, source);
+                    return;
+                }
+                await originalSubmit(buildSymphonyDelegationPrompt(input, {
+                    persistentMode: true,
+                    ...(source ? { source } : {}),
+                    ...(idea ? { idea } : {}),
+                }));
+                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: 'ai',
+        argumentHint: 'connect <provider>',
+        description: 'connect AI provider credentials to LinX Pod settings',
+        getArgumentCompletions: completeAiArguments,
+    },
+    {
+        name: 'symphony',
+        argumentHint: 'on|off|status',
+        description: 'switch chat peer between Secretary and backend worker',
+        getArgumentCompletions: (prefix) => completeStaticArguments(prefix, [
+            { value: 'on', description: 'Chat with Secretary using Symphony orchestration skills' },
+            { value: 'off', description: 'Chat directly with the current worker/backend peer' },
+            { value: 'status', description: 'Show Symphony state and source conversation' },
+        ]),
+    },
+];
+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 on: you are now chatting with Secretary.',
+            'What changed: following normal messages enter the Secretary control lane before worker/backend routing.',
+            'Skills: issue triage, existing Issue lookup, create/update/ask decision, task split, worker dispatch, status/report tracking.',
+            'Ordinary chat stays ordinary Message; only trackable work becomes Issue/Task/Delivery/Session.',
+            'Use /symphony status to inspect workers, /symphony off to chat with the current worker/backend peer.',
+        ].join('\n')
+        : [
+            'Symphony off: you are now chatting with the current worker/backend peer.',
+            'What changed: following messages bypass Secretary Symphony triage and dispatch.',
+            'Current Symphony dispatches started from this TUI were cancelled; archived workers remain inspectable with /symphony status.',
+            'Use /symphony on to chat with Secretary again.',
+        ].join('\n');
+}
+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 shouldDispatchSymphonyWorkerInput(input) {
+    const normalized = input.trim().toLowerCase();
+    if (!normalized) {
+        return false;
+    }
+    return /\b(delegate|dispatch|assign|worker|agent|task)\b/u.test(normalized)
+        || /(派工|派活|派发|委派|分派|交给.*(worker|agent|codex|claude|codebuddy|ai)|让.*(worker|agent|codex|claude|codebuddy|ai).*做|发一个任务|派出一个任务)/u.test(input);
+}
+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 dispatch started.',
+        `Worker backend: ${backend}`,
+        `Worker credentials: ${workerCredentialSource}`,
+        ...(agentRuntime ? [`Control runtime: ${formatSymphonyControlRuntime(agentRuntime)}`] : []),
+        ...(workerModel ? [`Worker model: ${workerModel}`] : []),
+        workerGoalMode
+            ? `Worker goal: on · supervisor interval=${formatSymphonySupervisorInterval(workerSupervisorIntervalMs)}`
+            : 'Worker goal: off',
+        'Status: creating Issue / Task / Delivery and starting a quiet worker session.',
+        'Use /symphony status to inspect running workers and reports.',
+    ].join('\n'));
+    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,
+        persistSymphonyProjectionToPod(plan, options) {
+            return persistSymphonyProjectionToPod(plan, {
+                ...options,
+                runtime: projectionRuntime,
+            });
         },
-        requestLogin(reason = 'manual') {
-            requestLinxCloudLogin(interactive, reason);
+        listOpenSymphonyIssuesFromPod() {
+            return listOpenSymphonyIssuesFromPod({ runtime: projectionRuntime });
         },
-        stop() {
-            interactive.stop();
+        mirrorSymphonyProjectionJsonLdFromPod(result) {
+            return mirrorSymphonyProjectionJsonLdFromPod(result, { runtime: projectionRuntime });
         },
     };
 }
-function installLinxCdCommand(interactive, sessionCwd) {
+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 dispatch completed.'
+            : 'Symphony dispatch recorded.',
+        `Issue: ${plan.issue.title} (${formatSymphonyResourceTail(plan.issue.uri) ?? plan.issue.uri})`,
+        `Task: ${formatSymphonyResourceTail(worker?.task ?? plan.task) ?? worker?.task ?? plan.task}`,
+        `Delivery: ${delivery.status}${delivery.autoModeSessionId ? ` · runtime=${delivery.autoModeSessionId}` : ''}`,
+        `Worker session: ${session.status}${session.autoModeSessionId ? ` · runtime=${session.autoModeSessionId}` : ''}`,
+        'Use /symphony status to inspect the Pod-projected worker report.',
+    ];
+    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)
+            .catch(() => null);
+        if (!persisted) {
+            writeSymphonyIdea(idea);
+        }
+        return {
+            uri: idea.uri,
+            summary: idea.summary,
+            status: idea.status,
+            commitment: idea.commitment,
+        };
+    }
+    catch {
+        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;
+}
+function buildSymphonyDelegationPrompt(objective, options) {
+    const modeLine = options.persistentMode
+        ? 'Symphony is on: the user is chatting with Secretary in this LinX TUI session.'
+        : 'This is a chat-driven Symphony request from the LinX TUI.';
+    const sourceLines = options.source
+        ? [
+            '',
+            'Source conversation resources:',
+            `Chat: ${options.source.chat}`,
+            `Thread: ${options.source.thread}`,
+            ...(options.source.sessionId ? [`Runtime session: ${options.source.sessionId}`] : []),
+        ]
+        : [];
+    const ideaLines = options.idea
+        ? [
+            '',
+            'Captured Idea:',
+            `Idea: ${options.idea.uri}`,
+            `Summary: ${options.idea.summary}`,
+            `Commitment: ${options.idea.commitment}`,
+            `Status: ${options.idea.status}`,
+        ]
+        : [];
+    return [
+        'AI Secretary Symphony request.',
+        modeLine,
+        ...sourceLines,
+        ...ideaLines,
+        '',
+        'User objective:',
+        objective.trim(),
+        '',
+        'Act as AI Secretary with Symphony skills enabled: issue triage, existing issue lookup, create/update/ask decision, task split, worker dispatch, and status/report tracking.',
+        'Decide whether this objective should be delegated to backend workers through Symphony.',
+        'Do not create an Issue for ordinary chat. Create or update an Issue only when the objective is a trackable work item.',
+        'If this is an uncommitted fragment, keep or merge it as an Idea first; do not dispatch a worker until promotion gates are met.',
+        'Before creating a new Issue, compare against existing open Issues. Update the existing Issue when it is clearly the same work item, and ask the user only when new-vs-existing is ambiguous.',
+        'Every delegation must target a Chat resource. Use a personal AI contact chat when assigning to one worker, or a group chat when the work belongs in a shared room.',
+        'Use the Source conversation resources only as provenance unless they are also the correct target chat.',
+        'If delegation is appropriate, create or update the normal LinX work context, derive issue/task acceptance criteria from the objective and source context, and project the task to the selected backend worker.',
+        'Ask the user only when acceptance, authority, credentials, or target selection cannot be safely inferred.',
+        'If delegation is not appropriate, explain the reason and continue in this conversation.',
+        'Keep the user-facing answer concise and show the next observable step.',
+    ].join('\n');
+}
+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 projectionErrors = Array.from(new Set([
+        workersRead.error,
+        issuesRead.error,
+        reportsRead.error,
+    ].filter((item) => Boolean(item))));
+    const projectionSources = 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}`,
+        projectionErrors.length > 0
+            ? `Pod projection: unavailable (${formatSymphonyStatusError(projectionErrors[0])})`
+            : projectionSources.has('pod')
+                ? 'Pod projection: active.'
+                : 'Pod projection: local archive only.',
+        '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.',
+    ];
+    if (projectionErrors.length > 0) {
+        lines.push('Fallback: showing local Symphony archive while Pod projection is unavailable.');
+    }
+    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 projectionRuntime = interactive?.__linxSymphonyPodProjectionRuntime;
+    let projectionError;
+    try {
+        if (projectionRuntime?.issueResource) {
+            const podIssues = await withSymphonyStatusTimeout(interactive, 'Symphony Pod issue status', listOpenSymphonyIssuesFromPod({ runtime: projectionRuntime }));
+            if (podIssues) {
+                return { items: podIssues, source: 'pod' };
+            }
+        }
+    }
+    catch (error) {
+        projectionError = error instanceof Error ? error.message : String(error);
+        // Fall back to local no-Pod archive below.
+    }
+    try {
+        const issues = typeof interactive?.__linxListSymphonyIssues === 'function'
+            ? interactive.__linxListSymphonyIssues()
+            : listSymphonyIssues();
+        return {
+            items: issues.filter((issue) => issue.status !== 'closed' && issue.status !== 'resolved'),
+            source: 'local',
+            ...(projectionError ? { error: projectionError } : {}),
+        };
+    }
+    catch {
+        return { items: [], source: 'none', ...(projectionError ? { error: projectionError } : {}) };
+    }
+}
+async function listRunningSymphonyWorkers(interactive) {
+    const projectionRuntime = interactive?.__linxSymphonyPodProjectionRuntime;
+    let projectionError;
+    try {
+        if (projectionRuntime?.sessionResource) {
+            const podWorkers = await withSymphonyStatusTimeout(interactive, 'Symphony Pod worker status', listRunningSymphonyWorkersFromPod({ runtime: projectionRuntime }));
+            if (podWorkers) {
+                return { items: podWorkers, source: 'pod' };
+            }
+        }
+    }
+    catch (error) {
+        projectionError = error instanceof Error ? error.message : String(error);
+    }
+    try {
+        if (typeof interactive?.__linxListSymphonySessions === 'function') {
+            const sessions = interactive.__linxListSymphonySessions();
+            return {
+                items: sessions.filter((session) => session.status === 'running'),
+                source: 'local',
+                ...(projectionError ? { error: projectionError } : {}),
+            };
+        }
+        return {
+            items: listSymphonySessions()
+                .filter((session) => session.status === 'running'),
+            source: 'local',
+            ...(projectionError ? { error: projectionError } : {}),
+        };
+    }
+    catch {
+        return { items: [], source: 'none', ...(projectionError ? { error: projectionError } : {}) };
+    }
+}
+async function listRecentSymphonyReports(interactive) {
+    const projectionRuntime = interactive?.__linxSymphonyPodProjectionRuntime;
+    let projectionError;
+    try {
+        if (projectionRuntime?.deliveryResource) {
+            const podReports = await withSymphonyStatusTimeout(interactive, 'Symphony Pod report status', listRecentSymphonyReportsFromPod({
+                runtime: projectionRuntime,
+                limit: 5,
+            }));
+            if (podReports) {
+                return { items: podReports, source: 'pod' };
+            }
+        }
+    }
+    catch (error) {
+        projectionError = error instanceof Error ? error.message : String(error);
+        // Fall back to local no-Pod archive below.
+    }
+    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',
+            ...(projectionError ? { error: projectionError } : {}),
+        };
+    }
+    catch {
+        return { items: [], source: 'none', ...(projectionError ? { error: projectionError } : {}) };
+    }
+}
+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;
@@ -49,31 +2427,77 @@ export function installLinxEscapeInterrupt(interactive) {
     if (!editor || editor.__linxEscapeInterruptInstalled) {
         return;
     }
-    let currentOnEscape = typeof editor.onEscape === 'function'
+    const initialOnEscape = typeof editor.onEscape === 'function'
         ? editor.onEscape
         : undefined;
+    let currentOnEscape = isLinxEscapeInterruptWrapper(initialOnEscape)
+        ? undefined
+        : initialOnEscape;
+    const linxEscapeInterrupt = function linxEscapeInterrupt() {
+        const session = interactive?.session;
+        if (handBackAutoControlOnInterrupt(interactive)) {
+            return;
+        }
+        if (session?.isBashRunning && typeof session.abortBash === 'function') {
+            void session.abortBash();
+            return;
+        }
+        if (isLinxSessionRunning(interactive) && typeof session?.abort === 'function') {
+            void session.abort();
+            return;
+        }
+        currentOnEscape?.call(editor);
+    };
+    Object.defineProperty(linxEscapeInterrupt, '__linxEscapeInterruptWrapper', {
+        value: true,
+    });
     Object.defineProperty(editor, 'onEscape', {
         configurable: true,
         get() {
-            return function linxEscapeInterrupt() {
-                const session = interactive?.session;
-                if (session?.isBashRunning && typeof session.abortBash === 'function') {
-                    void session.abortBash();
-                    return;
-                }
-                if (isLinxSessionRunning(interactive) && typeof session?.abort === 'function') {
-                    void session.abort();
-                    return;
-                }
-                currentOnEscape?.call(editor);
-            };
+            return linxEscapeInterrupt;
         },
         set(next) {
+            if (isLinxEscapeInterruptWrapper(next)) {
+                return;
+            }
             currentOnEscape = typeof next === 'function' ? next : undefined;
         },
     });
+    installLinxClearInterrupt(interactive, editor);
     editor.__linxEscapeInterruptInstalled = true;
 }
+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)
@@ -123,10 +2547,160 @@ export function buildLinxExitMessage(interactive) {
         lines.push(`Token usage: ${usageParts.join(' · ')}`);
     }
     if (typeof sessionId === 'string' && sessionId.trim()) {
-        lines.push(`Resume: linx resume ${sessionId}`);
+        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;
@@ -143,6 +2717,36 @@ function patchPiFooter() {
     };
     footerPatched = true;
 }
+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;
+}
 function buildLinxFooterStatusLine(session, width, autoCompactEnabled) {
     const usage = calculateSessionUsage(session);
     const state = session?.state ?? {};