@undefineds.co/linx 0.2.19 → 0.2.24

package/dist/lib/{watch → auto-mode}/runner.js

@@ -1,28 +1,30 @@
 import { spawn } from 'node:child_process';
 import { setTimeout as delay } from 'node:timers/promises';
-import { buildAcpPermissionResponse, buildWatchUserInputResponse, MAX_WATCH_SECRETARY_REACTION_WINDOW_MS, MIN_WATCH_SECRETARY_REACTION_WINDOW_MS, normalizeAcpInteractionRequest, normalizeAcpRequest, normalizeAcpSessionNotification, normalizeWatchCredentialSource, parseWatchJsonLine, resolveWatchCredentialSourceResolution, shouldAttemptCloudCredentialProbe, watchApprovalDecisionLabel, watchUserInputAnswersSummary, } from '@undefineds.co/models/watch';
-import { appendWatchEvent, createWatchSession, finishWatchSession, loadWatchEvents, loadWatchSession, listWatchSessions, writeWatchSession, } from './archive.js';
-import { detectWatchAuthFailure, preflightWatchAuth } from './auth.js';
-import { createWatchDisplay } from './display.js';
-import { formatWatchSessionSummary } from './format.js';
-import { describeWatchMode, getWatchHook, listWatchHooks } from './hooks/index.js';
-import { createRemoteWatchApproval, isRemoteApprovalAbortError, resolveExistingRemoteWatchGrant, resolveRemoteWatchApproval, waitForRemoteWatchApproval, } from './pod-approval.js';
-import { persistWatchConversationToPod } from './pod-persistence.js';
+import { buildAcpPermissionResponse, buildAutoModeUserInputResponse, MAX_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS, MIN_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS, normalizeAcpInteractionRequest, normalizeAcpRequest, normalizeAcpSessionNotification, parseAutoModeJsonLine, autoModeApprovalDecisionLabel, autoModeUserInputAnswersSummary, } from '../../../vendor/agent-runtime/dist/auto-mode.js';
+import { adoptAutoModeSessionId, appendAutoModeEvent, createAutoModeSession, finishAutoModeSession, loadAutoModeEvents, loadAutoModeSession, listAutoModeSessions, writeAutoModeSession, } from './archive.js';
+import { detectAutoModeAuthFailure, preflightAutoModeAuth } from './auth.js';
+import { createAutoModeDisplay } from './display.js';
+import { formatAutoModeSessionSummary } from './format.js';
+import { describeAutoModeMode, getAutoModeHook, listAutoModeHooks } from './hooks/index.js';
+import { createRemoteAutoModeApproval, isRemoteApprovalAbortError, resolveExistingRemoteAutoModeGrant, resolveRemoteAutoModeApproval, waitForRemoteAutoModeApproval, } from './pod-approval.js';
+import { persistAutoModeConversationToPod } from './pod-persistence.js';
 import { loadPodBackendCredential, podCredentialMissingMessage } from './pod-ai.js';
-import { resolveWatchSecretaryRecommendation } from './secretary.js';
+import { resolveAutoModeSecretaryRecommendation } from './secretary.js';
 import { promptText } from '../prompt.js';
-const WATCH_SECRETARY_COUNTDOWN_BAR_WIDTH = 10;
-const WATCH_SECRETARY_COUNTDOWN_TICK_MS = 250;
-export const watchRuntime = {
+import { runLinxLoginCommand, runLinxLogoutCommand } from '../login-command.js';
+import { clearDefaultPodDataSession } from '../pod-data-session.js';
+const AUTO_MODE_SECRETARY_COUNTDOWN_BAR_WIDTH = 10;
+const AUTO_MODE_SECRETARY_COUNTDOWN_TICK_MS = 250;
+export const autoModeRuntime = {
     promptText,
-    preflightWatchAuth,
+    preflightAutoModeAuth,
     loadPodBackendCredential,
-    createRemoteWatchApproval,
-    resolveExistingRemoteWatchGrant,
-    waitForRemoteWatchApproval,
-    resolveRemoteWatchApproval,
-    persistWatchConversationToPod,
-    resolveWatchSecretaryRecommendation,
+    createRemoteAutoModeApproval,
+    resolveExistingRemoteAutoModeGrant,
+    waitForRemoteAutoModeApproval,
+    resolveRemoteAutoModeApproval,
+    persistAutoModeConversationToPod,
+    resolveAutoModeSecretaryRecommendation,
 };
 function createLineSplitter(stream, onLine) {
     let buffer = '';
@@ -57,7 +59,7 @@ function appendEntry(record, stream, line, events) {
         line,
         events,
     };
-    appendWatchEvent(record, entry);
+    appendAutoModeEvent(record, entry);
 }
 function appendSessionNote(record, message, raw) {
     appendEntry(record, 'system', JSON.stringify({
@@ -98,7 +100,7 @@ async function promptApproval(display, message, allowSessionOption = true, signa
 function approvalPromptLines(message, recommendation) {
     const lines = [`[approval] ${message}`];
     if (recommendation?.decision) {
-        const label = watchApprovalDecisionLabel(recommendation.decision);
+        const label = autoModeApprovalDecisionLabel(recommendation.decision);
         const confidence = typeof recommendation.confidence === 'number'
             ? ` · confidence ${Math.round(recommendation.confidence * 100)}%`
             : '';
@@ -108,7 +110,7 @@ function approvalPromptLines(message, recommendation) {
         lines.push(`[secretary] ${recommendation.reason}`);
     }
     if (recommendation?.canAutoDecide && recommendation.decision && (recommendation.reactionWindowMs ?? 0) > 0) {
-        lines.push(`[secretary] auto-selects ${watchApprovalDecisionLabel(recommendation.decision)} after ${formatReactionWindow(recommendation.reactionWindowMs)}`);
+        lines.push(`[secretary] auto-selects ${autoModeApprovalDecisionLabel(recommendation.decision)} after ${formatReactionWindow(recommendation.reactionWindowMs)}`);
     }
     return lines;
 }
@@ -118,9 +120,9 @@ function resolveSecretaryReactionWindowMs(recommendation) {
     }
     const reactionWindowMs = recommendation.reactionWindowMs ?? 0;
     if (recommendation.source === 'fallback') {
-        return Math.max(0, Math.min(MAX_WATCH_SECRETARY_REACTION_WINDOW_MS, reactionWindowMs));
+        return Math.max(0, Math.min(MAX_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS, reactionWindowMs));
     }
-    return Math.max(MIN_WATCH_SECRETARY_REACTION_WINDOW_MS, Math.min(MAX_WATCH_SECRETARY_REACTION_WINDOW_MS, reactionWindowMs > 0 ? reactionWindowMs : MIN_WATCH_SECRETARY_REACTION_WINDOW_MS));
+    return Math.max(MIN_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS, Math.min(MAX_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS, reactionWindowMs > 0 ? reactionWindowMs : MIN_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS));
 }
 export const __testResolveSecretaryReactionWindowMs = resolveSecretaryReactionWindowMs;
 function approvalPromptOptions(allowSessionOption, recommendedDecision) {
@@ -158,7 +160,7 @@ async function promptApprovalWithRecommendation(display, message, recommendation
             : undefined,
         onAuto: () => {
             onAuto?.();
-            display.showActivity(`AI secretary selected ${watchApprovalDecisionLabel(recommendation.decision)} | ${recommendation.reason ?? 'auto decision'}`, 'success');
+            display.showActivity(`AI secretary selected ${autoModeApprovalDecisionLabel(recommendation.decision)} | ${recommendation.reason ?? 'auto decision'}`, 'success');
         },
     });
 }
@@ -181,11 +183,11 @@ async function promptWithAutoDefault(options) {
     const progressTimer = options.onProgress
         ? setInterval(() => {
             const remainingMs = Math.max(0, options.reactionWindowMs - Math.max(0, Date.now() - startedAt));
-            options.onProgress?.(formatWatchSecretaryCountdownDetail(remainingMs, options.reactionWindowMs));
-        }, WATCH_SECRETARY_COUNTDOWN_TICK_MS)
+            options.onProgress?.(formatAutoModeSecretaryCountdownDetail(remainingMs, options.reactionWindowMs));
+        }, AUTO_MODE_SECRETARY_COUNTDOWN_TICK_MS)
         : null;
     if (options.onProgress) {
-        options.onProgress(formatWatchSecretaryCountdownDetail(options.reactionWindowMs, options.reactionWindowMs));
+        options.onProgress(formatAutoModeSecretaryCountdownDetail(options.reactionWindowMs, options.reactionWindowMs));
     }
     void promptPromise.catch(() => undefined);
     try {
@@ -206,30 +208,74 @@ function formatReactionWindow(ms) {
     const seconds = Math.max(0, Math.ceil((ms ?? 0) / 1000));
     return `${seconds}s`;
 }
-export function formatWatchSecretaryCountdownDetail(remainingMs, durationMs) {
+export function formatAutoModeSecretaryCountdownDetail(remainingMs, durationMs) {
     const totalMs = Math.max(1, durationMs);
     const clampedRemainingMs = Math.max(0, Math.min(totalMs, remainingMs));
-    const filled = Math.max(0, Math.min(WATCH_SECRETARY_COUNTDOWN_BAR_WIDTH, Math.ceil((clampedRemainingMs / totalMs) * WATCH_SECRETARY_COUNTDOWN_BAR_WIDTH)));
-    const bar = `${'#'.repeat(filled)}${'-'.repeat(WATCH_SECRETARY_COUNTDOWN_BAR_WIDTH - filled)}`;
+    const filled = Math.max(0, Math.min(AUTO_MODE_SECRETARY_COUNTDOWN_BAR_WIDTH, Math.ceil((clampedRemainingMs / totalMs) * AUTO_MODE_SECRETARY_COUNTDOWN_BAR_WIDTH)));
+    const bar = `${'#'.repeat(filled)}${'-'.repeat(AUTO_MODE_SECRETARY_COUNTDOWN_BAR_WIDTH - filled)}`;
     return `auto [${bar}] ${formatReactionWindow(clampedRemainingMs)}`;
 }
-async function promptAuthContinue(display, lines) {
+async function promptLinxCloudAuth(display, lines, reason = 'manual') {
     while (true) {
-        display.setPhase('question', 'Authentication required');
-        const answer = (await display.chooseOption('Authentication required', lines, [
-            { label: 'Continue', value: 'continue', shortcuts: ['c', 'y'] },
-            { label: 'Cancel', value: 'cancel', shortcuts: ['n', 'x'] },
+        display.setPhase('question', reason === 'expired' ? 'LinX Cloud login expired' : 'LinX Cloud login required');
+        const answer = (await display.chooseOption(reason === 'expired' ? 'LinX Cloud login expired' : 'LinX Cloud login required', lines, [
+            { label: 'Authorize in browser', value: 'browser', description: 'refresh the LinX Cloud Solid session', shortcuts: ['b', '1'] },
+            { label: 'Logout', value: 'logout', description: 'clear the current LinX Cloud session', shortcuts: ['l', '2'] },
+            { label: 'Exit', value: 'exit', description: 'leave auto-mode', shortcuts: ['x', '3'] },
         ])).trim().toLowerCase();
-        if (answer === 'continue' || answer === 'c' || answer === 'y' || answer === 'yes') {
-            display.setPhase('running', 'Continuing turn');
-            return true;
+        if (answer === 'browser' || answer === 'b' || answer === '1') {
+            await runBackendLinxLogin(display);
+            return 'retry';
         }
-        if (answer === 'cancel' || answer === 'n' || answer === 'x' || answer === 'no') {
-            display.setPhase('running', 'Continuing turn');
-            return false;
+        if (answer === 'logout' || answer === 'l' || answer === '2') {
+            runBackendLinxLogout(display);
+            continue;
+        }
+        if (answer === 'exit' || answer === 'x' || answer === '3' || answer === 'cancel') {
+            display.setPhase('running', 'Authentication cancelled');
+            return 'cancel';
         }
     }
 }
+async function runBackendLinxLogin(display) {
+    display.showActivity('Opening LinX Cloud login in your browser...');
+    await runLinxLoginCommand({}, {
+        promptText: autoModeRuntime.promptText,
+        write(chunk) {
+            for (const line of chunk.split(/\r?\n/u)) {
+                const trimmed = line.trim();
+                if (trimmed) {
+                    display.showActivity(trimmed);
+                }
+            }
+        },
+    });
+    clearDefaultPodDataSession();
+    display.showActivity('LinX Cloud login refreshed.', 'success');
+}
+function runBackendLinxLogout(display) {
+    runLinxLogoutCommand({
+        write(chunk) {
+            for (const line of chunk.split(/\r?\n/u)) {
+                const trimmed = line.trim();
+                if (trimmed) {
+                    display.showActivity(trimmed);
+                }
+            }
+        },
+    });
+    clearDefaultPodDataSession();
+    display.showActivity('Use /login or choose browser authorization to sign in again.', 'note');
+}
+function isRecoverableLinxCloudAuthError(message) {
+    const normalized = message.toLowerCase();
+    return normalized.includes('linx login')
+        || normalized.includes('linx cloud login expired')
+        || normalized.includes('linx cloud credential source is not connected')
+        || normalized.includes('failed to restore oidc access token')
+        || normalized.includes('invalid solid token')
+        || normalized.includes('unauthorized');
+}
 function approvalPromptMessage(request) {
     if (request.kind === 'command-approval') {
         return request.command ? `Approve command: ${request.command}` : 'Approve command execution';
@@ -248,15 +294,18 @@ function appendUserTurn(record, text) {
 function appendTurnStart(record, command, args) {
     appendEntry(record, 'system', JSON.stringify({ type: 'turn.start', command, args }), []);
 }
-function requestedCredentialSource(options) {
-    return normalizeWatchCredentialSource(options.credentialSource);
+function requestedCredentialSource(_options) {
+    return 'cloud';
 }
-function requestedApprovalSource(options) {
-    return options.approvalSource ?? 'hybrid';
+function requestedApprovalSource() {
+    return 'hybrid';
 }
 function requestedRuntime(options) {
     return options.runtime ?? 'local';
 }
+function requestedAutoModeMode(options) {
+    return options.autoModeEnabled ? 'auto' : options.mode;
+}
 function normalizeBackendCommandEnv(backend, env) {
     if (!env) {
         return undefined;
@@ -281,25 +330,38 @@ function syncRecordFromOptions(record, options, plan) {
     return {
         backend: options.backend,
         runtime: requestedRuntime(options),
-        mode: options.mode,
+        mode: requestedAutoModeMode(options),
         cwd: options.cwd,
         model: options.model,
         prompt: options.prompt,
         passthroughArgs: [...options.passthroughArgs],
         credentialSource: requestedCredentialSource(options),
         resolvedCredentialSource: options.resolvedCredentialSource,
-        approvalSource: requestedApprovalSource(options),
+        approvalSource: requestedApprovalSource(),
         command: plan.command,
         args: [...plan.args],
         transport: options.transport ?? 'acp',
     };
 }
+function extractAcpSessionId(response) {
+    if (typeof response.sessionId === 'string' && response.sessionId.trim()) {
+        return response.sessionId;
+    }
+    const nestedSession = response.session;
+    if (typeof nestedSession === 'object'
+        && nestedSession !== null
+        && typeof nestedSession.id === 'string'
+        && nestedSession.id.trim()) {
+        return nestedSession.id;
+    }
+    return null;
+}
 function withResolvedSource(options, resolvedCredentialSource, commandEnv) {
     return {
         ...options,
+        mode: requestedAutoModeMode(options),
         transport: options.transport ?? 'acp',
         credentialSource: requestedCredentialSource(options),
-        approvalSource: requestedApprovalSource(options),
         resolvedCredentialSource,
         commandEnv,
     };
@@ -308,67 +370,21 @@ async function probeCloudCredentialSource(backend, runtime) {
     try {
         const podCredential = await runtime.loadPodBackendCredential(backend);
         if (!podCredential) {
-            return {
-                probe: {
-                    status: 'unavailable',
-                    message: podCredentialMissingMessage(backend),
-                },
-            };
+            throw new Error(podCredentialMissingMessage(backend));
         }
         return {
-            probe: { status: 'available' },
             commandEnv: normalizeBackendCommandEnv(backend, { ...podCredential.env }),
         };
     }
     catch (error) {
-        return {
-            probe: {
-                status: 'error',
-                message: error instanceof Error ? error.message : String(error),
-            },
-        };
+        throw error instanceof Error ? error : new Error(String(error));
     }
 }
-export async function resolveWatchRunOptions(options, runtime = watchRuntime) {
-    const source = requestedCredentialSource(options);
-    if (source === 'cloud') {
-        const { probe, commandEnv } = await probeCloudCredentialSource(options.backend, runtime);
-        const resolution = resolveWatchCredentialSourceResolution({
-            requestedSource: source,
-            localAuthStatus: { state: 'unknown' },
-            cloudCredentialProbe: probe,
-        });
-        if (resolution.error) {
-            throw new Error(resolution.error);
-        }
-        return {
-            options: withResolvedSource(options, resolution.resolvedSource ?? 'cloud', commandEnv),
-            authPreflight: resolution.authStatus,
-        };
-    }
-    const localOptions = withResolvedSource(options, 'local');
-    const authPreflight = await runtime.preflightWatchAuth(options.backend);
-    let cloudCredentialProbe;
-    let commandEnv;
-    if (shouldAttemptCloudCredentialProbe(source, authPreflight)) {
-        const cloudResult = await probeCloudCredentialSource(options.backend, runtime);
-        cloudCredentialProbe = cloudResult.probe;
-        commandEnv = cloudResult.commandEnv;
-    }
-    const resolution = resolveWatchCredentialSourceResolution({
-        requestedSource: source,
-        localAuthStatus: authPreflight,
-        cloudCredentialProbe,
-        defaultLocalMessage: `${options.backend} is not authenticated`,
-    });
-    if (resolution.error) {
-        throw new Error(resolution.error);
-    }
+export async function resolveAutoRunOptions(options, runtime = autoModeRuntime) {
+    const { commandEnv } = await probeCloudCredentialSource(options.backend, runtime);
     return {
-        options: resolution.resolvedSource === 'cloud'
-            ? withResolvedSource(options, 'cloud', commandEnv)
-            : localOptions,
-        authPreflight: resolution.authStatus,
+        options: withResolvedSource(options, 'cloud', commandEnv),
+        authPreflight: { state: 'authenticated' },
     };
 }
 class BaseSession {
@@ -381,7 +397,7 @@ class BaseSession {
     lastExit = null;
     constructor(record, prompt) {
         this.record = record;
-        this.display = createWatchDisplay(record, prompt);
+        this.display = createAutoModeDisplay(record, prompt);
     }
     spawnProcess(command, args, cwd, env) {
         this.activeExitPromise = new Promise((resolve) => {
@@ -414,7 +430,7 @@ class BaseSession {
     }
     async finalizeAndClose(status, error) {
         const exitState = await this.waitForActiveExit();
-        const next = finishWatchSession(this.record, {
+        const next = finishAutoModeSession(this.record, {
             status,
             exitCode: exitState.code,
             signal: exitState.signal,
@@ -433,7 +449,11 @@ class BaseSession {
     }
     updateRecord(updates) {
         Object.assign(this.record, updates);
-        writeWatchSession(this.record);
+        writeAutoModeSession(this.record);
+        this.display.updateRecord(this.record);
+    }
+    adoptSessionId(sessionId) {
+        adoptAutoModeSessionId(this.record, sessionId);
         this.display.updateRecord(this.record);
     }
     waitForActiveExit() {
@@ -474,7 +494,7 @@ class AcpSession extends BaseSession {
     activeAgentRequests = 0;
     constructor(options, hook) {
         const plan = hook.buildSpawnPlan(options);
-        super(createWatchSession({ ...options, transport: options.transport ?? 'acp' }, plan), watchRuntime.promptText);
+        super(createAutoModeSession({ ...options, transport: options.transport ?? 'acp' }, plan), autoModeRuntime.promptText);
         this.hook = hook;
         this.options = options;
     }
@@ -497,19 +517,22 @@ class AcpSession extends BaseSession {
                 version: '0.1.0',
             },
         });
-        const newSession = await this.sendRequest('session/new', {
-            cwd: this.options.cwd,
-            mcpServers: [],
-        });
-        const sessionId = typeof newSession.sessionId === 'string'
-            ? newSession.sessionId
-            : typeof newSession.session?.id === 'string'
-                ? newSession.session.id
-                : null;
+        const sessionResponse = this.options.resumeSessionId
+            ? await this.sendRequest('session/resume', {
+                cwd: this.options.cwd,
+                mcpServers: [],
+                sessionId: this.options.resumeSessionId,
+            })
+            : await this.sendRequest('session/new', {
+                cwd: this.options.cwd,
+                mcpServers: [],
+            });
+        const sessionId = extractAcpSessionId(sessionResponse) ?? this.options.resumeSessionId ?? null;
         if (!sessionId) {
             throw new Error(`ACP backend ${this.options.backend} did not return a session id`);
         }
         this.sessionId = sessionId;
+        this.adoptSessionId(sessionId);
         this.updateRecord({
             backendSessionId: sessionId,
             error: undefined,
@@ -552,7 +575,7 @@ class AcpSession extends BaseSession {
             throw new Error('ACP session is not initialized');
         }
         if (this.turnState) {
-            throw new Error('A watch turn is already in progress');
+            throw new Error('An auto-mode turn is already in progress');
         }
         appendUserTurn(this.record, text);
         appendTurnStart(this.record, this.record.command, this.record.args);
@@ -652,7 +675,7 @@ class AcpSession extends BaseSession {
         this.scheduleTurnSettle();
     }
     handleLine(line, stream) {
-        const authFailure = detectWatchAuthFailure(this.record.backend, line);
+        const authFailure = detectAutoModeAuthFailure(this.record.backend, line);
         if (authFailure) {
             this.authFailureMessage = authFailure.message;
         }
@@ -661,7 +684,7 @@ class AcpSession extends BaseSession {
             this.markTurnActivity();
             return;
         }
-        const message = parseWatchJsonLine(line);
+        const message = parseAutoModeJsonLine(line);
         if (!message) {
             this.recordParsedLine(stream, line, []);
             this.markTurnActivity();
@@ -718,7 +741,7 @@ class AcpSession extends BaseSession {
         }
         this.pendingRequests.delete(id);
         if ('error' in message && message.error) {
-            const authFailure = detectWatchAuthFailure(this.record.backend, JSON.stringify(message));
+            const authFailure = detectAutoModeAuthFailure(this.record.backend, JSON.stringify(message));
             if (authFailure) {
                 this.authFailureMessage = authFailure.message;
                 pending.reject(new Error(authFailure.message));
@@ -744,9 +767,10 @@ class AcpSession extends BaseSession {
                 const lines = [
                     `[note] ${typeof params.message === 'string' ? params.message : 'Authentication required'}`,
                     ...(typeof params.url === 'string' ? [`[note] ${params.url}`] : []),
+                    '[note] Backend credentials are resolved from LinX Cloud Pod settings, not local backend login.',
                 ];
-                const shouldContinue = await promptAuthContinue(this.display, lines);
-                if (!shouldContinue) {
+                const authAction = await promptLinxCloudAuth(this.display, lines, 'expired');
+                if (authAction !== 'retry') {
                     this.authFailureMessage = 'Authentication request cancelled by user';
                 }
                 this.sendResponse(id, {});
@@ -778,13 +802,13 @@ class AcpSession extends BaseSession {
         const recommendation = await this.resolveSecretaryRecommendation(interaction);
         const answers = await this.resolveToolUserInputAnswers(interaction.questions, recommendation?.kind === 'user-input' ? recommendation : null);
         this.display.setPhase('running', 'Continuing turn');
-        return buildWatchUserInputResponse(answers);
+        return buildAutoModeUserInputResponse(answers);
     }
     async resolveToolUserInputAnswers(questions, recommendation) {
         this.display.setPhase('question', questions[0]?.header ?? 'Input required');
         if (!recommendation?.answers || !recommendation.canAutoDecide) {
             if (recommendation?.answers) {
-                this.display.showActivity(`AI secretary suggests: ${watchUserInputAnswersSummary(recommendation.answers)}`);
+                this.display.showActivity(`AI secretary suggests: ${autoModeUserInputAnswersSummary(recommendation.answers)}`);
             }
             return this.display.chooseQuestions(questions);
         }
@@ -796,7 +820,7 @@ class AcpSession extends BaseSession {
         const useAiAnswer = await promptWithAutoDefault({
             fallback: (signal) => this.display.chooseOption('Input required', [
                 `[input] ${questions[0]?.question ?? 'Input required'}`,
-                `[secretary] suggests ${watchUserInputAnswersSummary(recommendation.answers)}`,
+                `[secretary] suggests ${autoModeUserInputAnswersSummary(recommendation.answers)}`,
                 ...(recommendation.reason ? [`[secretary] ${recommendation.reason}`] : []),
                 ...(displayRecommendation.reactionWindowMs ? [`[secretary] auto-uses this answer after ${formatReactionWindow(displayRecommendation.reactionWindowMs)}`] : []),
             ], [
@@ -808,7 +832,7 @@ class AcpSession extends BaseSession {
             onProgress: reactionWindowMs > 0
                 ? (detail) => this.display.setPhase('question', detail)
                 : undefined,
-            onAuto: () => this.display.showActivity(`AI secretary answered input | ${watchUserInputAnswersSummary(recommendation.answers)}`, 'success'),
+            onAuto: () => this.display.showActivity(`AI secretary answered input | ${autoModeUserInputAnswersSummary(recommendation.answers)}`, 'success'),
         });
         if (useAiAnswer === 'use' || useAiAnswer === 'u' || useAiAnswer === 'y' || useAiAnswer === 'yes') {
             return recommendation.answers;
@@ -816,30 +840,21 @@ class AcpSession extends BaseSession {
         return this.display.chooseQuestions(questions);
     }
     async resolveApproval(interaction) {
-        const source = this.options.approvalSource ?? 'hybrid';
-        if (source !== 'local') {
-            const granted = await watchRuntime.resolveExistingRemoteWatchGrant({
-                record: this.record,
-                request: interaction,
-            }).catch(() => null);
-            if (granted) {
-                appendSessionNote(this.record, `Existing grant covered approval | ${watchApprovalDecisionLabel(granted)}`);
-                this.display.showActivity(`Existing grant covered approval | ${watchApprovalDecisionLabel(granted)}`, 'success');
-                this.display.setPhase('running', 'Continuing turn');
-                return granted;
-            }
+        const granted = await autoModeRuntime.resolveExistingRemoteAutoModeGrant({
+            record: this.record,
+            request: interaction,
+        }).catch(() => null);
+        if (granted) {
+            appendSessionNote(this.record, `Existing grant covered approval | ${autoModeApprovalDecisionLabel(granted)}`);
+            this.display.showActivity(`Existing grant covered approval | ${autoModeApprovalDecisionLabel(granted)}`, 'success');
+            this.display.setPhase('running', 'Continuing turn');
+            return granted;
         }
         const recommendation = await this.resolveSecretaryRecommendation(interaction);
-        if (source === 'local') {
-            return promptApprovalWithRecommendation(this.display, approvalPromptMessage(interaction), recommendation?.kind === interaction.kind ? recommendation : null);
-        }
-        if (source === 'remote') {
-            return this.resolveRemoteOnlyApproval(interaction, recommendation?.kind === interaction.kind ? recommendation : null);
-        }
         return this.resolveHybridApproval(interaction, recommendation?.kind === interaction.kind ? recommendation : null);
     }
     async resolveSecretaryRecommendation(interaction) {
-        return watchRuntime.resolveWatchSecretaryRecommendation({
+        return autoModeRuntime.resolveAutoModeSecretaryRecommendation({
             mode: this.options.mode,
             record: this.record,
             request: interaction,
@@ -849,11 +864,11 @@ class AcpSession extends BaseSession {
         const promptMessage = approvalPromptMessage(interaction);
         appendSessionNote(this.record, `Waiting for remote approval | ${promptMessage}`);
         this.display.setPhase('approval', `${promptMessage} · remote`);
-        const remote = await watchRuntime.createRemoteWatchApproval({
+        const remote = await autoModeRuntime.createRemoteAutoModeApproval({
             record: this.record,
             request: interaction,
         });
-        const remoteDecisionPromise = watchRuntime.waitForRemoteWatchApproval({
+        const remoteDecisionPromise = autoModeRuntime.waitForRemoteAutoModeApproval({
             approvalId: remote.id,
             approvalUri: remote.approvalUri,
         });
@@ -868,8 +883,8 @@ class AcpSession extends BaseSession {
         const decision = await Promise.race([
             remoteDecisionPromise,
             delay(reactionWindowMs).then(async () => {
-                this.display.showActivity(`AI secretary selected ${watchApprovalDecisionLabel(recommendation.decision)} | ${recommendation.reason ?? 'auto decision'}`, 'success');
-                await watchRuntime.resolveRemoteWatchApproval({
+                this.display.showActivity(`AI secretary selected ${autoModeApprovalDecisionLabel(recommendation.decision)} | ${recommendation.reason ?? 'auto decision'}`, 'success');
+                await autoModeRuntime.resolveRemoteAutoModeApproval({
                     approvalId: remote.id,
                     approvalUri: remote.approvalUri,
                     decision: recommendation.decision,
@@ -887,7 +902,7 @@ class AcpSession extends BaseSession {
         const promptMessage = approvalPromptMessage(interaction);
         let remoteApproval = null;
         try {
-            remoteApproval = await watchRuntime.createRemoteWatchApproval({
+            remoteApproval = await autoModeRuntime.createRemoteAutoModeApproval({
                 record: this.record,
                 request: interaction,
             });
@@ -895,7 +910,10 @@ class AcpSession extends BaseSession {
         }
         catch (error) {
             appendSessionNote(this.record, `Remote approval unavailable | ${error instanceof Error ? error.message : String(error)}`);
-            return promptApprovalWithRecommendation(this.display, promptMessage, recommendation);
+            const decision = await promptApprovalWithRecommendation(this.display, promptMessage, recommendation);
+            appendSessionNote(this.record, `Local approval resolved | ${decision}`);
+            this.display.setPhase('running', 'Continuing turn');
+            return decision;
         }
         const localAbort = new AbortController();
         const remoteAbort = new AbortController();
@@ -904,7 +922,7 @@ class AcpSession extends BaseSession {
             secretaryAutoResolved = true;
         })
             .then((decision) => ({ source: 'local', decision }));
-        const remoteDecisionPromise = watchRuntime.waitForRemoteWatchApproval({
+        const remoteDecisionPromise = autoModeRuntime.waitForRemoteAutoModeApproval({
             approvalId: remoteApproval.id,
             approvalUri: remoteApproval.approvalUri,
             signal: remoteAbort.signal,
@@ -916,14 +934,14 @@ class AcpSession extends BaseSession {
             if (winner.source === 'local') {
                 remoteAbort.abort();
                 appendSessionNote(this.record, `Local approval resolved | ${winner.decision}`);
-                void watchRuntime.resolveRemoteWatchApproval({
+                void autoModeRuntime.resolveRemoteAutoModeApproval({
                     approvalId: remoteApproval.id,
                     approvalUri: remoteApproval.approvalUri,
                     decision: winner.decision,
                     decisionRole: secretaryAutoResolved ? 'secretary' : 'human',
                     note: secretaryAutoResolved
                         ? (recommendation?.reason ?? 'resolved by AI secretary')
-                        : 'resolved from active local watch session',
+                        : 'resolved from active local auto-mode session',
                 }).catch(() => undefined);
                 this.display.setPhase('running', 'Continuing turn');
                 return winner.decision;
@@ -993,37 +1011,71 @@ class AcpSession extends BaseSession {
     }
 }
 function buildConversationSession(options) {
-    const hook = getWatchHook(options.backend);
+    const hook = getAutoModeHook(options.backend);
     return new AcpSession(options, hook);
 }
-async function handleWatchShellCommand(args) {
+async function handleAutoModeShellCommand(args) {
     const { input, session, display, queueState, backend, record } = args;
     if (input === '/exit' || input === '/quit') {
         return 'exit';
     }
-    if (input === '/help') {
+    if (input === '/help' || input === '/hotkeys' || input === '/keymap') {
         display.showHelp();
         return 'handled';
     }
+    if (input === '/login') {
+        try {
+            await runBackendLinxLogin(display);
+            appendSessionNote(record, 'LinX Cloud login refreshed from auto-mode');
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            appendAndDisplaySessionNote(record, display, `LinX Cloud login failed | ${message}`, 'error', { error: message });
+        }
+        return 'handled';
+    }
+    if (input === '/logout') {
+        runBackendLinxLogout(display);
+        appendSessionNote(record, 'LinX Cloud logout requested from auto-mode');
+        return 'handled';
+    }
     if (input === '/session') {
         appendAndDisplaySessionNote(record, display, [
-            `session=${record.id}`,
+            `session=${record.backendSessionId ?? record.id}`,
             `backend=${record.backend}`,
             `runtime=${record.runtime}`,
-            `source=${record.resolvedCredentialSource ?? record.credentialSource}`,
+            'credentials=pod',
             `model=${record.model ?? 'default'}`,
             `cwd=${record.cwd}`,
         ].join(' | '));
         return 'handled';
     }
+    if (input === '/manual' || input === '/smart' || input === '/auto') {
+        const mode = input.slice(1);
+        session.applyResolvedOptions({
+            backend: record.backend,
+            mode,
+            cwd: record.cwd,
+            plain: false,
+            model: record.model,
+            prompt: record.prompt,
+            passthroughArgs: record.passthroughArgs,
+            runtime: record.runtime,
+            transport: record.transport,
+            credentialSource: record.credentialSource,
+            resolvedCredentialSource: record.resolvedCredentialSource,
+        });
+        appendAndDisplaySessionNote(record, display, `Approval mode set to ${mode}`, 'success', { mode });
+        return 'handled';
+    }
     if (input === '/queue') {
         appendAndDisplaySessionNote(record, display, `queue | steer=${queueState.steeringCount} | follow-up=${queueState.followUpCount}`);
         return 'handled';
     }
     if (input === '/sessions') {
-        const summaries = listWatchSessions().slice(0, 5).map(formatWatchSessionSummary);
+        const summaries = listAutoModeSessions().slice(0, 5).map(formatAutoModeSessionSummary);
         if (summaries.length === 0) {
-            appendAndDisplaySessionNote(record, display, 'No archived watch sessions found');
+            appendAndDisplaySessionNote(record, display, 'No archived auto-mode sessions found');
             return 'handled';
         }
         for (const summary of summaries) {
@@ -1032,7 +1084,7 @@ async function handleWatchShellCommand(args) {
         return 'handled';
     }
     if (input === '/new') {
-        appendAndDisplaySessionNote(record, display, 'Use `linx watch run` to start a fresh watch session');
+        appendAndDisplaySessionNote(record, display, 'Use `linx --backend <backend>` to start a fresh auto-mode session');
         return 'handled';
     }
     if (input === '/debug' || input === '/debug on') {
@@ -1063,11 +1115,11 @@ async function handleWatchShellCommand(args) {
     }
     return 'pass';
 }
-export const __testHandleWatchShellCommand = handleWatchShellCommand;
-export async function runWatch(options) {
-    const previousPlainEnv = process.env.LINX_WATCH_PLAIN;
+export const __testHandleAutoModeShellCommand = handleAutoModeShellCommand;
+export async function runAutoMode(options) {
+    const previousPlainEnv = process.env.LINX_BACKEND_PLAIN;
     if (options.plain) {
-        process.env.LINX_WATCH_PLAIN = '1';
+        process.env.LINX_BACKEND_PLAIN = '1';
     }
     let fatalError = null;
     let session = null;
@@ -1075,8 +1127,8 @@ export async function runWatch(options) {
         ...options,
         runtime: requestedRuntime(options),
         transport: 'acp',
+        mode: requestedAutoModeMode(options),
         credentialSource: requestedCredentialSource(options),
-        approvalSource: requestedApprovalSource(options),
     };
     try {
         session = buildConversationSession(requestedOptions);
@@ -1089,18 +1141,31 @@ export async function runWatch(options) {
             followUpCount: 0,
         });
         let resolvedRun;
-        try {
-            resolvedRun = await resolveWatchRunOptions(requestedOptions);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            appendEntry(activeSession.record, 'system', JSON.stringify({
-                type: 'credentials.resolve',
-                backend: requestedOptions.backend,
-                requestedCredentialSource: requestedOptions.credentialSource,
-                error: message,
-            }), []);
-            throw error;
+        for (let attempt = 0;; attempt += 1) {
+            try {
+                resolvedRun = await resolveAutoRunOptions(requestedOptions);
+                break;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                appendEntry(activeSession.record, 'system', JSON.stringify({
+                    type: 'credentials.resolve',
+                    backend: requestedOptions.backend,
+                    requestedCredentialSource: requestedOptions.credentialSource,
+                    error: message,
+                }), []);
+                if (attempt >= 2 || !isRecoverableLinxCloudAuthError(message)) {
+                    throw error;
+                }
+                const authAction = await promptLinxCloudAuth(activeSession.display, [
+                    message,
+                    `Backend ${requestedOptions.backend} reads provider credentials from your LinX Cloud Pod.`,
+                    'Re-authorize LinX Cloud, then LinX will retry backend startup.',
+                ], 'startup');
+                if (authAction !== 'retry') {
+                    throw error;
+                }
+            }
         }
         activeSession.applyResolvedOptions(resolvedRun.options);
         appendEntry(activeSession.record, 'system', JSON.stringify({
@@ -1222,7 +1287,7 @@ export async function runWatch(options) {
             if (!trimmed) {
                 return;
             }
-            const shellCommand = await handleWatchShellCommand({
+            const shellCommand = await handleAutoModeShellCommand({
                 input: trimmed,
                 session: activeSession,
                 display: activeSession.display,
@@ -1291,38 +1356,60 @@ export async function runWatch(options) {
         if (session) {
             await session.close();
             const finalRecord = await session.finalizeAndClose(fatalError ? 'failed' : 'completed', fatalError?.message);
-            await watchRuntime.persistWatchConversationToPod(finalRecord).catch(() => undefined);
+            await autoModeRuntime.persistAutoModeConversationToPod(finalRecord).catch((error) => {
+                const message = error instanceof Error ? error.message : String(error);
+                appendSessionNote(finalRecord, `Pod sync failed | ${message}`, { error: message });
+                process.emitWarning(`LinX auto-mode Pod sync failed: ${message}`);
+            });
         }
         if (options.plain) {
             if (previousPlainEnv === undefined) {
-                delete process.env.LINX_WATCH_PLAIN;
+                delete process.env.LINX_BACKEND_PLAIN;
             }
             else {
-                process.env.LINX_WATCH_PLAIN = previousPlainEnv;
+                process.env.LINX_BACKEND_PLAIN = previousPlainEnv;
             }
         }
     }
 }
-export function listArchivedWatchSessions() {
-    return listWatchSessions();
+export function listArchivedAutoModeSessions() {
+    return listAutoModeSessions();
+}
+export function loadArchivedAutoModeSession(id) {
+    return loadAutoModeSession(id);
 }
-export function loadArchivedWatchSession(id) {
-    return loadWatchSession(id);
+export function loadArchivedAutoModeEvents(id) {
+    return loadAutoModeEvents(id);
 }
-export function loadArchivedWatchEvents(id) {
-    return loadWatchEvents(id);
+export function resumeAutoModeSession(record, options = {}) {
+    const sessionId = record.backendSessionId?.trim() || record.id;
+    return runAutoMode({
+        backend: record.backend,
+        mode: record.mode,
+        autoModeEnabled: record.mode === 'auto',
+        resumeSessionId: sessionId,
+        cwd: options.cwd || record.cwd,
+        plain: Boolean(options.plain),
+        model: options.model || record.model,
+        prompt: options.prompt,
+        passthroughArgs: [...record.passthroughArgs],
+        runtime: record.runtime,
+        transport: record.transport ?? 'acp',
+        credentialSource: record.credentialSource,
+        resolvedCredentialSource: record.resolvedCredentialSource,
+    });
 }
-export { formatWatchSessionSummary };
-export function listSupportedWatchBackends() {
-    return listWatchHooks().map((hook) => ({
+export { formatAutoModeSessionSummary };
+export function listSupportedAutoModeBackends() {
+    return listAutoModeHooks().map((hook) => ({
         backend: hook.id,
         label: hook.label,
         description: hook.description,
         capabilities: hook.capabilities,
         modes: {
-            manual: describeWatchMode('manual'),
-            smart: describeWatchMode('smart'),
-            auto: describeWatchMode('auto'),
+            manual: describeAutoModeMode('manual'),
+            smart: describeAutoModeMode('smart'),
+            auto: describeAutoModeMode('auto'),
         },
     }));
 }