@undefineds.co/linx 0.3.4 → 0.3.7

package/dist/lib/auto-mode/runner.js

@@ -1,19 +1,27 @@
 import { spawn } from 'node:child_process';
 import { setTimeout as delay } from 'node:timers/promises';
-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 { buildAcpPermissionResponse, buildAutoModeUserInputResponse, MAX_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS, MIN_AUTO_MODE_SECRETARY_REACTION_WINDOW_MS, normalizeAcpInteractionRequest, normalizeAcpRequest, normalizeAcpSessionNotification, parseAutoModeJsonLine, autoModeApprovalDecisionLabel, autoModeUserInputAnswersSummary, resolveAutoModeCommandRoute, shouldMaterializeAutoModeGrant, } from '../../../vendor/agent-runtime/dist/auto-mode.js';
+import { adoptAutoModeSessionId, appendAutoModeEvent, createAutoModeSession, finishAutoModeSession, hasPendingAutoModeSync, loadAutoModeEvents, loadAutoModeSession, listAutoModeSessionsWithPendingSync, listAutoModeSessions, writeAutoModeSyncCheckpoint, 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 { describeAutoControl, getAutoModeHook, linxNativeBackend, listAutoModeHooks } from './hooks/index.js';
+import { createRemoteAutoModeApproval, isRemoteApprovalAbortError, materializeRemoteAutoModeGrant, resolveExistingRemoteAutoModeGrant, resolveRemoteAutoModeApproval, waitForRemoteAutoModeApproval, } from './pod-approval.js';
 import { persistAutoModeConversationToPod } from './pod-persistence.js';
 import { loadPodBackendCredential, podCredentialMissingMessage } from './pod-ai.js';
 import { resolveAutoModeSecretaryRecommendation } from './secretary.js';
 import { promptText } from '../prompt.js';
 import { runLinxLoginCommand, runLinxLogoutCommand } from '../login-command.js';
-import { clearDefaultPodDataSession } from '../pod-data-session.js';
+import { clearDefaultPodDataSession, createPodDataSession } from '../pod-data-session.js';
+import { parseSolidClientCredentials, persistSolidClientCredentialsLogin } from '../solid-client-credentials-login.js';
 import { connectAiProviderCredential } from '../ai-command.js';
+import { saveAccountSession } from '../account-session.js';
+import { clearCredentials, loadCredentials, saveCredentials } from '../credentials-store.js';
+import { resolveAccountBaseUrl } from '../account-api.js';
+import { createRemoteCompletionResult } from '../chat-api.js';
+import { resolveRuntimeTarget } from '../runtime-target.js';
+import { runThreadReconcilerCycle } from '../../../vendor/agent-runtime/dist/index.js';
+import { createLinxSyncCheckpoint } from '../../../vendor/agent-runtime/dist/sync.js';
 const AUTO_MODE_SECRETARY_COUNTDOWN_BAR_WIDTH = 10;
 const AUTO_MODE_SECRETARY_COUNTDOWN_TICK_MS = 250;
 const POD_PERSISTENCE_TIMEOUT_MS = 5_000;
@@ -26,8 +34,18 @@ export const autoModeRuntime = {
     resolveExistingRemoteAutoModeGrant,
     waitForRemoteAutoModeApproval,
     resolveRemoteAutoModeApproval,
+    materializeRemoteAutoModeGrant,
     persistAutoModeConversationToPod,
     resolveAutoModeSecretaryRecommendation,
+    createPodDataSession,
+    clearDefaultPodDataSession,
+    loadCredentials,
+    saveCredentials,
+    clearCredentials,
+    saveAccountSession,
+    resolveAccountBaseUrl,
+    persistSolidClientCredentialsLogin,
+    createRemoteCompletionResult,
 };
 function createLineSplitter(stream, onLine) {
     let buffer = '';
@@ -72,6 +90,39 @@ function withTimeout(promise, ms, message, onTimeout) {
         });
     });
 }
+function createAbortError(message = 'The operation was aborted.') {
+    const error = new Error(message);
+    error.name = 'AbortError';
+    return error;
+}
+function isAbortError(error) {
+    return error instanceof Error && (error.name === 'AbortError' || error.message.toLowerCase().includes('aborted'));
+}
+function throwIfAborted(signal) {
+    if (!signal?.aborted) {
+        return;
+    }
+    const reason = signal.reason;
+    if (reason instanceof Error) {
+        throw reason;
+    }
+    throw createAbortError(typeof reason === 'string' && reason.trim() ? reason : undefined);
+}
+function withAbortSignal(promise, signal) {
+    if (!signal) {
+        return promise;
+    }
+    throwIfAborted(signal);
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(signal.reason instanceof Error
+            ? signal.reason
+            : createAbortError(typeof signal.reason === 'string' && signal.reason.trim() ? signal.reason : undefined));
+        signal.addEventListener('abort', onAbort, { once: true });
+        promise
+            .then(resolve, reject)
+            .finally(() => signal.removeEventListener('abort', onAbort));
+    });
+}
 function appendEntry(record, stream, line, events) {
     const entry = {
         timestamp: new Date().toISOString(),
@@ -91,6 +142,32 @@ function appendSessionNote(record, message, raw) {
             raw,
         }]);
 }
+function writeFailedPodSyncCheckpoint(record, message) {
+    const now = new Date().toISOString();
+    const result = {
+        source: 'auto-mode-archive',
+        target: 'pod',
+        direction: 'local-to-core',
+        plane: 'projection',
+        authority: 'core',
+        attempted: 0,
+        applied: 0,
+        skipped: 0,
+        failed: 1,
+        failures: [{
+                operationId: 'auto-mode.persist-to-pod',
+                message,
+                failedAt: now,
+            }],
+        startedAt: now,
+        completedAt: now,
+        status: 'failed',
+    };
+    writeAutoModeSyncCheckpoint(record, createLinxSyncCheckpoint('auto-mode-archive:pod:projection', result, {
+        sessionId: record.id,
+        backend: record.backend,
+    }));
+}
 function appendAndDisplaySessionNote(record, display, message, tone = 'note', raw) {
     appendSessionNote(record, message, raw);
     display.showActivity(message, tone);
@@ -240,15 +317,18 @@ async function promptLinxCloudAuth(display, lines, reason = 'manual') {
         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'] },
+            { label: 'Enter Solid client credentials', value: 'client-credentials', description: 'use LinX Cloud client credentials', shortcuts: ['k', '2'] },
+            { label: 'Exit', value: 'exit', description: 'leave this session', shortcuts: ['x', '3'] },
         ])).trim().toLowerCase();
         if (answer === 'browser' || answer === 'b' || answer === '1') {
             await runBackendLinxLogin(display);
             return 'retry';
         }
-        if (answer === 'logout' || answer === 'l' || answer === '2') {
-            runBackendLinxLogout(display);
+        if (answer === 'client-credentials' || answer === 'k' || answer === '2') {
+            const saved = await promptBackendSolidClientCredentials(display);
+            if (saved) {
+                return 'retry';
+            }
             continue;
         }
         if (answer === 'exit' || answer === 'x' || answer === '3' || answer === 'cancel') {
@@ -270,7 +350,7 @@ async function runBackendLinxLogin(display) {
             }
         },
     });
-    clearDefaultPodDataSession();
+    autoModeRuntime.clearDefaultPodDataSession();
     display.showActivity('LinX Cloud login refreshed.', 'success');
 }
 function runBackendLinxLogout(display) {
@@ -284,9 +364,35 @@ function runBackendLinxLogout(display) {
             }
         },
     });
-    clearDefaultPodDataSession();
+    autoModeRuntime.clearDefaultPodDataSession();
     display.showActivity('Use /login or choose browser authorization to sign in again.', 'note');
 }
+async function promptBackendSolidClientCredentials(display) {
+    display.setPhase('question', 'Solid client credentials required');
+    const credentialsText = await display.promptSecret({
+        header: 'Solid client credentials',
+        question: 'Paste Solid client credentials in client_id:client_secret format.',
+        note: 'Input is hidden and saved locally as LinX Cloud client credentials.',
+    });
+    const parsed = parseSolidClientCredentials(credentialsText);
+    if (!parsed) {
+        display.showActivity('Solid client credentials entry cancelled or invalid. Expected client_id:client_secret.', 'error');
+        return false;
+    }
+    autoModeRuntime.clearDefaultPodDataSession();
+    try {
+        await autoModeRuntime.persistSolidClientCredentialsLogin(credentialsText, autoModeRuntime);
+        autoModeRuntime.clearDefaultPodDataSession();
+        display.showActivity('Solid client credentials saved. Retrying backend startup.', 'success');
+        return true;
+    }
+    catch (error) {
+        autoModeRuntime.clearDefaultPodDataSession();
+        const message = error instanceof Error ? error.message : String(error);
+        display.showActivity(`Solid client credentials rejected: ${message}`, 'error');
+        return false;
+    }
+}
 function isRecoverableLinxCloudAuthError(message) {
     const normalized = message.toLowerCase();
     return normalized.includes('linx login')
@@ -300,7 +406,7 @@ function backendProviderLabel(backend) {
     if (backend === 'claude')
         return 'Anthropic';
     if (backend === 'codex')
-        return 'OpenAI/Codex';
+        return 'Codex';
     return 'CodeBuddy';
 }
 function backendProviderId(backend) {
@@ -313,10 +419,24 @@ function backendProviderId(backend) {
 function isMissingProviderCredentialError(backend, message) {
     return message === podCredentialMissingMessage(backend);
 }
-async function promptBackendProviderKey(display, backend) {
+async function promptBackendProviderCredential(display, backend, reason = 'missing') {
     const provider = backendProviderId(backend);
     const label = backendProviderLabel(backend);
-    display.setPhase('question', `${label} API key required`);
+    display.showActivity(`AI Secretary detected ${reason} ${label} credentials.`, 'note');
+    let providerId = provider;
+    if (backend === 'codex') {
+        display.setPhase('question', `${label} ${reason} provider`);
+        const enteredProviderId = await display.chooseQuestion({
+            header: `${label} provider id`,
+            question: 'Enter the provider id for this Codex-compatible API gateway.',
+            options: [],
+            questionIndex: 0,
+            questionCount: 1,
+            unansweredCount: 1,
+        });
+        providerId = enteredProviderId.trim() || provider;
+    }
+    display.setPhase('question', `${label} ${reason} API key`);
     const apiKey = await display.promptSecret({
         header: `${label} key`,
         question: `Enter the ${label} API key to save in your LinX Pod AI settings.`,
@@ -326,8 +446,9 @@ async function promptBackendProviderKey(display, backend) {
         return 'cancel';
     }
     const result = await autoModeRuntime.connectAiProviderCredential({
-        provider,
+        provider: providerId,
         apiKey,
+        ...(backend === 'codex' ? { supportsBackend: 'codex', rotationPolicy: 'round_robin' } : {}),
     });
     display.showActivity(`Saved ${result.providerId} credential to LinX Pod AI settings.`, 'success');
     return 'saved';
@@ -344,33 +465,71 @@ function approvalPromptMessage(request) {
     }
     return request.message || 'Approval required';
 }
+async function materializeAutoModeGrantIfNeeded(input) {
+    if (!shouldMaterializeAutoModeGrant(input.decision)) {
+        return;
+    }
+    await autoModeRuntime.materializeRemoteAutoModeGrant({
+        approvalId: input.approvalId,
+        approvalUri: input.approvalUri,
+        decisionRole: input.decisionRole,
+    }).catch(() => undefined);
+}
 function appendUserTurn(record, text) {
     appendEntry(record, 'system', JSON.stringify({ type: 'user.turn', text }), []);
 }
 function appendTurnStart(record, command, args) {
     appendEntry(record, 'system', JSON.stringify({ type: 'turn.start', command, args }), []);
 }
-function requestedCredentialSource(_options) {
-    return 'cloud';
+function createAcpInteractionThreadEvent(record, interaction) {
+    return {
+        type: interaction.kind === 'user-input' ? 'input.required' : 'approval.required',
+        thread: record.backendSessionId ?? record.id,
+        chat: record.backendSessionId ?? record.id,
+        actor: {
+            id: record.backendSessionId ?? record.backend,
+            role: 'runtime',
+        },
+        data: {
+            requestKind: interaction.kind,
+            backend: record.backend,
+            runtimeSession: record.backendSessionId,
+            businessSession: record.id,
+        },
+    };
+}
+function requestedCredentialSource(options) {
+    return options.credentialSource === 'local' ? 'local' : 'cloud';
 }
-function requestedApprovalSource() {
+function defaultApprovalStrategy() {
     return 'hybrid';
 }
+function resolveApprovalStrategy(options) {
+    return options.approvalStrategy ?? defaultApprovalStrategy();
+}
 function requestedRuntime(options) {
     return options.runtime ?? 'local';
 }
+function requestedAutoEnabled(options) {
+    return options.autoEnabled === true;
+}
 function requestedAutoModeMode(options) {
-    return options.autoModeEnabled ? 'auto' : options.mode;
+    if (options.mode === 'auto' || options.mode === 'off') {
+        return options.mode;
+    }
+    return requestedAutoEnabled(options) ? 'auto' : 'off';
+}
+function isAutoModeWorkerBackend(backend) {
+    return backend === 'linx' || backend === 'codex' || backend === 'claude' || backend === 'codebuddy';
+}
+function isAcpAutoModeWorkerBackend(backend) {
+    return backend === 'codex' || backend === 'claude' || backend === 'codebuddy';
 }
 function normalizeBackendCommandEnv(backend, env) {
     if (!env) {
         return undefined;
     }
-    const next = { ...env };
-    if (backend === 'codex' && next.OPENAI_API_KEY && !next.CODEX_API_KEY) {
-        next.CODEX_API_KEY = next.OPENAI_API_KEY;
-    }
-    return next;
+    return { ...env };
 }
 function mergeCommandEnv(backend, commandEnv, planEnv) {
     const normalizedCommandEnv = normalizeBackendCommandEnv(backend, commandEnv);
@@ -387,6 +546,7 @@ function syncRecordFromOptions(record, options, plan) {
         backend: options.backend,
         runtime: requestedRuntime(options),
         mode: requestedAutoModeMode(options),
+        autoEnabled: requestedAutoEnabled(options),
         goalMode: options.goalMode || undefined,
         cwd: options.cwd,
         model: options.model,
@@ -394,10 +554,11 @@ function syncRecordFromOptions(record, options, plan) {
         passthroughArgs: [...options.passthroughArgs],
         credentialSource: requestedCredentialSource(options),
         resolvedCredentialSource: options.resolvedCredentialSource,
-        approvalSource: requestedApprovalSource(),
+        approvalSource: record.approvalSource ?? defaultApprovalStrategy(),
         command: plan.command,
         args: [...plan.args],
-        transport: options.transport ?? 'acp',
+        transport: options.transport ?? (options.backend === 'linx' ? 'native' : 'acp'),
+        metadata: options.metadata ? { ...options.metadata } : undefined,
     };
 }
 function extractAcpSessionId(response) {
@@ -417,10 +578,12 @@ function withResolvedSource(options, resolvedCredentialSource, commandEnv) {
     return {
         ...options,
         mode: requestedAutoModeMode(options),
-        transport: options.transport ?? 'acp',
+        transport: options.transport ?? (options.backend === 'linx' ? 'native' : 'acp'),
         credentialSource: requestedCredentialSource(options),
         resolvedCredentialSource,
-        commandEnv,
+        commandEnv: mergeCommandEnv(options.backend, commandEnv, options.commandEnv),
+        autoEnabled: requestedAutoEnabled(options),
+        approvalStrategy: resolveApprovalStrategy(options),
     };
 }
 async function probeCloudCredentialSource(backend, runtime) {
@@ -438,6 +601,23 @@ async function probeCloudCredentialSource(backend, runtime) {
     }
 }
 export async function resolveAutoRunOptions(options, runtime = autoModeRuntime) {
+    if (options.backend === 'linx') {
+        const session = await runtime.createPodDataSession();
+        if (!session) {
+            throw new Error('No LinX cloud login found. Run `linx login` first.');
+        }
+        await session.close().catch(() => undefined);
+        return {
+            options: withResolvedSource(options, 'cloud'),
+            authPreflight: { state: 'authenticated' },
+        };
+    }
+    if (requestedCredentialSource(options) === 'local') {
+        return {
+            options: withResolvedSource(options, 'local'),
+            authPreflight: await runtime.preflightAutoModeAuth(options.backend),
+        };
+    }
     const { commandEnv } = await probeCloudCredentialSource(options.backend, runtime);
     return {
         options: withResolvedSource(options, 'cloud', commandEnv),
@@ -454,9 +634,9 @@ class BaseSession {
     activeCloseResolve = null;
     closed = false;
     lastExit = null;
-    constructor(record, prompt) {
+    constructor(record, prompt, options = {}) {
         this.record = record;
-        this.display = createAutoModeDisplay(record, prompt);
+        this.display = createAutoModeDisplay(record, prompt, { quiet: options.quiet });
     }
     spawnProcess(command, args, cwd, env) {
         this.activeExitPromise = new Promise((resolve) => {
@@ -540,6 +720,17 @@ class BaseSession {
         }
         return Promise.resolve(this.lastExit ?? { code: null, signal: null });
     }
+    async abort() {
+        this.closed = true;
+        const child = this.child;
+        if (!child) {
+            return;
+        }
+        if (child.exitCode === null && child.signalCode === null) {
+            child.kill('SIGTERM');
+        }
+        await this.waitForActiveClose();
+    }
     async close() {
         this.closed = true;
         const child = this.child;
@@ -573,7 +764,9 @@ class AcpSession extends BaseSession {
     activeAgentRequests = 0;
     constructor(options, hook) {
         const plan = hook.buildSpawnPlan(options);
-        super(createAutoModeSession({ ...options, transport: options.transport ?? 'acp' }, plan), autoModeRuntime.promptText);
+        super(createAutoModeSession({ ...options, transport: options.transport ?? 'acp' }, plan), autoModeRuntime.promptText, {
+            quiet: options.quiet === true,
+        });
         this.hook = hook;
         this.options = options;
     }
@@ -860,13 +1053,7 @@ class AcpSession extends BaseSession {
                 this.sendError(id, -32601, `Unsupported ACP client request: ${method}`);
                 return;
             }
-            if (interaction.kind === 'user-input') {
-                const result = await this.resolveToolUserInput(interaction);
-                this.sendResponse(id, result);
-                return;
-            }
-            const decision = await this.resolveApproval(interaction);
-            this.sendResponse(id, buildAcpPermissionResponse(interaction, decision));
+            this.sendResponse(id, await this.resolveInteraction(interaction));
         }
         catch (error) {
             const messageText = error instanceof Error ? error.message : String(error);
@@ -877,6 +1064,68 @@ class AcpSession extends BaseSession {
             this.scheduleTurnSettle();
         }
     }
+    async resolveInteraction(interaction) {
+        let result;
+        let wakeError;
+        const autoEnabled = this.record.autoEnabled === true;
+        const cycle = await runThreadReconcilerCycle({
+            policy: {
+                kind: autoEnabled ? 'auto' : 'direct',
+                secretaryAgent: '__secretary__',
+            },
+            handleWakeJob: async ({ decisionSummary, record }) => {
+                try {
+                    result = await this.resolveInteractionDirect(interaction);
+                    return {
+                        requestKind: interaction.kind,
+                        responseKind: interaction.kind === 'user-input' ? 'user-input' : 'approval',
+                        reconciler: decisionSummary.id,
+                        wakeJob: record.key,
+                    };
+                }
+                catch (error) {
+                    wakeError = error;
+                    throw error;
+                }
+            },
+            event: createAcpInteractionThreadEvent(this.record, interaction),
+            dispatchOptions: {
+                randomId: `acp-${interaction.kind}-${Date.now()}`,
+            },
+            onDispatched: (dispatch) => {
+                appendSessionNote(this.record, `Thread Reconciler dispatched ${interaction.kind}`, {
+                    requestKind: interaction.kind,
+                    reconciler: dispatch.summary,
+                    scheduler: {
+                        wakeRecords: dispatch.wakeRecordSummaries,
+                    },
+                });
+                if (dispatch.summary.wakeJobs.length === 0) {
+                    result = this.resolveInteractionDirect(interaction);
+                }
+            },
+        });
+        result = await result;
+        appendSessionNote(this.record, `Thread Reconciler resolved ${interaction.kind}`, {
+            requestKind: interaction.kind,
+            reconciler: cycle.summary,
+            scheduler: cycle.schedulerSummary,
+        });
+        if (cycle.schedulerSummary.failed.length > 0) {
+            throw wakeError ?? new Error(String(cycle.schedulerSummary.failed[0]?.error ?? 'AI Secretary interaction wake job failed'));
+        }
+        if (result === undefined) {
+            throw new Error('AI Secretary was not awakened for ACP interaction.');
+        }
+        return result;
+    }
+    async resolveInteractionDirect(interaction) {
+        if (interaction.kind === 'user-input') {
+            return this.resolveToolUserInput(interaction);
+        }
+        const decision = await this.resolveApproval(interaction);
+        return buildAcpPermissionResponse(interaction, decision);
+    }
     async resolveToolUserInput(interaction) {
         const recommendation = await this.resolveSecretaryRecommendation(interaction);
         const answers = await this.resolveToolUserInputAnswers(interaction.questions, recommendation?.kind === 'user-input' ? recommendation : null);
@@ -919,6 +1168,18 @@ class AcpSession extends BaseSession {
         return this.display.chooseQuestions(questions);
     }
     async resolveApproval(interaction) {
+        const recommendation = await this.resolveSecretaryRecommendation(interaction);
+        const approvalRecommendation = recommendation?.kind === interaction.kind
+            ? recommendation
+            : null;
+        const approvalStrategy = resolveApprovalStrategy(this.options);
+        if (approvalStrategy === 'local') {
+            const promptMessage = approvalPromptMessage(interaction);
+            const decision = await promptApprovalWithRecommendation(this.display, promptMessage, approvalRecommendation);
+            appendSessionNote(this.record, `Local approval resolved | ${decision}`);
+            this.display.setPhase('running', 'Continuing turn');
+            return decision;
+        }
         const granted = await autoModeRuntime.resolveExistingRemoteAutoModeGrant({
             record: this.record,
             request: interaction,
@@ -929,12 +1190,14 @@ class AcpSession extends BaseSession {
             this.display.setPhase('running', 'Continuing turn');
             return granted;
         }
-        const recommendation = await this.resolveSecretaryRecommendation(interaction);
-        return this.resolveHybridApproval(interaction, recommendation?.kind === interaction.kind ? recommendation : null);
+        if (approvalStrategy === 'remote') {
+            return this.resolveRemoteOnlyApproval(interaction, approvalRecommendation);
+        }
+        return this.resolveHybridApproval(interaction, approvalRecommendation);
     }
     async resolveSecretaryRecommendation(interaction) {
         return autoModeRuntime.resolveAutoModeSecretaryRecommendation({
-            mode: this.options.mode,
+            mode: requestedAutoModeMode(this.options),
             record: this.record,
             request: interaction,
         }).catch(() => null);
@@ -954,6 +1217,11 @@ class AcpSession extends BaseSession {
         void remoteDecisionPromise.catch(() => undefined);
         if (!recommendation?.canAutoDecide || !recommendation.decision) {
             const decision = await remoteDecisionPromise;
+            await materializeAutoModeGrantIfNeeded({
+                approvalId: remote.id,
+                approvalUri: remote.approvalUri,
+                decision,
+            });
             appendSessionNote(this.record, `Remote approval resolved | ${decision}`);
             this.display.setPhase('running', 'Continuing turn');
             return decision;
@@ -973,6 +1241,12 @@ class AcpSession extends BaseSession {
                 return recommendation.decision;
             }),
         ]);
+        await materializeAutoModeGrantIfNeeded({
+            approvalId: remote.id,
+            approvalUri: remote.approvalUri,
+            decision,
+            decisionRole: recommendation?.canAutoDecide ? 'secretary' : undefined,
+        });
         appendSessionNote(this.record, `Remote approval resolved | ${decision}`);
         this.display.setPhase('running', 'Continuing turn');
         return decision;
@@ -1021,11 +1295,23 @@ class AcpSession extends BaseSession {
                     note: secretaryAutoResolved
                         ? (recommendation?.reason ?? 'resolved by AI secretary')
                         : 'resolved from active local auto-mode session',
-                }).catch(() => undefined);
+                })
+                    .then(() => materializeAutoModeGrantIfNeeded({
+                    approvalId: remoteApproval.id,
+                    approvalUri: remoteApproval.approvalUri,
+                    decision: winner.decision,
+                    decisionRole: secretaryAutoResolved ? 'secretary' : 'human',
+                }))
+                    .catch(() => undefined);
                 this.display.setPhase('running', 'Continuing turn');
                 return winner.decision;
             }
             localAbort.abort();
+            await materializeAutoModeGrantIfNeeded({
+                approvalId: remoteApproval.id,
+                approvalUri: remoteApproval.approvalUri,
+                decision: winner.decision,
+            });
             appendSessionNote(this.record, `Remote approval resolved | ${winner.decision}`);
             this.display.setPhase('running', 'Continuing turn');
             return winner.decision;
@@ -1089,7 +1375,124 @@ class AcpSession extends BaseSession {
         }
     }
 }
+class LinxNativeSession extends BaseSession {
+    options;
+    podSession = null;
+    constructor(options) {
+        super(createAutoModeSession({ ...options, transport: 'native' }, buildLinxNativeSpawnPlan(options)), autoModeRuntime.promptText, {
+            quiet: options.quiet === true,
+        });
+        this.options = options;
+    }
+    async start() {
+        const podSession = await autoModeRuntime.createPodDataSession();
+        if (!podSession) {
+            throw new Error('No LinX cloud login found. Run `linx login` first.');
+        }
+        this.podSession = podSession;
+        this.updateRecord({
+            backendSessionId: this.record.id,
+            transport: 'native',
+            resolvedCredentialSource: 'cloud',
+            error: undefined,
+        });
+        appendSessionNote(this.record, `LinX native worker connected as ${podSession.webId}`);
+    }
+    applyResolvedOptions(options) {
+        this.options = {
+            ...options,
+            transport: 'native',
+        };
+        this.updateRecord(syncRecordFromOptions(this.record, this.options, buildLinxNativeSpawnPlan(this.options)));
+    }
+    async setModel(model) {
+        const normalized = model.trim();
+        if (!normalized) {
+            throw new Error('Model id cannot be empty');
+        }
+        this.options = {
+            ...this.options,
+            model: normalized,
+        };
+        this.updateRecord({
+            model: normalized,
+        });
+        appendSessionNote(this.record, `LinX native worker model set to ${normalized}`);
+    }
+    async sendTurn(text) {
+        const podSession = this.podSession;
+        if (!podSession) {
+            throw new Error('LinX native session is not initialized');
+        }
+        appendUserTurn(this.record, text);
+        appendTurnStart(this.record, this.record.command, this.record.args);
+        const result = await autoModeRuntime.createRemoteCompletionResult({
+            runtimeUrl: resolveRuntimeTarget({ issuerUrl: podSession.credentials.url }).runtimeUrl,
+            authSession: podSession,
+            model: this.options.model,
+            messages: [{ role: 'user', content: text }],
+            signal: this.options.signal,
+        });
+        this.recordLinxCompletion(result);
+    }
+    onProcessExit() { }
+    onProcessFailure() { }
+    async abort() {
+        await this.close();
+    }
+    async close() {
+        const session = this.podSession;
+        this.podSession = null;
+        await session?.close().catch(() => undefined);
+        await super.close();
+    }
+    recordLinxCompletion(result) {
+        const content = result.content.trim();
+        const toolEvents = result.toolCalls.map((toolCall) => ({
+            type: 'tool.call',
+            name: toolCall.function.name,
+            arguments: parseLinxToolCallArguments(toolCall.function.arguments),
+            raw: toolCall,
+        }));
+        const events = [
+            ...toolEvents,
+            ...(content ? [{ type: 'assistant.delta', text: content, raw: result }] : []),
+            { type: 'assistant.done', ...(content ? { text: content } : {}), raw: result },
+        ];
+        this.recordParsedLine('stdout', JSON.stringify({
+            type: 'assistant.message',
+            content,
+            ...(result.reasoningContent ? { reasoningContent: result.reasoningContent } : {}),
+            ...(result.finishReason ? { finishReason: result.finishReason } : {}),
+            ...(result.usage ? { usage: result.usage } : {}),
+        }), events);
+    }
+}
+function buildLinxNativeSpawnPlan(_options) {
+    return {
+        command: 'linx-cloud',
+        args: ['chat/completions'],
+    };
+}
+function parseLinxToolCallArguments(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)
+            ? parsed
+            : { value: parsed };
+    }
+    catch {
+        return { raw: value };
+    }
+}
 function buildConversationSession(options) {
+    if (options.backend === 'linx') {
+        return new LinxNativeSession(options);
+    }
     const hook = getAutoModeHook(options.backend);
     return new AcpSession(options, hook);
 }
@@ -1129,24 +1532,14 @@ async function handleAutoModeShellCommand(args) {
         ].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,
-            goalMode: record.goalMode,
-            runtime: record.runtime,
-            transport: record.transport,
-            credentialSource: record.credentialSource,
-            resolvedCredentialSource: record.resolvedCredentialSource,
+    const autoModeRoute = resolveAutoModeCommandRoute(input);
+    if (autoModeRoute) {
+        return handleAutoModeCommandRoute({
+            route: autoModeRoute,
+            session,
+            display,
+            record,
         });
-        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}`);
@@ -1198,7 +1591,97 @@ async function handleAutoModeShellCommand(args) {
     }
     return 'pass';
 }
+function handleAutoModeCommandRoute(args) {
+    const { route, session, display, record } = args;
+    if (route.kind === 'control-command') {
+        return handleAutoModeControlCommand({ route, session, display, record });
+    }
+    return handleAutoModePeerCommand({ route, session, display, record });
+}
+function handleAutoModeControlCommand(args) {
+    const { route, session, display, record } = args;
+    const auto = route.auto;
+    if (!auto || auto.action === 'status') {
+        const enabled = record.autoEnabled === true;
+        appendAndDisplaySessionNote(record, display, `Auto is ${enabled ? 'on' : 'off'}. Use /auto on or /auto off.`);
+        return 'handled';
+    }
+    if (!isAutoModeWorkerBackend(record.backend)) {
+        throw new Error(`Auto control commands cannot run backend ${record.backend}`);
+    }
+    applyAutoModeAutoEnabled(session, record, auto.enabled);
+    appendAndDisplaySessionNote(record, display, `Auto ${auto.enabled ? 'on' : 'off'}: ${auto.enabled ? 'Secretary drives the session and asks when blocked' : 'user drives the session directly'}.`, 'success', { autoEnabled: auto.enabled });
+    if (auto.initialInput) {
+        const projectedRoute = resolveAutoModeCommandRoute(auto.initialInput);
+        if (projectedRoute) {
+            return handleAutoModeCommandRoute({
+                route: projectedRoute,
+                session,
+                display,
+                record,
+            });
+        }
+        return { kind: 'send', text: auto.initialInput };
+    }
+    return 'handled';
+}
+function handleAutoModePeerCommand(args) {
+    const { route, session, display, record } = args;
+    const goalMirror = route.secretaryBehavior?.goalMode;
+    if (goalMirror !== undefined) {
+        applyAutoModeGoalMode(session, record, goalMirror);
+        appendAndDisplaySessionNote(record, display, `Goal command routed to current chat peer; local supervision mirror is ${goalMirror ? 'active' : 'paused'}.`, 'success', { goalMode: goalMirror, peerCommand: route.text });
+    }
+    else {
+        appendAndDisplaySessionNote(record, display, 'Goal command routed to current chat peer.', 'note', { peerCommand: route.text });
+    }
+    return { kind: 'send', text: route.text };
+}
+function applyAutoModeAutoEnabled(session, record, enabled) {
+    session.applyResolvedOptions({
+        backend: record.backend,
+        autoEnabled: enabled,
+        mode: enabled ? 'auto' : 'off',
+        cwd: record.cwd,
+        plain: false,
+        model: record.model,
+        prompt: record.prompt,
+        passthroughArgs: record.passthroughArgs,
+        goalMode: record.goalMode,
+        runtime: record.runtime,
+        transport: record.transport,
+        credentialSource: record.credentialSource,
+        resolvedCredentialSource: record.resolvedCredentialSource,
+        approvalStrategy: resolveApprovalStrategy({ approvalStrategy: record.approvalSource }),
+    });
+    record.autoEnabled = enabled;
+    record.mode = enabled ? 'auto' : 'off';
+}
+function applyAutoModeGoalMode(session, record, enabled) {
+    if (!isAutoModeWorkerBackend(record.backend)) {
+        throw new Error(`Goal peer commands cannot run backend ${record.backend}`);
+    }
+    session.applyResolvedOptions({
+        backend: record.backend,
+        autoEnabled: record.autoEnabled === true,
+        mode: record.mode,
+        cwd: record.cwd,
+        plain: false,
+        model: record.model,
+        prompt: record.prompt,
+        passthroughArgs: record.passthroughArgs,
+        goalMode: enabled,
+        runtime: record.runtime,
+        transport: record.transport,
+        credentialSource: record.credentialSource,
+        resolvedCredentialSource: record.resolvedCredentialSource,
+        approvalStrategy: resolveApprovalStrategy({ approvalStrategy: record.approvalSource }),
+    });
+    record.goalMode = enabled || undefined;
+}
 export const __testHandleAutoModeShellCommand = handleAutoModeShellCommand;
+export const __testPromptLinxCloudAuth = promptLinxCloudAuth;
+export const __testParseSolidClientCredentials = parseSolidClientCredentials;
 export async function runAutoMode(options) {
     const previousPlainEnv = process.env.LINX_BACKEND_PLAIN;
     if (options.plain) {
@@ -1206,18 +1689,39 @@ export async function runAutoMode(options) {
     }
     let fatalError = null;
     let session = null;
+    let abortCleanup = null;
     const requestedOptions = {
         ...options,
         runtime: requestedRuntime(options),
-        transport: 'acp',
+        transport: (options.transport ?? (options.backend === 'linx' ? 'native' : 'acp')),
         mode: requestedAutoModeMode(options),
+        autoEnabled: requestedAutoEnabled(options),
         credentialSource: requestedCredentialSource(options),
+        approvalStrategy: resolveApprovalStrategy(options),
     };
     try {
+        throwIfAborted(requestedOptions.signal);
         session = buildConversationSession(requestedOptions);
         const activeSession = session;
+        if (requestedOptions.signal) {
+            const abortRun = () => {
+                const reason = requestedOptions.signal?.reason;
+                const error = reason instanceof Error
+                    ? reason
+                    : createAbortError(typeof reason === 'string' && reason.trim() ? reason : 'Auto-mode run aborted');
+                fatalError ??= error;
+                void activeSession.abort().catch(() => undefined);
+            };
+            if (requestedOptions.signal.aborted) {
+                abortRun();
+            }
+            else {
+                requestedOptions.signal.addEventListener('abort', abortRun, { once: true });
+                abortCleanup = () => requestedOptions.signal?.removeEventListener('abort', abortRun);
+            }
+        }
+        throwIfAborted(requestedOptions.signal);
         activeSession.display.start();
-        activeSession.display.showHelp();
         activeSession.display.setPhase('starting', `Preparing ${requestedOptions.backend}`);
         activeSession.display.updateQueue({
             steeringCount: 0,
@@ -1226,10 +1730,15 @@ export async function runAutoMode(options) {
         let resolvedRun;
         for (let attempt = 0;; attempt += 1) {
             try {
-                resolvedRun = await resolveAutoRunOptions(requestedOptions);
+                throwIfAborted(requestedOptions.signal);
+                resolvedRun = await withAbortSignal(resolveAutoRunOptions(requestedOptions), requestedOptions.signal);
+                throwIfAborted(requestedOptions.signal);
                 break;
             }
             catch (error) {
+                if (isAbortError(error)) {
+                    throw error;
+                }
                 const message = error instanceof Error ? error.message : String(error);
                 appendEntry(activeSession.record, 'system', JSON.stringify({
                     type: 'credentials.resolve',
@@ -1237,11 +1746,20 @@ export async function runAutoMode(options) {
                     requestedCredentialSource: requestedOptions.credentialSource,
                     error: message,
                 }), []);
-                if (isMissingProviderCredentialError(requestedOptions.backend, message)) {
+                if (isAcpAutoModeWorkerBackend(requestedOptions.backend)
+                    && isMissingProviderCredentialError(requestedOptions.backend, message)) {
+                    if (requestedOptions.quiet) {
+                        throw new Error(`${message} Quiet worker sessions cannot prompt for provider credentials; configure the credential before dispatching Symphony workers.`);
+                    }
                     if (attempt >= 2) {
                         throw error;
                     }
-                    const keyAction = await promptBackendProviderKey(activeSession.display, requestedOptions.backend);
+                    appendEntry(activeSession.record, 'system', JSON.stringify({
+                        type: 'credentials.secretary.repair',
+                        backend: requestedOptions.backend,
+                        reason: 'missing',
+                    }), []);
+                    const keyAction = await promptBackendProviderCredential(activeSession.display, requestedOptions.backend, 'missing');
                     if (keyAction !== 'saved') {
                         throw error;
                     }
@@ -1256,10 +1774,14 @@ export async function runAutoMode(options) {
                     'Re-authorize LinX Cloud, then LinX will retry backend startup.',
                 ], 'startup');
                 if (authAction !== 'retry') {
-                    throw error;
+                    const cancelError = new Error('Backend startup cancelled before LinX Cloud authorization.');
+                    fatalError = cancelError;
+                    appendAndDisplaySessionNote(activeSession.record, activeSession.display, cancelError.message, 'note');
+                    return 1;
                 }
             }
         }
+        throwIfAborted(requestedOptions.signal);
         activeSession.applyResolvedOptions(resolvedRun.options);
         appendEntry(activeSession.record, 'system', JSON.stringify({
             type: 'credentials.resolve',
@@ -1280,7 +1802,8 @@ export async function runAutoMode(options) {
             ]);
             throw new Error(message);
         }
-        await activeSession.start();
+        await withAbortSignal(activeSession.start(), requestedOptions.signal);
+        throwIfAborted(requestedOptions.signal);
         const steeringQueue = [];
         const followUpQueue = [];
         let stopRequested = false;
@@ -1316,6 +1839,28 @@ export async function runAutoMode(options) {
             followUpQueue.length = 0;
             updateQueueState();
         };
+        if (requestedOptions.signal) {
+            const wakeOnAbort = () => {
+                const reason = requestedOptions.signal?.reason;
+                fatalError ??= reason instanceof Error
+                    ? reason
+                    : createAbortError(typeof reason === 'string' && reason.trim() ? reason : 'Auto-mode run aborted');
+                stopRequested = true;
+                clearQueuedSubmissions();
+                resolveWake();
+            };
+            if (requestedOptions.signal.aborted) {
+                wakeOnAbort();
+            }
+            else {
+                requestedOptions.signal.addEventListener('abort', wakeOnAbort, { once: true });
+                const previousCleanup = abortCleanup;
+                abortCleanup = () => {
+                    previousCleanup?.();
+                    requestedOptions.signal?.removeEventListener('abort', wakeOnAbort);
+                };
+            }
+        }
         const restoreQueuedSubmission = () => {
             const restored = steeringQueue.pop() ?? followUpQueue.pop() ?? null;
             updateQueueState();
@@ -1348,11 +1893,20 @@ export async function runAutoMode(options) {
             if (!trimmed) {
                 return;
             }
+            if (requestedOptions.signal?.aborted) {
+                const reason = requestedOptions.signal.reason;
+                fatalError ??= reason instanceof Error
+                    ? reason
+                    : createAbortError(typeof reason === 'string' && reason.trim() ? reason : 'Auto-mode run aborted');
+                stopRequested = true;
+                resolveWake();
+                return;
+            }
             activeSession.display.showUserTurn(trimmed);
             activeSession.display.setPhase('running', `Running ${resolvedRun.options.backend}`);
             activeTurn = activeSession.sendTurn(trimmed)
                 .catch((error) => {
-                fatalError = error instanceof Error ? error : new Error(String(error));
+                fatalError ??= error instanceof Error ? error : new Error(String(error));
             })
                 .finally(() => {
                 activeTurn = null;
@@ -1380,6 +1934,7 @@ export async function runAutoMode(options) {
             if (!trimmed) {
                 return;
             }
+            throwIfAborted(requestedOptions.signal);
             const shellCommand = await handleAutoModeShellCommand({
                 input: trimmed,
                 session: activeSession,
@@ -1401,6 +1956,22 @@ export async function runAutoMode(options) {
                 resolveWake();
                 return;
             }
+            if (shellCommand !== 'pass') {
+                const projectedText = shellCommand.text.trim();
+                if (!projectedText) {
+                    resolveWake();
+                    return;
+                }
+                if (activeTurn) {
+                    enqueueSubmission({
+                        text: projectedText,
+                        mode: submission.mode,
+                    });
+                    return;
+                }
+                runTurn(projectedText);
+                return;
+            }
             if (activeTurn) {
                 enqueueSubmission({
                     text: trimmed,
@@ -1446,17 +2017,24 @@ export async function runAutoMode(options) {
         throw fatalError;
     }
     finally {
+        abortCleanup?.();
         if (session) {
             await session.close();
             const finalRecord = await session.finalizeAndClose(fatalError ? 'failed' : 'completed', fatalError?.message);
             const podSyncAbort = new AbortController();
             const podSyncTimeoutMessage = `timed out after ${POD_PERSISTENCE_TIMEOUT_MS}ms`;
+            const podSyncSignal = options.signal && typeof AbortSignal.any === 'function'
+                ? AbortSignal.any([options.signal, podSyncAbort.signal])
+                : podSyncAbort.signal;
             await withTimeout(autoModeRuntime.persistAutoModeConversationToPod(finalRecord, undefined, {
-                signal: podSyncAbort.signal,
+                signal: podSyncSignal,
             }), POD_PERSISTENCE_TIMEOUT_MS, podSyncTimeoutMessage, () => podSyncAbort.abort(new Error(podSyncTimeoutMessage))).catch((error) => {
                 const message = error instanceof Error ? error.message : String(error);
+                writeFailedPodSyncCheckpoint(finalRecord, message);
                 appendSessionNote(finalRecord, `Pod sync failed | ${message}`, { error: message });
-                process.emitWarning(`LinX auto-mode Pod sync failed: ${message}`);
+                if (!options.quiet) {
+                    process.emitWarning(`LinX auto-mode Pod sync failed: ${message}`);
+                }
             });
         }
         if (options.plain) {
@@ -1478,12 +2056,31 @@ export function loadArchivedAutoModeSession(id) {
 export function loadArchivedAutoModeEvents(id) {
     return loadAutoModeEvents(id);
 }
+export function listArchivedAutoModeSessionsWithPendingSync() {
+    return listAutoModeSessionsWithPendingSync();
+}
+export function hasArchivedAutoModeSessionPendingSync(record) {
+    return hasPendingAutoModeSync(record);
+}
+export async function retryArchivedAutoModePodSync(id) {
+    const record = loadAutoModeSession(id);
+    if (!record) {
+        throw new Error(`Auto-mode session not found: ${id}`);
+    }
+    if (record.status === 'running') {
+        throw new Error(`Auto-mode session is still running: ${id}`);
+    }
+    return autoModeRuntime.persistAutoModeConversationToPod(record);
+}
 export function resumeAutoModeSession(record, options = {}) {
+    if (!isAutoModeWorkerBackend(record.backend)) {
+        throw new Error(`Cannot resume ${record.backend} through the worker auto-mode runner`);
+    }
     const sessionId = record.backendSessionId?.trim() || record.id;
     return runAutoMode({
         backend: record.backend,
+        autoEnabled: record.autoEnabled ?? record.mode === 'auto',
         mode: record.mode,
-        autoModeEnabled: record.mode === 'auto',
         resumeSessionId: sessionId,
         cwd: options.cwd || record.cwd,
         plain: Boolean(options.plain),
@@ -1492,23 +2089,28 @@ export function resumeAutoModeSession(record, options = {}) {
         goalMode: options.goalMode ?? record.goalMode,
         passthroughArgs: [...record.passthroughArgs],
         runtime: record.runtime,
-        transport: record.transport ?? 'acp',
+        transport: record.transport ?? (record.backend === 'linx' ? 'native' : 'acp'),
         credentialSource: record.credentialSource,
         resolvedCredentialSource: record.resolvedCredentialSource,
     });
 }
 export { formatAutoModeSessionSummary };
 export function listSupportedAutoModeBackends() {
-    return listAutoModeHooks().map((hook) => ({
-        backend: hook.id,
-        label: hook.label,
-        description: hook.description,
-        capabilities: hook.capabilities,
-        modes: {
-            manual: describeAutoModeMode('manual'),
-            smart: describeAutoModeMode('smart'),
-            auto: describeAutoModeMode('auto'),
+    return [
+        {
+            backend: linxNativeBackend.backend,
+            label: linxNativeBackend.label,
+            description: linxNativeBackend.description,
+            capabilities: linxNativeBackend.capabilities,
+            auto: describeAutoControl(),
         },
-    }));
+        ...listAutoModeHooks().map((hook) => ({
+            backend: hook.id,
+            label: hook.label,
+            description: hook.description,
+            capabilities: hook.capabilities,
+            auto: describeAutoControl(),
+        })),
+    ];
 }
 //# sourceMappingURL=runner.js.map