@undefineds.co/linx 0.3.20 → 0.3.23

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

@@ -8,7 +8,7 @@ import { listArchivedAutoModeSessions, runAutoMode } from '../auto-mode/runner.j
 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 { applyLinxInteractiveBranding, checkAndShowLinxUpdate, requestLinxCloudLogin } from './branding.js';
 import { installPodStatusOutputFilter } from './pod-status-output.js';
 import { createPodBackedExtensionUiContext } from './pod-approval.js';
 import { DEFAULT_SECRETARY_CHAT_ID, secretaryChatUri, secretaryThreadUri } from './pod-mirror-mapping.js';
@@ -16,8 +16,8 @@ import { getSecretaryAutoInputController } from './auto-input-controller.js';
 import { createSymphonyIdeaRecord, listSymphonyIssues, listSymphonySessions, } from '../symphony/archive.js';
 import { listOpenSymphonyIssuesFromPod, listRecentSymphonyReportsFromPod, listRunningSymphonyWorkersFromPod, mirrorSymphonyProjectionJsonLdFromPod, persistSymphonyIdeaToPod, persistSymphonyControlStateToPod, } from '../symphony/pod-projection.js';
 import { getSessionControlManager, installSessionControlRuntimeEventBridge, } from './session-control.js';
-import { buildLinxTuiStatusLine, calculateSessionUsage, DEFAULT_STATUS_LINE_TOKENS, formatTokenCount, LINX_STATUS_LINE_TOKEN_NAMES, parseLinxStatusLineColorArg, parseLinxStatusLineTokenArgs, readLinxStatusLineConfig, resetLinxStatusLineConfig, writeLinxStatusLineConfigPatch, } from '../linx-status-line.js';
-let statusLinePatched = false;
+import { buildLinxFooterStatusLine, calculateSessionUsage, DEFAULT_STATUS_LINE_TOKENS, formatTokenCount, LINX_STATUS_LINE_TOKEN_NAMES, parseLinxStatusLineColorArg, parseLinxStatusLineTokenArgs, readLinxStatusLineConfig, resetLinxStatusLineConfig, writeLinxStatusLineConfigPatch, } from '../linx-status-line.js';
+let footerPatched = false;
 let assistantMessagePatched = false;
 let linxResumeOutputStyleRestore = null;
 const BACKEND_OWNED_SLASH_COMMANDS = new Set([
@@ -29,7 +29,6 @@ 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 = [
-    'mode',
     'model-with-reasoning',
     'git-branch',
     'context-remaining',
@@ -38,16 +37,20 @@ const CODEX_STYLE_STATUS_LINE_TOKENS = [
     'current-dir',
 ];
 const COMPACT_STATUS_LINE_TOKENS = [
-    'mode',
     'model-with-reasoning',
     'context-remaining',
     'current-dir',
 ];
-/** Module-level reference to interactive for status line mode state (set during bootstrap). */
-let _linxStatusLineInteractive = null;
+const STATUS_LINE_CODEX_PRESET_OPTION = 'Preset: Codex-style';
+const STATUS_LINE_COMPACT_PRESET_OPTION = 'Preset: Compact';
+const STATUS_LINE_TOGGLE_COLORS_OPTION = 'Toggle colors';
+const STATUS_LINE_RESET_OPTION = 'Reset to default';
+const STATUS_LINE_DONE_OPTION = 'Done';
+/** Module-level reference to interactive for footer mode state (set during bootstrap). */
+let _linxFooterInteractive = null;
 export function bootstrapLinxInteractiveMode(runtime, options = {}) {
     installLinxResumeOutputStyle();
-    patchPiStatusLine();
+    patchPiFooter();
     patchPiAssistantMessageRendering();
     const sessionCwd = runtime?.cwd || process.cwd();
     ensureInteractiveRuntimeHost(runtime);
@@ -55,7 +58,7 @@ export function bootstrapLinxInteractiveMode(runtime, options = {}) {
     interactive.runtime = runtime;
     interactive.__autoEnabled = runtime?.autoEnabled === true;
     interactive.__linxSymphonyModeEnabled = runtime?.symphonyEnabled === true;
-    _linxStatusLineInteractive = interactive;
+    _linxFooterInteractive = interactive;
     if (options.onSymphonyControlChange) {
         ;
         interactive.__linxOnSymphonyControlChange = options.onSymphonyControlChange;
@@ -556,6 +559,9 @@ function parseLinxGlobalCommand(input) {
             : input.slice('/status-line'.length).trim();
         return { action: 'statusline', args: splitInteractiveCommandArgs(body) };
     }
+    if (input === '/update' || input === '/upgrade') {
+        return { action: 'update' };
+    }
     if (input === '/rewind') {
         return { action: 'rewind-select' };
     }
@@ -681,6 +687,10 @@ async function handleLinxGlobalCommand(interactive, runtime, command) {
         await handleInteractiveStatusLineCommand(interactive, command.args);
         return;
     }
+    if (command.action === 'update') {
+        await checkAndShowLinxUpdate(interactive, { manual: true });
+        return;
+    }
     if (command.action === 'rewind-select') {
         await handleInteractiveRewindSelector(interactive, runtime);
         return;
@@ -697,53 +707,133 @@ async function handleInteractiveStatusLineCommand(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?.();
+    if (typeof interactive.showSelector === 'function') {
+        await showInteractiveStatusLineMultiSelect(interactive);
         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.',
-        });
+    if (typeof interactive.showExtensionSelector === 'function') {
+        await showInteractiveStatusLineFallbackSelector(interactive);
         return;
     }
-    if (choice === 'Use compact preset') {
-        writeInteractiveStatusLineConfig(interactive, {
-            statusLine: COMPACT_STATUS_LINE_TOKENS,
-            message: 'Status line set to compact preset.',
-        });
+    {
+        interactive.showStatus?.(`${summary} · Use /statusline set <tokens...>, /statusline tokens, /statusline colors <on|off>, or /statusline reset.`);
+        interactive.ui?.requestRender?.();
         return;
     }
-    if (choice === 'Toggle colors') {
-        const current = readLinxStatusLineConfig();
-        writeInteractiveStatusLineConfig(interactive, {
-            statusLineUseColors: !current.useColors,
-            message: `Status line colors ${current.useColors ? 'disabled' : 'enabled'}.`,
-        });
-        return;
+}
+async function showInteractiveStatusLineFallbackSelector(interactive) {
+    while (true) {
+        const currentSummary = formatInteractiveStatusLineSummary();
+        const config = readLinxStatusLineConfig();
+        const options = buildInteractiveStatusLineOptions(config);
+        const choice = await interactive.showExtensionSelector(`Status line\n${currentSummary}`, options);
+        if (!choice || choice === STATUS_LINE_DONE_OPTION) {
+            return;
+        }
+        const token = parseInteractiveStatusLineTokenChoice(choice);
+        if (token) {
+            toggleInteractiveStatusLineToken(interactive, token);
+            continue;
+        }
+        if (choice === STATUS_LINE_CODEX_PRESET_OPTION) {
+            writeInteractiveStatusLineConfig(interactive, {
+                statusLine: CODEX_STYLE_STATUS_LINE_TOKENS,
+                message: 'Status line set to Codex-style preset.',
+            });
+            continue;
+        }
+        if (choice === STATUS_LINE_COMPACT_PRESET_OPTION) {
+            writeInteractiveStatusLineConfig(interactive, {
+                statusLine: COMPACT_STATUS_LINE_TOKENS,
+                message: 'Status line set to compact preset.',
+            });
+            continue;
+        }
+        if (choice === STATUS_LINE_TOGGLE_COLORS_OPTION) {
+            const current = readLinxStatusLineConfig();
+            writeInteractiveStatusLineConfig(interactive, {
+                statusLineUseColors: !current.useColors,
+                message: `Status line colors ${current.useColors ? 'disabled' : 'enabled'}.`,
+            });
+            continue;
+        }
+        if (choice === STATUS_LINE_RESET_OPTION) {
+            resetLinxStatusLineConfig();
+            finishInteractiveStatusLineUpdate(interactive, `Status line reset to default: ${DEFAULT_STATUS_LINE_TOKENS.join(', ')}`);
+        }
     }
-    if (choice === 'Show available tokens') {
-        showInteractiveStatusLineTokens(interactive);
-        return;
+}
+async function showInteractiveStatusLineMultiSelect(interactive) {
+    await new Promise((resolvePromise, rejectPromise) => {
+        let resolved = false;
+        const resolveOnce = () => {
+            if (!resolved) {
+                resolved = true;
+                resolvePromise();
+            }
+        };
+        try {
+            interactive.showSelector((done) => {
+                const close = () => {
+                    done();
+                    resolveOnce();
+                };
+                const selector = new LinxStatusLineSelectorComponent(readLinxStatusLineConfig(), ({ tokens, useColors }) => {
+                    writeInteractiveStatusLineConfig(interactive, {
+                        statusLine: tokens,
+                        statusLineUseColors: useColors,
+                        message: `Status line updated: ${tokens.join(', ')}`,
+                    });
+                    close();
+                }, () => {
+                    close();
+                    interactive.ui?.requestRender?.();
+                });
+                return { component: selector, focus: selector.getList() };
+            });
+        }
+        catch (error) {
+            rejectPromise(error);
+        }
+    });
+}
+function buildInteractiveStatusLineOptions(config = readLinxStatusLineConfig()) {
+    const enabled = new Set(config.tokens);
+    return [
+        ...LINX_STATUS_LINE_TOKEN_NAMES.map((token) => `${enabled.has(token) ? '✓' : '○'} ${token}`),
+        STATUS_LINE_CODEX_PRESET_OPTION,
+        STATUS_LINE_COMPACT_PRESET_OPTION,
+        STATUS_LINE_TOGGLE_COLORS_OPTION,
+        STATUS_LINE_RESET_OPTION,
+        STATUS_LINE_DONE_OPTION,
+    ];
+}
+function parseInteractiveStatusLineTokenChoice(choice) {
+    if (typeof choice !== 'string') {
+        return null;
     }
-    if (choice === 'Reset to default') {
-        resetLinxStatusLineConfig();
-        finishInteractiveStatusLineUpdate(interactive, `Status line reset to default: ${DEFAULT_STATUS_LINE_TOKENS.join(', ')}`);
-        return;
+    const token = choice.replace(/^[✓○]\s*/u, '').trim();
+    if (!token) {
+        return null;
     }
-    if (choice === 'Configure tokens manually') {
-        await promptInteractiveStatusLineTokens(interactive);
+    return LINX_STATUS_LINE_TOKEN_NAMES.includes(token)
+        ? token
+        : null;
+}
+function toggleInteractiveStatusLineToken(interactive, token) {
+    const current = readLinxStatusLineConfig().tokens;
+    const exists = current.includes(token);
+    if (exists && current.length <= 1) {
+        interactive.showError?.('Status line needs at least one item.');
+        return;
     }
+    const next = exists
+        ? current.filter((item) => item !== token)
+        : [...current, token];
+    writeInteractiveStatusLineConfig(interactive, {
+        statusLine: next,
+        message: `Status line ${exists ? 'removed' : 'added'}: ${token}`,
+    });
 }
 function handleInteractiveStatusLineArgs(interactive, args) {
     const action = args[0]?.toLowerCase();
@@ -781,20 +871,6 @@ function handleInteractiveStatusLineArgs(interactive, args) {
         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 } : {}),
@@ -891,15 +967,14 @@ async function handleInteractiveRewindTurnsCommand(interactive, runtime, turns)
     interactive.ui?.requestRender?.();
 }
 async function rewindSessionManagerBeforeUserEntry(interactive, runtime, session, sessionManager, entryId) {
-    const previousBranch = getActiveSessionBranch(sessionManager);
-    const entry = previousBranch.find((candidate) => String(candidate?.id) === entryId);
-    if (!entry) {
-        throw new Error('Cannot rewind: selected message is no longer in the active branch. Reopen /rewind and choose a current user turn.');
-    }
-    if (entry.type !== 'message' || entry.message?.role !== 'user') {
-        throw new Error('Cannot rewind: selected message is not a user turn.');
+    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;
@@ -1162,6 +1237,178 @@ function refreshInteractiveTranscriptFromSessionManager(interactive) {
         interactive?.showWarning?.(`Rewind transcript refresh failed: ${message}`);
     }
 }
+class LinxMultiSelectList {
+    getRows;
+    onToggle;
+    onAction;
+    onCancel;
+    selectedIndex = 0;
+    constructor(getRows, onToggle, onAction, onCancel) {
+        this.getRows = getRows;
+        this.onToggle = onToggle;
+        this.onAction = onAction;
+        this.onCancel = onCancel;
+    }
+    invalidate() {
+        // No cached render state.
+    }
+    render(width) {
+        const rows = this.normalizedRows();
+        if (rows.length === 0) {
+            return ['  No options'];
+        }
+        const lines = [];
+        for (let index = 0; index < rows.length; index += 1) {
+            const row = rows[index];
+            const cursor = index === this.selectedIndex ? '> ' : '  ';
+            const label = row.kind === 'item'
+                ? `${row.selected ? '✓' : '○'} ${row.label}`
+                : row.label;
+            lines.push(`${cursor}${truncateToWidth(label, Math.max(1, width - 2))}`);
+            if (row.description) {
+                lines.push(`  ${truncateToWidth(row.description, Math.max(1, width - 2))}`);
+            }
+        }
+        lines.push('');
+        lines.push('↑↓ navigate  Enter toggles items/actions  Escape/Ctrl+C cancel');
+        return lines;
+    }
+    handleInput(keyData) {
+        const rows = this.normalizedRows();
+        if (rows.length === 0) {
+            return;
+        }
+        const keybindings = getKeybindings();
+        if (keybindings.matches(keyData, 'tui.select.up')) {
+            this.selectedIndex = this.selectedIndex === 0 ? rows.length - 1 : this.selectedIndex - 1;
+            return;
+        }
+        if (keybindings.matches(keyData, 'tui.select.down')) {
+            this.selectedIndex = this.selectedIndex === rows.length - 1 ? 0 : this.selectedIndex + 1;
+            return;
+        }
+        if (keybindings.matches(keyData, 'tui.select.confirm')) {
+            const selected = rows[this.selectedIndex];
+            if (selected?.kind === 'item') {
+                this.onToggle(selected.id);
+            }
+            else if (selected?.kind === 'action') {
+                this.onAction(selected.id);
+            }
+            return;
+        }
+        if (keybindings.matches(keyData, 'tui.select.cancel')) {
+            this.onCancel();
+        }
+    }
+    normalizedRows() {
+        const rows = this.getRows();
+        if (this.selectedIndex >= rows.length) {
+            this.selectedIndex = Math.max(0, rows.length - 1);
+        }
+        return rows;
+    }
+}
+class LinxStatusLineSelectorComponent extends Container {
+    list;
+    draftTokens;
+    draftUseColors;
+    notice = null;
+    constructor(config, onCommit, onCancel) {
+        super();
+        this.draftTokens = [...config.tokens];
+        this.draftUseColors = config.useColors;
+        this.addChild(new Spacer(1));
+        this.addChild(new Text('Status line', 1, 0));
+        this.addChild(new Text('Select the items that appear in the bottom TUI status line.', 1, 0));
+        this.addChild(new Text(`Current source: tokens ${config.tokenSource}, colors ${config.colorSource}.`, 1, 0));
+        this.addChild(new Spacer(1));
+        this.list = new LinxMultiSelectList(() => this.rows(), (id) => this.toggleToken(id), (id) => this.handleAction(id, onCommit), onCancel);
+        this.addChild(this.list);
+    }
+    getList() {
+        return this.list;
+    }
+    rows() {
+        const enabled = new Set(this.draftTokens);
+        const rows = LINX_STATUS_LINE_TOKEN_NAMES.map((token) => ({
+            kind: 'item',
+            id: token,
+            label: token,
+            selected: enabled.has(token),
+        }));
+        rows.push({
+            kind: 'action',
+            id: 'preset-codex',
+            label: STATUS_LINE_CODEX_PRESET_OPTION,
+            description: CODEX_STYLE_STATUS_LINE_TOKENS.join(', '),
+        }, {
+            kind: 'action',
+            id: 'preset-compact',
+            label: STATUS_LINE_COMPACT_PRESET_OPTION,
+            description: COMPACT_STATUS_LINE_TOKENS.join(', '),
+        }, {
+            kind: 'action',
+            id: 'toggle-colors',
+            label: `${STATUS_LINE_TOGGLE_COLORS_OPTION}: ${this.draftUseColors ? 'on' : 'off'}`,
+        }, {
+            kind: 'action',
+            id: 'reset',
+            label: STATUS_LINE_RESET_OPTION,
+            description: DEFAULT_STATUS_LINE_TOKENS.join(', '),
+        }, {
+            kind: 'action',
+            id: 'done',
+            label: STATUS_LINE_DONE_OPTION,
+            description: this.notice ?? 'Save changes and close.',
+        });
+        return rows;
+    }
+    toggleToken(id) {
+        const token = id;
+        if (!LINX_STATUS_LINE_TOKEN_NAMES.includes(token)) {
+            return;
+        }
+        const exists = this.draftTokens.includes(token);
+        if (exists && this.draftTokens.length <= 1) {
+            this.notice = 'Status line needs at least one item.';
+            return;
+        }
+        this.draftTokens = exists
+            ? this.draftTokens.filter((item) => item !== token)
+            : [...this.draftTokens, token];
+        this.notice = null;
+    }
+    handleAction(id, onCommit) {
+        if (id === 'preset-codex') {
+            this.draftTokens = [...CODEX_STYLE_STATUS_LINE_TOKENS];
+            this.notice = 'Draft changed to Codex-style preset.';
+            return;
+        }
+        if (id === 'preset-compact') {
+            this.draftTokens = [...COMPACT_STATUS_LINE_TOKENS];
+            this.notice = 'Draft changed to compact preset.';
+            return;
+        }
+        if (id === 'toggle-colors') {
+            this.draftUseColors = !this.draftUseColors;
+            this.notice = `Draft colors ${this.draftUseColors ? 'enabled' : 'disabled'}.`;
+            return;
+        }
+        if (id === 'reset') {
+            this.draftTokens = [...DEFAULT_STATUS_LINE_TOKENS];
+            this.draftUseColors = true;
+            this.notice = 'Draft reset to default.';
+            return;
+        }
+        if (id === 'done') {
+            onCommit({
+                tokens: this.draftTokens,
+                useColors: this.draftUseColors,
+            });
+        }
+    }
+}
 function collectRewindUserMessages(_session, sessionManager) {
     return getActiveSessionBranch(sessionManager)
         .filter((entry) => entry?.type === 'message' && entry.message?.role === 'user')
@@ -1523,6 +1770,10 @@ const LINX_INTERACTIVE_SLASH_COMMANDS = [
             { value: 'reset', description: 'Restore default status line tokens' },
         ]),
     },
+    {
+        name: 'update',
+        description: 'check for a LinX CLI update and install from the TUI',
+    },
     {
         name: 'ai',
         argumentHint: 'connect <provider>',
@@ -1673,12 +1924,7 @@ function renderSymphonySecretaryProjection(input) {
         '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, update the Symphony control state before describing the visible handoff result.',
-        'When you need to inspect or mutate Symphony Pod resources from the AI side, use the xpod CLI as the direct Pod tool surface.',
-        'Prefer model-backed xpod obj commands for Idea, Issue, Task, Delivery, Run, RunStep, Report, Evidence, ApprovalRequest, InputRequest, and InboxNotification resources.',
-        'xpod uses the same Solid authority as LinX inside the Agent Runtime; do not ask the model to handle tokens or client secrets.',
-        'Before mutating Pod resources from tools, verify xpod auth status/whoami reports the same acting WebID/Pod root as the LinX session; stop on mismatch.',
-        'Do not hand-patch TTL or guess Pod paths for modeled product resources; use xpod/model descriptors or inspect existing links first.',
+        'If real delegation is needed, summarize the visible handoff result briefly after updating control state.',
         '',
         'User message:',
         input,
@@ -1727,9 +1973,8 @@ async function dispatchSymphonyWorkerFromInteractive(interactive, objective, sou
         target: {
             source: 'active-session',
             backend,
-            contact: backend,
-            agent: backend,
-            label: backend,
+            agent: `${backend}-worker`,
+            label: `${backend} worker`,
             ...(source?.chat ? { chat: source.chat } : {}),
             ...(source?.thread ? { thread: source.thread } : {}),
         },
@@ -2078,8 +2323,8 @@ async function formatSymphonyStatus(interactive) {
                 ? '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 chooses a Contact-backed worker target before dispatch.',
-        'Allowed targets: personal AI contact chat or group chat; Chat participants must reference Contacts.',
+        '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.',
     ];
@@ -2247,7 +2492,6 @@ async function listRecentSymphonyReports(interactive) {
 }
 function formatSymphonyWorkerStatus(session) {
     const target = session.target?.label
-        ?? session.target?.contact
         ?? session.target?.agent
         ?? session.target?.chat
         ?? session.backend;
@@ -2261,10 +2505,8 @@ function formatSymphonyWorkerStatus(session) {
 function formatSymphonyReportStatus(report) {
     const status = report.status;
     const reportRecord = report;
-    const target = reportRecord.target?.label
-        ?? reportRecord.contact
-        ?? reportRecord.target?.contact
-        ?? reportRecord.agent
+    const target = reportRecord.agent
+        ?? reportRecord.target?.label
         ?? reportRecord.target?.agent
         ?? report.backend;
     const title = 'summary' in report && report.summary
@@ -2869,42 +3111,40 @@ function isPotentialPiResumeOutput(text) {
 function stripAnsi(text) {
     return text.replace(/\x1b\[[0-9;]*m/gu, '');
 }
-function patchPiStatusLine() {
-    if (statusLinePatched) {
+function patchPiFooter() {
+    if (footerPatched) {
         return;
     }
     const originalRender = FooterComponent.prototype.render;
     FooterComponent.prototype.render = function patchedRender(width) {
         const lines = originalRender.call(this, width);
-        if (Array.isArray(lines)) {
+        if (Array.isArray(lines) && lines.length > 1 && typeof lines[1] === 'string') {
             const session = this.session;
             const autoCompactEnabled = this.autoCompactEnabled !== false;
             const footerData = this.footerData;
-            const statusLine = buildLinxTuiStatusLine({
+            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,
+                width: statusWidth,
                 autoCompactEnabled,
                 footerData: footerData,
-                modeLabel: buildLinxStatusLineModeLabel(),
             });
-            // Pi's footer renders cwd, stats, then optional extension notices.  LinX
-            // owns only the logical TUI status line, so replace Pi's stats line and
-            // append the configurable status line after notices to keep it the
-            // bottom-most line.
-            if (lines.length > 1 && typeof lines[1] === 'string') {
-                lines.splice(1, 1);
+            if (modePrefix) {
+                lines[1] = modePrefix + ' • ' + lines[1];
             }
-            lines.push(statusLine);
         }
         return lines;
     };
-    statusLinePatched = true;
+    footerPatched = true;
 }
-function buildLinxStatusLineModeLabel() {
-    if (!_linxStatusLineInteractive)
+function buildLinxFooterModePrefix() {
+    if (!_linxFooterInteractive)
         return '';
-    const autoOn = _linxStatusLineInteractive.__autoEnabled === true;
-    const symphonyOn = _linxStatusLineInteractive.__linxSymphonyModeEnabled === true;
+    const autoOn = _linxFooterInteractive.__autoEnabled === true;
+    const symphonyOn = _linxFooterInteractive.__linxSymphonyModeEnabled === true;
     if (!autoOn && !symphonyOn)
         return '';
     if (autoOn && symphonyOn)