@undefineds.co/linx 0.3.8 → 0.3.13

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

@@ -13,9 +13,10 @@ 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 { createSymphonyIdeaRecord, listSymphonyIssues, listSymphonySessions, } from '../symphony/archive.js';
+import { listOpenSymphonyIssuesFromPod, listRecentSymphonyReportsFromPod, listRunningSymphonyWorkersFromPod, mirrorSymphonyProjectionJsonLdFromPod, persistSymphonyIdeaToPod, persistSymphonyControlStateToPod, } from '../symphony/pod-projection.js';
 import { getSessionControlManager, installSessionControlRuntimeEventBridge, } from './session-control.js';
+import { buildLinxFooterStatusLine, calculateSessionUsage, DEFAULT_STATUS_LINE_TOKENS, formatTokenCount, LINX_STATUS_LINE_TOKEN_NAMES, parseLinxStatusLineColorArg, parseLinxStatusLineTokenArgs, readLinxStatusLineConfig, resetLinxStatusLineConfig, writeLinxStatusLineConfigPatch, } from '../linx-status-line.js';
 let footerPatched = false;
 let assistantMessagePatched = false;
 let linxResumeOutputStyleRestore = null;
@@ -27,6 +28,21 @@ const BACKEND_OWNED_SLASH_COMMANDS = new Set([
 ]);
 const SYMPHONY_STATUS_POD_TIMEOUT_MS = 1_200;
 const DEFAULT_SYMPHONY_WORKER_SUPERVISOR_INTERVAL_MS = 10 * 60 * 1000;
+const CODEX_STYLE_STATUS_LINE_TOKENS = [
+    'model-with-reasoning',
+    'git-branch',
+    'context-remaining',
+    'total-input-tokens',
+    'total-output-tokens',
+    'current-dir',
+];
+const COMPACT_STATUS_LINE_TOKENS = [
+    'model-with-reasoning',
+    'context-remaining',
+    'current-dir',
+];
+/** Module-level reference to interactive for footer mode state (set during bootstrap). */
+let _linxFooterInteractive = null;
 export function bootstrapLinxInteractiveMode(runtime, options = {}) {
     installLinxResumeOutputStyle();
     patchPiFooter();
@@ -37,6 +53,7 @@ export function bootstrapLinxInteractiveMode(runtime, options = {}) {
     interactive.runtime = runtime;
     interactive.__autoEnabled = runtime?.autoEnabled === true;
     interactive.__linxSymphonyModeEnabled = runtime?.symphonyEnabled === true;
+    _linxFooterInteractive = interactive;
     if (options.onSymphonyControlChange) {
         ;
         interactive.__linxOnSymphonyControlChange = options.onSymphonyControlChange;
@@ -124,7 +141,7 @@ export function installLinxRestoredAutoStartup(interactive, runtime, sessionCont
             controller.start({ scheduleImmediately: true });
             interactive.showStatus?.([
                 'Auto restored from the previous session.',
-                '托管中 · Secretary 自动输入 · Ctrl+C 接管 · /auto off',
+                'auto · Ctrl+C or /auto off to hand control back',
             ].join('\n'));
             interactive.ui?.requestRender?.();
         }
@@ -528,6 +545,15 @@ function parseLinxGlobalCommand(input) {
     if (input.startsWith('/ai connect ')) {
         return { action: 'ai-connect', ...parseInteractiveAiConnectArgs(input.slice('/ai connect'.length).trim()) };
     }
+    if (input === '/statusline' || input === '/status-line') {
+        return { action: 'statusline', args: [] };
+    }
+    if (input.startsWith('/statusline ') || input.startsWith('/status-line ')) {
+        const body = input.startsWith('/statusline ')
+            ? input.slice('/statusline'.length).trim()
+            : input.slice('/status-line'.length).trim();
+        return { action: 'statusline', args: splitInteractiveCommandArgs(body) };
+    }
     if (input === '/rewind') {
         return { action: 'rewind-select' };
     }
@@ -649,6 +675,10 @@ async function handleLinxGlobalCommand(interactive, runtime, command) {
         await handleInteractiveAiConnectCommand(interactive, runtime, command);
         return;
     }
+    if (command.action === 'statusline') {
+        await handleInteractiveStatusLineCommand(interactive, command.args);
+        return;
+    }
     if (command.action === 'rewind-select') {
         await handleInteractiveRewindSelector(interactive, runtime);
         return;
@@ -659,6 +689,130 @@ async function handleLinxGlobalCommand(interactive, runtime, command) {
     }
     await changeInteractiveCwd(interactive, runtime, command.target);
 }
+async function handleInteractiveStatusLineCommand(interactive, args) {
+    if (args.length > 0) {
+        handleInteractiveStatusLineArgs(interactive, args);
+        return;
+    }
+    const summary = formatInteractiveStatusLineSummary();
+    if (typeof interactive.showExtensionSelector !== 'function') {
+        interactive.showStatus?.(`${summary} · Use /statusline set <tokens...>, /statusline tokens, /statusline colors <on|off>, or /statusline reset.`);
+        interactive.ui?.requestRender?.();
+        return;
+    }
+    const choice = await interactive.showExtensionSelector(`Status line\n${summary}`, [
+        'Use Codex-style preset',
+        'Use compact preset',
+        'Configure tokens manually',
+        'Toggle colors',
+        'Show available tokens',
+        'Reset to default',
+    ]);
+    if (choice === 'Use Codex-style preset') {
+        writeInteractiveStatusLineConfig(interactive, {
+            statusLine: CODEX_STYLE_STATUS_LINE_TOKENS,
+            message: 'Status line set to Codex-style preset.',
+        });
+        return;
+    }
+    if (choice === 'Use compact preset') {
+        writeInteractiveStatusLineConfig(interactive, {
+            statusLine: COMPACT_STATUS_LINE_TOKENS,
+            message: 'Status line set to compact preset.',
+        });
+        return;
+    }
+    if (choice === 'Toggle colors') {
+        const current = readLinxStatusLineConfig();
+        writeInteractiveStatusLineConfig(interactive, {
+            statusLineUseColors: !current.useColors,
+            message: `Status line colors ${current.useColors ? 'disabled' : 'enabled'}.`,
+        });
+        return;
+    }
+    if (choice === 'Show available tokens') {
+        showInteractiveStatusLineTokens(interactive);
+        return;
+    }
+    if (choice === 'Reset to default') {
+        resetLinxStatusLineConfig();
+        finishInteractiveStatusLineUpdate(interactive, `Status line reset to default: ${DEFAULT_STATUS_LINE_TOKENS.join(', ')}`);
+        return;
+    }
+    if (choice === 'Configure tokens manually') {
+        await promptInteractiveStatusLineTokens(interactive);
+    }
+}
+function handleInteractiveStatusLineArgs(interactive, args) {
+    const action = args[0]?.toLowerCase();
+    if (action === 'tokens' || action === 'list') {
+        showInteractiveStatusLineTokens(interactive);
+        return;
+    }
+    if (action === 'reset') {
+        resetLinxStatusLineConfig();
+        finishInteractiveStatusLineUpdate(interactive, `Status line reset to default: ${DEFAULT_STATUS_LINE_TOKENS.join(', ')}`);
+        return;
+    }
+    if (action === 'colors' || action === 'color') {
+        const value = parseLinxStatusLineColorArg(args[1]);
+        if (value === undefined) {
+            interactive.showError?.('Usage: /statusline colors <on|off>');
+            return;
+        }
+        writeInteractiveStatusLineConfig(interactive, {
+            statusLineUseColors: value,
+            message: `Status line colors ${value ? 'enabled' : 'disabled'}.`,
+        });
+        return;
+    }
+    const tokenArgs = action === 'set' ? args.slice(1) : args;
+    try {
+        const tokens = parseLinxStatusLineTokenArgs(tokenArgs);
+        writeInteractiveStatusLineConfig(interactive, {
+            statusLine: tokens,
+            message: `Status line updated: ${tokens.join(', ')}`,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        interactive.showError?.(`${message}. Use /statusline tokens to list valid tokens.`);
+    }
+}
+async function promptInteractiveStatusLineTokens(interactive) {
+    if (typeof interactive.showExtensionInput !== 'function') {
+        interactive.showStatus?.(`Use /statusline set ${CODEX_STYLE_STATUS_LINE_TOKENS.join(' ')}`);
+        interactive.ui?.requestRender?.();
+        return;
+    }
+    const value = await interactive.showExtensionInput('Status line tokens', CODEX_STYLE_STATUS_LINE_TOKENS.join(' '));
+    if (typeof value !== 'string' || !value.trim()) {
+        interactive.showStatus?.('Status line unchanged.');
+        interactive.ui?.requestRender?.();
+        return;
+    }
+    handleInteractiveStatusLineArgs(interactive, ['set', ...splitInteractiveCommandArgs(value)]);
+}
+function writeInteractiveStatusLineConfig(interactive, patch) {
+    writeLinxStatusLineConfigPatch({
+        ...(patch.statusLine ? { statusLine: patch.statusLine } : {}),
+        ...(patch.statusLineUseColors !== undefined ? { statusLineUseColors: patch.statusLineUseColors } : {}),
+    });
+    finishInteractiveStatusLineUpdate(interactive, patch.message);
+}
+function finishInteractiveStatusLineUpdate(interactive, message) {
+    interactive.footer?.invalidate?.();
+    interactive.showStatus?.(message);
+    interactive.ui?.requestRender?.();
+}
+function showInteractiveStatusLineTokens(interactive) {
+    interactive.showStatus?.(`Status line tokens: ${LINX_STATUS_LINE_TOKEN_NAMES.join(', ')}`);
+    interactive.ui?.requestRender?.();
+}
+function formatInteractiveStatusLineSummary() {
+    const config = readLinxStatusLineConfig();
+    return `Current: ${config.tokens.join(', ')} · colors ${config.useColors ? 'on' : 'off'} · source ${config.tokenSource}`;
+}
 async function handleInteractiveRewindSelector(interactive, runtime) {
     const session = resolveInteractiveSession(interactive, runtime);
     const sessionManager = resolveInteractiveSessionManager(interactive, runtime);
@@ -720,6 +874,7 @@ async function handleInteractiveRewindTurnsCommand(interactive, runtime, turns)
     }
     const cleanResult = materializeCleanRewindSession(sessionManager, result.targetLeafId, previousState);
     syncAgentStateFromSessionManager(session, sessionManager);
+    refreshInteractiveTranscriptFromSessionManager(interactive);
     await syncRewindProjection(interactive, runtime, {
         previousState,
         cleanResult,
@@ -748,6 +903,7 @@ async function rewindSessionManagerBeforeUserEntry(interactive, runtime, session
     moveSessionManagerLeaf(sessionManager, targetLeafId);
     const cleanResult = materializeCleanRewindSession(sessionManager, targetLeafId, previousState);
     syncAgentStateFromSessionManager(session, sessionManager);
+    refreshInteractiveTranscriptFromSessionManager(interactive);
     await syncRewindProjection(interactive, runtime, {
         previousState,
         cleanResult,
@@ -987,6 +1143,22 @@ function syncAgentStateFromSessionManager(session, sessionManager) {
         session.agent.state.messages = context.messages;
     }
 }
+function refreshInteractiveTranscriptFromSessionManager(interactive) {
+    try {
+        if (typeof interactive?.rebuildChatFromMessages === 'function') {
+            interactive.rebuildChatFromMessages();
+            return;
+        }
+        if (typeof interactive?.renderInitialMessages === 'function') {
+            interactive.chatContainer?.clear?.();
+            interactive.renderInitialMessages();
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        interactive?.showWarning?.(`Rewind transcript refresh failed: ${message}`);
+    }
+}
 function collectRewindUserMessages(_session, sessionManager) {
     return getActiveSessionBranch(sessionManager)
         .filter((entry) => entry?.type === 'message' && entry.message?.role === 'user')
@@ -1190,7 +1362,7 @@ function formatAutoModeChangeStatus(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.',
+            'User-visible state: the input bar shows auto; Ctrl+C or /auto off hands control back to you.',
             'Backend approval policy is unchanged.',
         ].join('\n')
         : [
@@ -1270,18 +1442,8 @@ export function installSymphonyCommand(interactive) {
                 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 } : {}),
-                }));
+                await originalSubmit(renderSymphonySecretaryProjection(input));
                 return;
             }
             await originalSubmit(text);
@@ -1347,6 +1509,17 @@ const LINX_INTERACTIVE_SLASH_COMMANDS = [
         name: 'rewind',
         description: 'select a user message and rewind the active branch before it',
     },
+    {
+        name: 'statusline',
+        argumentHint: 'set|colors|tokens|reset',
+        description: 'configure which items appear in the status line',
+        getArgumentCompletions: (prefix) => completeStaticArguments(prefix, [
+            { value: 'set', description: 'Set status line tokens' },
+            { value: 'colors', description: 'Enable or disable status line colors' },
+            { value: 'tokens', description: 'List available status line tokens' },
+            { value: 'reset', description: 'Restore default status line tokens' },
+        ]),
+    },
     {
         name: 'ai',
         argumentHint: 'connect <provider>',
@@ -1356,11 +1529,11 @@ const LINX_INTERACTIVE_SLASH_COMMANDS = [
     {
         name: 'symphony',
         argumentHint: 'on|off|status',
-        description: 'switch chat peer between Secretary and backend worker',
+        description: 'turn Secretary task handoff on/off, or show status',
         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' },
+            { value: 'on', description: 'Secretary can plan and hand off larger tasks' },
+            { value: 'off', description: 'Return to direct chat' },
+            { value: 'status', description: 'Show whether Symphony task handoff is enabled' },
         ]),
     },
 ];
@@ -1472,19 +1645,8 @@ async function handleSymphonyCommand(interactive, command) {
 }
 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');
+        ? 'Symphony is on. I will keep ordinary chat ordinary and only plan or hand off real work.'
+        : 'Symphony is off. Back to direct chat. Active handoffs from this window were stopped.';
 }
 function formatSymphonyUsage(input) {
     return [
@@ -1498,13 +1660,21 @@ function shouldProjectSymphonyInput(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);
+function renderSymphonySecretaryProjection(input) {
+    return [
+        '# AI Secretary Symphony request',
+        '',
+        'Symphony is on: the user is chatting with Secretary, not directly with the worker/backend peer.',
+        'Treat the user message below as a Secretary-facing product message.',
+        'Decide whether it is ordinary chat, an Idea, a change to existing work, or delegable work.',
+        'Default response style: reply like normal chat.',
+        'Do not print internal Symphony binding, Issue/Task routing, worker selection, or report-style sections unless a visible state change or blocker must be surfaced.',
+        'If the message is ordinary chat or early exploration, answer directly and do not explain that it was not delegated.',
+        'If real delegation is needed, summarize the visible handoff result briefly after updating control state.',
+        '',
+        'User message:',
+        input,
+    ].join('\n');
 }
 async function dispatchSymphonyWorkerFromInteractive(interactive, objective, source) {
     const backend = resolveSymphonyWorkerBackend(interactive, objective);
@@ -1522,18 +1692,9 @@ async function dispatchSymphonyWorkerFromInteractive(interactive, objective, sou
     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.showStatus?.(`Symphony handoff started: ${backend}${workerModel ? ` · ${workerModel}` : ''}`
+        + `${workerGoalMode ? ` · supervised every ${formatSymphonySupervisorInterval(workerSupervisorIntervalMs)}` : ''}.`
+        + ' Use /symphony status for details.');
     interactive.ui?.requestRender?.();
     const run = typeof interactive.__linxRunSymphony === 'function'
         ? interactive.__linxRunSymphony
@@ -1624,8 +1785,8 @@ function createInteractiveSymphonyRuntime(interactive) {
     return {
         runAutoMode,
         listAutoModeSessions: listArchivedAutoModeSessions,
-        persistSymphonyProjectionToPod(plan, options) {
-            return persistSymphonyProjectionToPod(plan, {
+        persistSymphonyControlStateToPod(plan, options) {
+            return persistSymphonyControlStateToPod(plan, {
                 ...options,
                 runtime: projectionRuntime,
             });
@@ -1817,13 +1978,9 @@ function formatSymphonyDispatchResult(plan) {
     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.',
+            ? `Symphony handoff completed: ${plan.issue.title}.`
+            : `Symphony handoff recorded: ${plan.issue.title}.`,
+        'Use /symphony status for details.',
     ];
     if (session.error) {
         lines.push(`Error: ${session.error}`);
@@ -1847,10 +2004,9 @@ async function captureSymphonyIdeaIfNeeded(input, source) {
             ...(affectedArea ? { affectedArea } : {}),
         };
         const idea = createSymphonyIdeaRecord(captureInput);
-        const persisted = await persistSymphonyIdeaToPod(idea)
-            .catch(() => null);
+        const persisted = await persistSymphonyIdeaToPod(idea);
         if (!persisted) {
-            writeSymphonyIdea(idea);
+            throw new Error('No active Pod session; Symphony Idea records must be written to Pod in LinX runtime.');
         }
         return {
             uri: idea.uri,
@@ -1859,7 +2015,10 @@ async function captureSymphonyIdeaIfNeeded(input, source) {
             commitment: idea.commitment,
         };
     }
-    catch {
+    catch (error) {
+        process.emitWarning(error instanceof Error
+            ? new Error(`LinX Symphony Idea Pod write failed: ${error.message}`)
+            : new Error(`LinX Symphony Idea Pod write failed: ${String(error)}`));
         return undefined;
     }
 }
@@ -1881,51 +2040,6 @@ function inferSymphonyIdeaAffectedArea(input) {
     }
     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([
@@ -1937,32 +2051,29 @@ async function formatSymphonyStatus(interactive) {
     const workers = workersRead.items;
     const issues = issuesRead.items;
     const reports = reportsRead.items;
-    const projectionErrors = Array.from(new Set([
+    const controlStateErrors = 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 controlStateSources = new Set([workersRead.source, issuesRead.source, reportsRead.source]);
     const lines = [
         `Symphony is ${enabled ? 'on' : 'off'}.`,
         `Current chat peer: ${enabled ? 'Secretary' : 'worker/backend peer'}.`,
         `Open issues: ${issues.length}`,
         `Running workers: ${workers.length}`,
         `Recent reports: ${reports.length}`,
-        projectionErrors.length > 0
-            ? `Pod projection: unavailable (${formatSymphonyStatusError(projectionErrors[0])})`
-            : projectionSources.has('pod')
-                ? 'Pod projection: active.'
-                : 'Pod projection: local archive only.',
+        controlStateErrors.length > 0
+            ? `Pod control state: unavailable (${formatSymphonyStatusError(controlStateErrors[0])})`
+            : controlStateSources.has('pod')
+                ? 'Pod control state: active.'
+                : 'Pod control state: portable local archive mode.',
         'Skills: issue triage, existing issue lookup, create/update/ask decision, task split, worker dispatch, status/report tracking.',
         'Delegation target: AI Secretary must choose a Chat resource before dispatch.',
         'Allowed targets: personal AI contact chat or group chat.',
         'Thread role: concrete work timeline under the selected Chat.',
         'Session role: backend runtime lifecycle only.',
     ];
-    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)}`);
     }
@@ -2017,19 +2128,24 @@ async function withSymphonyStatusTimeout(interactive, label, task) {
     }
 }
 async function listOpenSymphonyIssues(interactive) {
-    const projectionRuntime = interactive?.__linxSymphonyPodProjectionRuntime;
-    let projectionError;
+    const controlRuntime = interactive?.__linxSymphonyPodProjectionRuntime;
     try {
-        if (projectionRuntime?.issueResource) {
-            const podIssues = await withSymphonyStatusTimeout(interactive, 'Symphony Pod issue status', listOpenSymphonyIssuesFromPod({ runtime: projectionRuntime }));
+        if (controlRuntime?.issueResource) {
+            const podIssues = await withSymphonyStatusTimeout(interactive, 'Symphony Pod issue status', listOpenSymphonyIssuesFromPod({ runtime: controlRuntime }));
             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.
+        return { items: [], source: 'none', error: error instanceof Error ? error.message : String(error) };
+    }
+    if (controlRuntime?.issueResource) {
+        return {
+            items: [],
+            source: 'none',
+            error: 'No active Pod session; Symphony control-plane state is Pod-authoritative.',
+        };
     }
     try {
         const issues = typeof interactive?.__linxListSymphonyIssues === 'function'
@@ -2038,26 +2154,31 @@ async function listOpenSymphonyIssues(interactive) {
         return {
             items: issues.filter((issue) => issue.status !== 'closed' && issue.status !== 'resolved'),
             source: 'local',
-            ...(projectionError ? { error: projectionError } : {}),
         };
     }
     catch {
-        return { items: [], source: 'none', ...(projectionError ? { error: projectionError } : {}) };
+        return { items: [], source: 'none' };
     }
 }
 async function listRunningSymphonyWorkers(interactive) {
-    const projectionRuntime = interactive?.__linxSymphonyPodProjectionRuntime;
-    let projectionError;
+    const controlRuntime = interactive?.__linxSymphonyPodProjectionRuntime;
     try {
-        if (projectionRuntime?.sessionResource) {
-            const podWorkers = await withSymphonyStatusTimeout(interactive, 'Symphony Pod worker status', listRunningSymphonyWorkersFromPod({ runtime: projectionRuntime }));
+        if (controlRuntime?.sessionResource) {
+            const podWorkers = await withSymphonyStatusTimeout(interactive, 'Symphony Pod worker status', listRunningSymphonyWorkersFromPod({ runtime: controlRuntime }));
             if (podWorkers) {
                 return { items: podWorkers, source: 'pod' };
             }
         }
     }
     catch (error) {
-        projectionError = error instanceof Error ? error.message : String(error);
+        return { items: [], source: 'none', error: error instanceof Error ? error.message : String(error) };
+    }
+    if (controlRuntime?.sessionResource) {
+        return {
+            items: [],
+            source: 'none',
+            error: 'No active Pod session; Symphony control-plane state is Pod-authoritative.',
+        };
     }
     try {
         if (typeof interactive?.__linxListSymphonySessions === 'function') {
@@ -2065,27 +2186,24 @@ async function listRunningSymphonyWorkers(interactive) {
             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 } : {}) };
+        return { items: [], source: 'none' };
     }
 }
 async function listRecentSymphonyReports(interactive) {
-    const projectionRuntime = interactive?.__linxSymphonyPodProjectionRuntime;
-    let projectionError;
+    const controlRuntime = interactive?.__linxSymphonyPodProjectionRuntime;
     try {
-        if (projectionRuntime?.deliveryResource) {
+        if (controlRuntime?.deliveryResource) {
             const podReports = await withSymphonyStatusTimeout(interactive, 'Symphony Pod report status', listRecentSymphonyReportsFromPod({
-                runtime: projectionRuntime,
+                runtime: controlRuntime,
                 limit: 5,
             }));
             if (podReports) {
@@ -2094,8 +2212,14 @@ async function listRecentSymphonyReports(interactive) {
         }
     }
     catch (error) {
-        projectionError = error instanceof Error ? error.message : String(error);
-        // Fall back to local no-Pod archive below.
+        return { items: [], source: 'none', error: error instanceof Error ? error.message : String(error) };
+    }
+    if (controlRuntime?.deliveryResource) {
+        return {
+            items: [],
+            source: 'none',
+            error: 'No active Pod session; Symphony control-plane state is Pod-authoritative.',
+        };
     }
     try {
         const sessions = typeof interactive?.__linxListSymphonySessions === 'function'
@@ -2106,11 +2230,10 @@ async function listRecentSymphonyReports(interactive) {
                 .filter((session) => session.status === 'completed' || session.status === 'failed')
                 .slice(0, 5),
             source: 'local',
-            ...(projectionError ? { error: projectionError } : {}),
         };
     }
     catch {
-        return { items: [], source: 'none', ...(projectionError ? { error: projectionError } : {}) };
+        return { items: [], source: 'none' };
     }
 }
 function formatSymphonyWorkerStatus(session) {
@@ -2433,19 +2556,37 @@ export function installLinxEscapeInterrupt(interactive) {
     let currentOnEscape = isLinxEscapeInterruptWrapper(initialOnEscape)
         ? undefined
         : initialOnEscape;
+    let lastIdleEscapeTime = 0;
     const linxEscapeInterrupt = function linxEscapeInterrupt() {
         const session = interactive?.session;
         if (handBackAutoControlOnInterrupt(interactive)) {
+            lastIdleEscapeTime = 0;
             return;
         }
         if (session?.isBashRunning && typeof session.abortBash === 'function') {
+            lastIdleEscapeTime = 0;
             void session.abortBash();
             return;
         }
         if (isLinxSessionRunning(interactive) && typeof session?.abort === 'function') {
+            lastIdleEscapeTime = 0;
             void session.abort();
             return;
         }
+        if (shouldHandleLinxIdleDoubleEscape(interactive)) {
+            const now = Date.now();
+            if (now - lastIdleEscapeTime < 500) {
+                lastIdleEscapeTime = 0;
+                void openInteractiveRewindFromEscape(interactive);
+            }
+            else {
+                lastIdleEscapeTime = now;
+                interactive?.showStatus?.('Press Escape again to rewind this session.');
+                interactive?.ui?.requestRender?.();
+            }
+            return;
+        }
+        lastIdleEscapeTime = 0;
         currentOnEscape?.call(editor);
     };
     Object.defineProperty(linxEscapeInterrupt, '__linxEscapeInterruptWrapper', {
@@ -2466,6 +2607,21 @@ export function installLinxEscapeInterrupt(interactive) {
     installLinxClearInterrupt(interactive, editor);
     editor.__linxEscapeInterruptInstalled = true;
 }
+function shouldHandleLinxIdleDoubleEscape(interactive) {
+    if (typeof interactive?.editor?.getText !== 'function') {
+        return false;
+    }
+    const text = String(interactive.editor.getText() ?? '');
+    return text.trim().length === 0;
+}
+async function openInteractiveRewindFromEscape(interactive) {
+    try {
+        await handleInteractiveRewindSelector(interactive, interactive?.runtime);
+    }
+    catch (error) {
+        interactive?.showError?.(error instanceof Error ? error.message : String(error));
+    }
+}
 function isLinxEscapeInterruptWrapper(value) {
     return typeof value === 'function'
         && value.__linxEscapeInterruptWrapper === true;
@@ -2711,12 +2867,38 @@ function patchPiFooter() {
         if (Array.isArray(lines) && lines.length > 1 && typeof lines[1] === 'string') {
             const session = this.session;
             const autoCompactEnabled = this.autoCompactEnabled !== false;
-            lines[1] = buildLinxFooterStatusLine(session, width, autoCompactEnabled);
+            const footerData = this.footerData;
+            const modePrefix = buildLinxFooterModePrefix();
+            const modeLen = visibleWidth(modePrefix);
+            const bulletLen = modeLen > 0 ? 3 : 0;
+            const statusWidth = Math.max(0, width - modeLen - bulletLen);
+            lines[1] = buildLinxFooterStatusLine({
+                session,
+                width: statusWidth,
+                autoCompactEnabled,
+                footerData: footerData,
+            });
+            if (modePrefix) {
+                lines[1] = modePrefix + ' • ' + lines[1];
+            }
         }
         return lines;
     };
     footerPatched = true;
 }
+function buildLinxFooterModePrefix() {
+    if (!_linxFooterInteractive)
+        return '';
+    const autoOn = _linxFooterInteractive.__autoEnabled === true;
+    const symphonyOn = _linxFooterInteractive.__linxSymphonyModeEnabled === true;
+    if (!autoOn && !symphonyOn)
+        return '';
+    if (autoOn && symphonyOn)
+        return 'Symphony · Auto';
+    if (autoOn)
+        return 'Auto';
+    return 'Symphony';
+}
 export function patchPiAssistantMessageRendering() {
     if (assistantMessagePatched) {
         return;
@@ -2747,91 +2929,4 @@ function isLinxHiddenAssistantContentPart(part) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
-function buildLinxFooterStatusLine(session, width, autoCompactEnabled) {
-    const usage = calculateSessionUsage(session);
-    const state = session?.state ?? {};
-    const model = state.model ?? {};
-    const parts = [];
-    if (usage.input > 0) {
-        parts.push(`↑${formatTokenCount(usage.input)}`);
-    }
-    if (usage.output > 0) {
-        parts.push(`↓${formatTokenCount(usage.output)}`);
-    }
-    parts.push(formatContextUsage(session, model, autoCompactEnabled));
-    if (usage.cacheRate !== null) {
-        parts.push(`cache ${usage.cacheRate}%`);
-    }
-    parts.push(typeof model.id === 'string' && model.id ? model.id : 'no-model');
-    if (model.reasoning) {
-        const thinkingLevel = typeof state.thinkingLevel === 'string' && state.thinkingLevel
-            ? state.thinkingLevel
-            : 'off';
-        parts.push(thinkingLevel === 'off' ? 'thinking off' : thinkingLevel);
-    }
-    return fitFooterLine(parts.join(' • '), width);
-}
-function fitFooterLine(line, width) {
-    const truncated = truncateToWidth(line, width);
-    const visible = visibleWidth(truncated);
-    const padded = visible < width ? `${truncated}${' '.repeat(width - visible)}` : truncated;
-    return `\x1b[2m${padded}\x1b[22m`;
-}
-function calculateSessionUsage(session) {
-    const entries = session?.sessionManager?.getEntries?.();
-    if (!Array.isArray(entries)) {
-        return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cacheRate: null };
-    }
-    let input = 0;
-    let output = 0;
-    let cacheRead = 0;
-    let cacheWrite = 0;
-    for (const entry of entries) {
-        const message = entry?.type === 'message' ? entry.message : undefined;
-        if (message?.role !== 'assistant' || !message.usage) {
-            continue;
-        }
-        input += safeTokenCount(message.usage.input);
-        output += safeTokenCount(message.usage.output);
-        cacheRead += safeTokenCount(message.usage.cacheRead);
-        cacheWrite += safeTokenCount(message.usage.cacheWrite);
-    }
-    const totalPromptTokens = input + cacheRead + cacheWrite;
-    if (totalPromptTokens <= 0) {
-        return { input, output, cacheRead, cacheWrite, cacheRate: null };
-    }
-    return {
-        input,
-        output,
-        cacheRead,
-        cacheWrite,
-        cacheRate: Math.round((cacheRead / totalPromptTokens) * 100),
-    };
-}
-function formatContextUsage(session, model, autoCompactEnabled) {
-    const contextUsage = session?.getContextUsage?.();
-    const contextWindow = safeTokenCount(contextUsage?.contextWindow) || safeTokenCount(model.contextWindow);
-    const percent = typeof contextUsage?.percent === 'number' && Number.isFinite(contextUsage.percent)
-        ? `${contextUsage.percent.toFixed(1)}%`
-        : '?';
-    return `${percent}/${formatTokenCount(contextWindow)}${autoCompactEnabled ? ' (auto)' : ''}`;
-}
-function formatTokenCount(count) {
-    if (count < 1000) {
-        return count.toString();
-    }
-    if (count < 10000) {
-        return `${(count / 1000).toFixed(1)}k`;
-    }
-    if (count < 1000000) {
-        return `${Math.round(count / 1000)}k`;
-    }
-    if (count < 10000000) {
-        return `${(count / 1000000).toFixed(1)}M`;
-    }
-    return `${Math.round(count / 1000000)}M`;
-}
-function safeTokenCount(value) {
-    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : 0;
-}
 //# sourceMappingURL=interactive.js.map