@undefineds.co/linx 0.3.5 → 0.3.8

package/dist/index.js

@@ -1,26 +1,30 @@
 #!/usr/bin/env node
 import './lib/node-warning-filter.js';
 import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import { aiCommand } from './lib/ai-command.js';
 import { resolveAccountBaseUrl } from './lib/account-api.js';
 import { loadCredentials } from './lib/credentials-store.js';
 import { loginCommand, logoutCommand, whoamiCommand } from './lib/login-command.js';
-import { DefaultPackageManager, SettingsManager, runPrintMode } from '@mariozechner/pi-coding-agent';
+import { DefaultPackageManager, SettingsManager, SessionSelectorComponent, initTheme, runPrintMode } from '@earendil-works/pi-coding-agent';
+import { ProcessTerminal, TUI } from '@earendil-works/pi-tui';
 import { promptText } from './lib/prompt.js';
 import { buildAutoModeOptions, isAutoModeRequest, runAutoModeCommand, } from './lib/auto-mode-command.js';
-import { formatAutoModeSessionSummary, listArchivedAutoModeSessions, loadArchivedAutoModeSession, resumeAutoModeSession, } from './lib/auto-mode/index.js';
-import { symphonyCommand } from './lib/symphony-command.js';
 import { resolveRuntimeTarget } from './lib/runtime-target.js';
 import { createCodexNativeProxy } from './lib/codex-plugin/index.js';
-import { bootstrapPiInteractiveMode, createPiRuntimeAdapter, resolveLinxInteractiveLoginReason, resolveLinxStartupLoginPromptDecision } from './lib/pi-adapter/index.js';
-import { isOidcLoginExpiredError } from './lib/oidc-auth.js';
-import { createPodDataSession } from './lib/pod-data-session.js';
+import { bootstrapLinxInteractiveMode, createLinxRuntimeAdapter, resolveLinxInteractiveLoginReason, resolveLinxStartupLoginPromptDecision, } from './lib/pi-adapter/index.js';
+import { clearDefaultPodDataSession, createPodDataSession, getDefaultPodDataSession } from './lib/pod-data-session.js';
 import { DEFAULT_LINX_CLOUD_MODEL_ID, FALLBACK_LINX_CLOUD_MODEL_IDS } from './lib/default-model.js';
-import { createLinxPiSessionManager, formatLinxPiSessionSummary, listLinxPiSessions, resolveLinxPiSession, } from './lib/pi-adapter/session.js';
+import { createLinxPiSessionManager, listLinxPiSessions, } from './lib/pi-adapter/session.js';
 import { LinxPiPodMirror } from './lib/pi-adapter/pod-mirror.js';
+import { listPendingPiPodMirrorSync, retryPendingPiPodMirrorSync } from './lib/pi-adapter/sync-recovery.js';
 import { LINX_AGENT_DIR } from './lib/pi-adapter/branding.js';
+import { createFileSyncCheckpointStore } from './lib/sync-checkpoint-store.js';
+import { deriveLinxPiStartupControlState, hydrateLinxPiControlState } from './lib/pi-adapter/control-state.js';
+import { drizzle, solidResources } from './lib/models.js';
+import { formatLinxCliErrorMessage } from './lib/linx-cloud-errors.js';
 function readPackageVersion() {
     try {
         const raw = readFileSync(new URL('../package.json', import.meta.url), 'utf-8');
@@ -77,11 +81,10 @@ async function resolveContext(urlOverride) {
         issuerUrl: podSession.credentials.url,
         runtimeUrlOverride: urlOverride,
     });
-    const apiKey = await resolvePodRuntimeAuthToken(podSession);
     const session = podSession.solidSession;
     await runtime.initPodData(session);
     const chatId = await runtime.getOrCreateDefaultChat(session);
-    return { runtimeUrl: target.runtimeUrl, apiKey, session, podSession, chatId, runtime };
+    return { runtimeUrl: target.runtimeUrl, authFetch: podSession.runtimeFetch, session, podSession, chatId, runtime };
 }
 async function resolveRuntimeAuthContext(urlOverride) {
     const runtime = await loadChatRuntime();
@@ -90,10 +93,9 @@ async function resolveRuntimeAuthContext(urlOverride) {
         issuerUrl: podSession.credentials.url,
         runtimeUrlOverride: urlOverride,
     });
-    const apiKey = await resolvePodRuntimeAuthToken(podSession);
     return {
         runtimeUrl: target.runtimeUrl,
-        apiKey,
+        authFetch: podSession.runtimeFetch,
         session: podSession.solidSession,
         podSession,
         runtime,
@@ -109,43 +111,76 @@ async function createLinxPodDataSession() {
     }
     return podSession;
 }
-async function resolvePodRuntimeAuthToken(podSession) {
-    try {
-        return await podSession.getRuntimeAuthToken();
-    }
-    catch (error) {
-        if (isOidcLoginExpiredError(error)) {
-            throw new Error('LinX Cloud login expired. Run `linx login` to re-authorize.');
-        }
-        throw error;
+async function resolveStartupLinxPodDataSession() {
+    if (!loadCredentials()) {
+        return null;
     }
+    return createLinxPodDataSession();
 }
 async function runSingleTurn(options) {
     const { ctx, threadId, model, prompt } = options;
-    const history = await ctx.runtime.loadMessages(ctx.session, threadId);
-    await ctx.runtime.saveUserMessage(ctx.session, ctx.chatId, threadId, prompt);
+    const history = await tryLoadMessages(ctx, threadId);
     const reply = await ctx.runtime.createRemoteCompletion({
         runtimeUrl: ctx.runtimeUrl,
-        apiKey: ctx.apiKey,
+        authFetch: ctx.authFetch,
         model,
         messages: [...ctx.runtime.toOpenAiMessages(history), { role: 'user', content: prompt }],
     });
     const replyText = typeof reply === 'string' ? reply : reply.content ?? '';
-    await ctx.runtime.saveAssistantMessage(ctx.session, ctx.chatId, threadId, replyText);
     process.stdout.write(`\n${replyText}\n\n`);
+    await persistSingleTurnBestEffort(ctx, threadId, prompt, replyText);
+}
+async function tryLoadMessages(ctx, threadId) {
+    try {
+        return await ctx.runtime.loadMessages(ctx.session, threadId);
+    }
+    catch (error) {
+        process.stderr.write(`Warning: failed to load Pod chat history; continuing without history: ${formatLinxCliErrorMessage(error)}\n`);
+        return [];
+    }
+}
+async function persistSingleTurnBestEffort(ctx, threadId, prompt, replyText) {
+    try {
+        await ctx.runtime.saveUserMessage(ctx.session, ctx.chatId, threadId, prompt);
+        await ctx.runtime.saveAssistantMessage(ctx.session, ctx.chatId, threadId, replyText);
+    }
+    catch (error) {
+        process.stderr.write(`Warning: failed to persist Pod chat turn: ${formatLinxCliErrorMessage(error)}\n`);
+    }
 }
 async function resolveThreadId(options) {
-    const { ctx, continueMode, explicitThreadId, workspace } = options;
+    const { ctx, continueMode, explicitThreadId, workspace, bestEffort } = options;
     if (explicitThreadId) {
         return explicitThreadId;
     }
     if (continueMode) {
-        const latest = await ctx.runtime.getLatestThreadId(ctx.session, ctx.chatId);
+        const latest = bestEffort
+            ? await tryGetLatestThreadId(ctx)
+            : await ctx.runtime.getLatestThreadId(ctx.session, ctx.chatId);
         if (latest) {
             return latest;
         }
     }
-    return ctx.runtime.createThread(ctx.session, ctx.chatId, workspace || process.cwd(), 'CLI Session');
+    if (!bestEffort) {
+        return ctx.runtime.createThread(ctx.session, ctx.chatId, workspace || process.cwd(), 'CLI Session');
+    }
+    try {
+        return await ctx.runtime.createThread(ctx.session, ctx.chatId, workspace || process.cwd(), 'CLI Session');
+    }
+    catch (error) {
+        const fallbackThreadId = `local-${Date.now().toString(36)}`;
+        process.stderr.write(`Warning: failed to create Pod chat thread; using temporary thread ${fallbackThreadId}: ${formatLinxCliErrorMessage(error)}\n`);
+        return fallbackThreadId;
+    }
+}
+async function tryGetLatestThreadId(ctx) {
+    try {
+        return await ctx.runtime.getLatestThreadId(ctx.session, ctx.chatId);
+    }
+    catch (error) {
+        process.stderr.write(`Warning: failed to load latest Pod chat thread: ${formatLinxCliErrorMessage(error)}\n`);
+        return null;
+    }
 }
 async function runInteractive(options) {
     const { ctx, initialThreadId, initialModel, initialPrompt } = options;
@@ -262,39 +297,82 @@ function printConfiguredLinxPackages(packageManager) {
 async function runPiCommand(argv) {
     const firstPromptToken = Array.isArray(argv.prompt) ? argv.prompt[0] : undefined;
     // Reject old command aliases explicitly; auto-mode is only selected through flags.
-    if (firstPromptToken === 'automode' || firstPromptToken === 'watch') {
+    if (firstPromptToken === 'automode' || firstPromptToken === 'watch' || firstPromptToken === 'resume') {
         throw new Error(`Unknown command: ${firstPromptToken}`);
     }
+    if (argv.resume) {
+        const selectedSession = await selectLinxSession(cwdFromArg(argv.cwd));
+        if (!selectedSession) {
+            process.stdout.write('No session selected\n');
+            return;
+        }
+        await runPiCommand({
+            ...argv,
+            resume: false,
+            session: selectedSession,
+        });
+        return;
+    }
     if (isAutoModeRequest(argv)) {
         await runAutoModeCommand(argv);
         return;
     }
-    const backend = 'cloud';
+    if (argv['pi-sync-status']) {
+        await runPiSyncStatusCommand();
+        return;
+    }
+    if (argv['pi-sync-retry']) {
+        await runPiSyncRetryCommand({
+            cwd: argv.cwd || process.cwd(),
+            sessionId: argv['pi-sync-retry'],
+        });
+        return;
+    }
+    if (argv.backend) {
+        await runAutoModeCommand({
+            ...argv,
+            plain: Boolean(argv.plain || argv.print),
+        });
+        return;
+    }
+    const cwd = argv.cwd || process.cwd();
     const startupLoginPrompt = await resolveLinxStartupLoginPromptDecision({
-        backend,
+        backend: 'cloud',
         print: argv.print,
         issuerUrl: resolveAccountBaseUrl(),
+        resolveSession: resolveStartupLinxPodDataSession,
     });
-    const adapter = createPiRuntimeAdapter({
-        createNativeProxy(options) {
-            return createCodexNativeProxy({
-                cwd: options?.cwd,
-                model: options?.model,
-                listenPort: options?.listenPort,
-            });
-        },
+    const sessionManager = await createLinxPiSessionManager({
+        cwd,
+        agentDir: LINX_AGENT_DIR,
+        session: argv.session,
+        last: Boolean(argv.continue || argv.last),
+    });
+    const restoreAutoFromHydration = Boolean(argv.session || argv.continue || argv.last);
+    const controlState = await resolvePiStartupControlState({
+        requestedAuto: typeof argv.auto === 'boolean' ? argv.auto : undefined,
+        hydrateFromPod: !argv.print && !startupLoginPrompt.shouldPrompt,
+        restoreAutoFromHydration,
+        sessionManager,
+    });
+    const autoEnabled = controlState.autoEnabled;
+    const symphonyEnabled = controlState.symphonyEnabled;
+    const adapter = createLinxRuntimeAdapter({
         async createRemoteCompletion(options) {
             const chatApi = await import('./lib/chat-api.js');
             return chatApi.createRemoteCompletionResult(options);
         },
-        async listRemoteModels(session, runtimeUrl, apiKey) {
+        async listRemoteModels(authFetch, runtimeUrl, options) {
             const chatApi = await import('./lib/chat-api.js');
-            return chatApi.listRemoteModels(session, runtimeUrl, apiKey, { fallback: false, timeoutMs: 5000 });
+            return chatApi.listRemoteModels(authFetch, runtimeUrl, options ?? { fallback: false, timeoutMs: 5000 });
         },
     }, {
-        cwd: argv.cwd || process.cwd(),
+        cwd,
         model: argv.model,
-        backend,
+        backend: 'cloud',
+        autoEnabled,
+        symphonyEnabled,
+        getPodDataSession: getDefaultPodDataSession,
         port: argv.port,
         providerConfig: {
             baseUrl: String(argv['runtime-url'] ?? 'https://api.undefineds.co/v1'),
@@ -302,42 +380,14 @@ async function runPiCommand(argv) {
         },
     });
     await adapter.start();
-    const sessionManager = await createLinxPiSessionManager({
-        cwd: adapter.cwd,
-        agentDir: LINX_AGENT_DIR,
-        session: argv.session,
-        last: argv.last,
-    });
     const runtime = await adapter.createRuntime({
         cwd: adapter.cwd,
         agentDir: LINX_AGENT_DIR,
         sessionManager,
     });
-    const podMirror = new LinxPiPodMirror({
-        cwd: adapter.cwd,
-        sessionManager,
-        onError(error) {
-            if (process.env.LINX_DEBUG === '1') {
-                const message = error instanceof Error ? error.stack || error.message : String(error);
-                process.stderr.write(`[linx pod mirror] ${message}\n`);
-            }
-        },
-    });
-    const unsubscribePodMirror = runtime.session.subscribe((event) => {
-        podMirror.handleEvent(event);
-    });
-    const interactive = bootstrapPiInteractiveMode(runtime);
-    const bridge = runtime;
-    const loginPromptReason = resolveLinxInteractiveLoginReason({
-        startupDecision: startupLoginPrompt,
-        runtimePromptOnStart: bridge.linxAuthBridge?.shouldPromptLoginOnStart,
-    });
-    if (loginPromptReason) {
-        interactive.requestLogin?.(loginPromptReason);
-    }
+    const prompt = (argv.prompt ?? []).join(' ').trim();
     try {
         if (argv.print) {
-            const prompt = (argv.prompt ?? []).join(' ').trim();
             const exitCode = await runPrintMode(runtime, {
                 mode: 'text',
                 initialMessage: prompt || undefined,
@@ -347,94 +397,194 @@ async function runPiCommand(argv) {
             }
             return;
         }
-        await interactive.run();
+        const podMirror = new LinxPiPodMirror({
+            cwd: adapter.cwd,
+            sessionManager,
+            autoEnabled,
+            symphonyEnabled,
+            checkpointStore: createFileSyncCheckpointStore({
+                dir: join(LINX_AGENT_DIR, 'sync', 'pi-pod-mirror', sessionManager.getSessionId()),
+            }),
+            onError(error) {
+                if (process.env.LINX_DEBUG === '1') {
+                    const message = error instanceof Error ? error.stack || error.message : String(error);
+                    process.stderr.write(`[linx pod mirror] ${message}\n`);
+                }
+            },
+        });
+        runtime.__linxPodMirror = podMirror;
+        const unsubscribePodMirror = runtime.session.subscribe((event) => {
+            podMirror.handleEvent(event);
+        });
+        const interactive = bootstrapLinxInteractiveMode(runtime, {
+            initialMessage: prompt || undefined,
+            restoredAuto: autoEnabled && restoreAutoFromHydration,
+            onAutoControlChange(enabled) {
+                void podMirror.syncAutoControlState(enabled);
+            },
+            onSymphonyControlChange(enabled) {
+                void podMirror.syncSymphonyControlState(enabled);
+            },
+        });
+        const bridge = runtime;
+        const loginPromptReason = resolveLinxInteractiveLoginReason({
+            startupDecision: startupLoginPrompt,
+            runtimePromptOnStart: bridge.linxAuthBridge?.shouldPromptLoginOnStart,
+        });
+        if (loginPromptReason) {
+            interactive.requestLogin?.(loginPromptReason);
+        }
+        try {
+            await interactive.run();
+        }
+        finally {
+            unsubscribePodMirror();
+            await podMirror.close().catch(() => undefined);
+            interactive.stop();
+        }
     }
     finally {
-        unsubscribePodMirror();
-        await podMirror.close().catch(() => undefined);
-        interactive.stop();
         await adapter.close();
+        clearDefaultPodDataSession();
     }
 }
-async function runResumeCommand(argv) {
-    const cwd = typeof argv.cwd === 'string' ? argv.cwd : process.cwd();
-    const session = typeof argv.session === 'string' ? argv.session : undefined;
-    const piSessions = await listLinxPiSessions(cwd, LINX_AGENT_DIR);
-    const autoModeSessions = listArchivedAutoModeSessions();
-    if (!session && !argv.last) {
-        if (piSessions.length === 0 && autoModeSessions.length === 0) {
-            process.stdout.write('No LinX sessions found.\n');
-            return;
-        }
-        if (piSessions.length > 0) {
-            process.stdout.write('LinX sessions:\n');
-            process.stdout.write(`${piSessions.map((item) => `  ${formatLinxPiSessionSummary(item)}`).join('\n')}\n`);
-        }
-        if (autoModeSessions.length > 0) {
-            process.stdout.write('Auto-mode sessions:\n');
-            process.stdout.write(`${autoModeSessions.map((item) => `  ${formatAutoModeSessionSummary(item)}`).join('\n')}\n`);
-        }
-        return;
+async function resolvePiStartupControlState(options) {
+    if (!options.hydrateFromPod) {
+        return {
+            autoEnabled: options.requestedAuto === true,
+            symphonyEnabled: false,
+        };
     }
-    if (argv.last && !session) {
-        const latestPi = piSessions[0];
-        const latestAutoMode = autoModeSessions[0];
-        const latestPiTime = latestPi?.modified.getTime() ?? 0;
-        const latestAutoModeTime = latestAutoMode ? Date.parse(latestAutoMode.endedAt ?? latestAutoMode.startedAt) : 0;
-        if (latestAutoMode && latestAutoModeTime > latestPiTime) {
-            const exitCode = await resumeAutoModeSession(latestAutoMode, {
-                cwd,
-                model: argv.model,
-            });
-            if (exitCode !== 0) {
-                process.exitCode = exitCode;
-            }
-            return;
-        }
+    const session = await createLinxPodDataSession().catch(() => null);
+    if (!session) {
+        return {
+            autoEnabled: options.requestedAuto === true,
+            symphonyEnabled: false,
+        };
     }
-    if (session) {
-        try {
-            await resolveLinxPiSession(session, cwd, undefined);
-            await runPiCommand({
-                cwd,
-                model: typeof argv.model === 'string' ? argv.model : undefined,
-                'runtime-url': typeof argv['runtime-url'] === 'string' ? argv['runtime-url'] : undefined,
-                session,
-                last: false,
-            });
-            return;
-        }
-        catch {
-            const autoModeSession = loadArchivedAutoModeSession(session);
-            if (autoModeSession) {
-                const exitCode = await resumeAutoModeSession(autoModeSession, {
-                    cwd,
-                    model: argv.model,
-                });
-                if (exitCode !== 0) {
-                    process.exitCode = exitCode;
+    try {
+        const db = drizzle(session.solidSession, {
+            logger: false,
+            disableInteropDiscovery: true,
+            podUrl: session.podUrl,
+            resourcePreparation: 'off',
+            schema: solidResources,
+        });
+        const hydration = await hydrateLinxPiControlState({
+            db,
+            sessionId: options.sessionManager.getSessionId(),
+            createdAt: getPiSessionCreatedAt(options.sessionManager),
+            onError(error) {
+                if (process.env.LINX_DEBUG === '1') {
+                    const message = error instanceof Error ? error.stack || error.message : String(error);
+                    process.stderr.write(`[linx control state] ${message}\n`);
                 }
+            },
+        });
+        return {
+            ...deriveLinxPiStartupControlState({
+                requestedAuto: options.requestedAuto,
+                hydration,
+                restoreAutoFromHydration: options.restoreAutoFromHydration,
+            }),
+        };
+    }
+    finally {
+        await session.close().catch(() => undefined);
+    }
+}
+function getPiSessionCreatedAt(sessionManager) {
+    const entryDate = sessionManager.getEntries()
+        .map((entry) => toDate(entry.timestamp))
+        .find((date) => date instanceof Date);
+    return entryDate ?? parseTimestampFromUuidLikeId(sessionManager.getSessionId()) ?? new Date();
+}
+function parseTimestampFromUuidLikeId(id) {
+    const prefix = id.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;
+    }
+    const date = new Date(millis);
+    return Number.isNaN(date.getTime()) ? null : date;
+}
+function toDate(value) {
+    if (value instanceof Date && !Number.isNaN(value.getTime())) {
+        return value;
+    }
+    if (typeof value === 'number' || typeof value === 'string') {
+        const date = new Date(value);
+        return Number.isNaN(date.getTime()) ? null : date;
+    }
+    return null;
+}
+function cwdFromArg(cwd) {
+    return typeof cwd === 'string' && cwd.trim() ? cwd : process.cwd();
+}
+async function selectLinxSession(cwd) {
+    const settingsManager = SettingsManager.create(cwd, LINX_AGENT_DIR);
+    initTheme(settingsManager.getTheme());
+    return new Promise((resolve) => {
+        const ui = new TUI(new ProcessTerminal());
+        let resolved = false;
+        const finish = (sessionPath) => {
+            if (resolved) {
                 return;
             }
-        }
+            resolved = true;
+            ui.stop();
+            resolve(sessionPath);
+        };
+        const loadSessions = () => listLinxPiSessions(cwd, LINX_AGENT_DIR, { podSessionSource: null });
+        const selector = new SessionSelectorComponent(loadSessions, loadSessions, (sessionPath) => finish(sessionPath), () => finish(null), () => {
+            ui.stop();
+            process.exit(0);
+        }, () => ui.requestRender(), { showRenameHint: false });
+        ui.addChild(selector);
+        ui.setFocus(selector.getSessionList());
+        ui.start();
+    });
+}
+async function runPiSyncStatusCommand() {
+    const sessions = await listPendingPiPodMirrorSync(LINX_AGENT_DIR);
+    if (sessions.length === 0) {
+        process.stdout.write('No pending LinX Pod sync sessions.\n');
+        return;
     }
-    await runPiCommand({
-        cwd,
-        model: typeof argv.model === 'string' ? argv.model : undefined,
-        'runtime-url': typeof argv['runtime-url'] === 'string' ? argv['runtime-url'] : undefined,
-        session,
-        last: Boolean(argv.last) || !session,
+    process.stdout.write(`${sessions.map((session) => {
+        const failed = session.checkpoints.filter((checkpoint) => checkpoint.status === 'failed').length;
+        const partial = session.checkpoints.filter((checkpoint) => checkpoint.status === 'partial').length;
+        const latest = session.checkpoints.at(-1)?.completedAt ?? 'unknown';
+        return `${session.sessionId} · failed=${failed} partial=${partial} latest=${latest}`;
+    }).join('\n')}\n`);
+}
+async function runPiSyncRetryCommand(options) {
+    const result = await retryPendingPiPodMirrorSync({
+        cwd: options.cwd,
+        agentDir: LINX_AGENT_DIR,
+        sessionId: options.sessionId,
     });
+    if (!result.attempted) {
+        process.stdout.write(`LinX Pod sync skipped: ${options.sessionId}\n`);
+        return;
+    }
+    const status = result.results.map((item) => item.status).join(', ') || 'none';
+    process.stdout.write(status === 'none'
+        ? `LinX Pod sync has no replayable local projections: ${options.sessionId}\n`
+        : `Retried LinX Pod sync: ${options.sessionId} (${status})\n`);
 }
 function buildPiCommand(command) {
     const configured = buildAutoModeOptions(command)
         .option('cwd', {
         type: 'string',
-        describe: 'Workspace path for the Pi session',
+        describe: 'Workspace path for the LinX session',
     })
         .option('model', {
         type: 'string',
-        describe: 'Model id to expose through the Pi runtime adapter; defaults to the last LinX selection',
+        describe: 'Model id to expose through the LinX runtime adapter; defaults to the last LinX selection',
     })
         .option('runtime-url', {
         type: 'string',
@@ -448,12 +598,32 @@ function buildPiCommand(command) {
     })
         .option('session', {
         type: 'string',
-        describe: 'Resume a specific LinX/Pi session id or JSONL file',
+        describe: 'Resume a specific LinX session id or JSONL file',
+    })
+        .option('continue', {
+        alias: 'c',
+        type: 'boolean',
+        default: false,
+        describe: 'Continue previous LinX session',
+    })
+        .option('resume', {
+        alias: 'r',
+        type: 'boolean',
+        default: false,
+        describe: 'Select a LinX session to resume',
     })
         .option('last', {
         type: 'boolean',
         default: false,
-        describe: 'Continue the most recent local LinX/Pi session for this workspace',
+        hidden: true,
+    })
+        .option('pi-sync-status', {
+        type: 'boolean',
+        hidden: true,
+    })
+        .option('pi-sync-retry', {
+        type: 'string',
+        hidden: true,
     })
         .positional('prompt', {
         array: true,
@@ -464,7 +634,7 @@ function buildPiCommand(command) {
 }
 const defaultPiCommand = {
     command: '$0 [prompt..]',
-    describe: 'Run LinX, or control an external agent backend with --backend',
+    describe: 'Run LinX with the selected runtime backend',
     builder: buildPiCommand,
     handler: runPiCommand,
 };
@@ -489,6 +659,23 @@ const execCommand = {
         await runPiCommand({ ...argv, print: true });
     },
 };
+const retiredSymphonyCommand = {
+    command: 'symphony [args..]',
+    describe: false,
+    builder(command) {
+        return command
+            .help(false)
+            .version(false)
+            .positional('args', {
+            array: true,
+            type: 'string',
+            describe: 'Retired Symphony CLI arguments',
+        });
+    },
+    handler() {
+        throw new Error('`linx symphony` is not a product command. Enter the TUI, run `/symphony on`, then send the objective as normal chat to Secretary.');
+    },
+};
 const cli = yargs(hideBin(process.argv))
     .scriptName('linx')
     .version(readPackageVersion())
@@ -499,7 +686,7 @@ const cli = yargs(hideBin(process.argv))
     .command(logoutCommand)
     .command(whoamiCommand)
     .command(aiCommand)
-    .command(symphonyCommand)
+    .command(retiredSymphonyCommand)
     .command('install [source]', 'Install a LinX package or extension', (command) => command
     .positional('source', { type: 'string', describe: 'Package source to install' })
     .option('local', { alias: 'l', type: 'boolean', default: false, describe: 'Install project-locally (.pi/settings.json)' }), async (argv) => {
@@ -538,6 +725,7 @@ const cli = yargs(hideBin(process.argv))
         continueMode: argv.continue,
         explicitThreadId: argv.thread,
         workspace: argv.workspace,
+        bestEffort: Boolean(argv.prompt?.join(' ').trim()),
     });
     const prompt = argv.prompt?.join(' ').trim() || undefined;
     if (prompt) {
@@ -552,7 +740,7 @@ const cli = yargs(hideBin(process.argv))
     const ctx = await resolveRuntimeAuthContext(argv.url);
     let models;
     try {
-        models = await ctx.runtime.listRemoteModels(ctx.session, ctx.runtimeUrl, ctx.apiKey, { fallback: false });
+        models = await ctx.runtime.listRemoteModels(ctx.authFetch, ctx.runtimeUrl, { fallback: false });
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -568,25 +756,11 @@ const cli = yargs(hideBin(process.argv))
         }
     }
     await ctx.podSession.close();
-})
-    .command('resume [session]', 'Resume a previous LinX or auto-mode session', (command) => command
-    .positional('session', { type: 'string', describe: 'Session id/prefix or JSONL file to resume' })
-    .option('last', { type: 'boolean', default: false, describe: 'Resume the most recent LinX or auto-mode session' })
-    .option('cwd', { type: 'string', describe: 'Workspace path for the resumed session' })
-    .option('model', { type: 'string', describe: 'Model id to expose through the Pi runtime adapter' })
-    .option('runtime-url', { type: 'string', default: 'https://api.undefineds.co/v1', describe: 'Cloud runtime API base URL' }), async (argv) => {
-    await runResumeCommand({
-        cwd: typeof argv.cwd === 'string' ? argv.cwd : undefined,
-        model: typeof argv.model === 'string' ? argv.model : undefined,
-        'runtime-url': typeof argv['runtime-url'] === 'string' ? argv['runtime-url'] : undefined,
-        session: typeof argv.session === 'string' ? argv.session : undefined,
-        last: Boolean(argv.last),
-    });
 })
     .command('fork [thread]', 'Fork a previous interactive session', (command) => command
     .positional('thread', { type: 'string', describe: 'Thread ID to fork' })
     .option('last', { type: 'boolean', default: false, describe: 'Fork the most recent thread' }), () => {
-    throw new Error('Fork is not implemented yet for LinX Pod-backed Pi sessions.');
+    throw new Error('Fork is not implemented yet for LinX Pod-backed sessions.');
 })
     .command(hiddenPiAliasCommand)
     .command(hiddenPiFrontendAliasCommand)
@@ -628,18 +802,18 @@ const cli = yargs(hideBin(process.argv))
     .help()
     .fail((message, error, yargsInstance) => {
     if (error) {
-        console.error(error instanceof Error ? error.message : String(error));
+        console.error(formatLinxCliErrorMessage(error));
         process.exit(1);
     }
     if (message) {
-        console.error(message);
+        console.error(formatLinxCliErrorMessage(message));
         process.exit(1);
     }
     yargsInstance.showHelp();
     process.exit(1);
 });
 process.on('unhandledRejection', (error) => {
-    console.error(error instanceof Error ? error.message : String(error));
+    console.error(formatLinxCliErrorMessage(error));
     process.exit(1);
 });
 cli.parse();