@yu_robotics/remote-cli 1.6.170 → 1.6.176

package/dist/executor/CodexAppServerExecutor.js

@@ -38,6 +38,8 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const crypto_1 = require("crypto");
+const CodexGoals_1 = require("./codex/CodexGoals");
+const CodexImages_1 = require("./codex/CodexImages");
 const ExecutionMetadata_1 = require("./ExecutionMetadata");
 const CodexAppServerClient_1 = require("./CodexAppServerClient");
 const CodexTaskNotifications_1 = require("./CodexTaskNotifications");
@@ -50,6 +52,8 @@ const CodexWebSearch_1 = require("./CodexWebSearch");
 const DEFAULT_INACTIVITY_TIMEOUT_MS = 10 * 60 * 1000;
 const DEFAULT_COMPACT_TIMEOUT_MS = 10 * 60 * 1000;
 const ACCOUNT_USAGE_TIMEOUT_MS = 10_000;
+const GOAL_CONTROL_TIMEOUT_MS = 10_000;
+const GOAL_RECOVERY_GUIDANCE = 'Use /goal resume to continue the saved native goal, or /goal pause or /goal clear before sending another task.';
 function formatWindowDuration(minutes) {
     if (!Number.isFinite(minutes) || !minutes || minutes <= 0)
         return 'usage window';
@@ -119,6 +123,9 @@ class CodexAppServerExecutor {
     currentWorkingDirectory;
     model;
     effort;
+    speed;
+    /** Only a fresh legacy thread is known not to carry an older remote speed override. */
+    legacyFollowReady = false;
     reportedModel;
     reportedEffort;
     autoApprove;
@@ -142,6 +149,13 @@ class CodexAppServerExecutor {
     delegationConfigured = false;
     delegationWorker;
     sessionResumeFailure = false;
+    goalManaged = false;
+    goalNeedsResume = false;
+    goalRun = null;
+    goalControl = null;
+    goalControlClear = false;
+    goalTransportStops = 0;
+    threadLoads = 0;
     async configureDelegation(connection) {
         if (this.delegationConfigured && (0, contract_1.sameConnection)(this.delegation, connection))
             return;
@@ -155,6 +169,7 @@ class CodexAppServerExecutor {
     constructor(directoryGuard, options = {}) {
         this.directoryGuard = directoryGuard;
         this.model = options.model;
+        this.speed = options.speed;
         this.effort = options.effort;
         this.autoApprove = options.autoApprove ?? true;
         this.remoteThreadId = options.threadId;
@@ -196,11 +211,13 @@ class CodexAppServerExecutor {
         this.sessionResumeFailure = false;
         if (this.destroyed)
             throw new Error('Executor has been destroyed');
-        if (this.activeTurn || this.compactWaiter) {
+        if (this.isBusy()) {
             return { success: false, error: 'Codex thread is already running a command' };
         }
         try {
             await this.ensureThread();
+            if (this.isBusy())
+                return { success: false, error: 'Codex thread is already running a command' };
         }
         catch (error) {
             return { success: false, error: this.errorMessage(error) };
@@ -211,6 +228,11 @@ class CodexAppServerExecutor {
             // leave the executor busy without an actual app-server turn.
             const sandboxOptions = this.sandbox.turnOptions(this.currentWorkingDirectory);
             const input = await this.buildInput(prompt, options.attachments, temporaryFiles);
+            const speedOptions = await this.speedOptions();
+            if (this.isBusy()) {
+                await this.cleanupTemporaryFiles(temporaryFiles);
+                return { success: false, error: 'Codex thread is already running a command' };
+            }
             return await new Promise((resolve) => {
                 const active = {
                     options,
@@ -221,6 +243,7 @@ class CodexAppServerExecutor {
                     emittedTools: new Map(),
                     itemPhases: new Map(),
                     temporaryFiles,
+                    images: new CodexImages_1.CodexImages(),
                     inactivityTimeoutMs: options.inactivityTimeout,
                 };
                 this.activityTracker.setCallback(options.onActivity);
@@ -238,6 +261,7 @@ class CodexAppServerExecutor {
                     cwd: this.currentWorkingDirectory,
                     ...(this.model ? { model: this.model } : {}),
                     ...(this.effort ? { effort: this.effort } : {}),
+                    ...speedOptions,
                     ...(this.autoApprove ? {
                         approvalPolicy: 'never',
                         sandboxPolicy: { type: 'dangerFullAccess' },
@@ -269,6 +293,337 @@ class CodexAppServerExecutor {
     getCurrentWorkingDirectory() {
         return this.currentWorkingDirectory;
     }
+    isGoalRunning() {
+        return this.goalRun !== null;
+    }
+    /** Reading a saved goal must never materialize or resume its native thread. */
+    async getGoal() {
+        if (this.destroyed)
+            throw new Error('Executor has been destroyed');
+        if (!this.codexThreadId)
+            return null;
+        const threadId = this.codexThreadId;
+        try {
+            await this.goalDeadline(this.client.start());
+            (0, CodexGoals_1.assertNativeGoalsVersion)(this.client.getServerVersion?.());
+            const response = await this.goalRequest('thread/goal/get', { threadId });
+            if (this.codexThreadId !== threadId || this.destroyed)
+                throw new Error('The native goal session changed while reading it.');
+            const goal = (0, CodexGoals_1.parseNativeGoal)(response?.goal, threadId);
+            if (goal && !this.goalManaged)
+                this.rememberGoalManagement();
+            return goal;
+        }
+        catch (error) {
+            throw new Error((0, CodexGoals_1.nativeGoalError)(error));
+        }
+    }
+    async executeGoal(request, options) {
+        try {
+            (0, CodexGoals_1.validateGoalRequest)(request);
+            if (this.destroyed)
+                throw new Error('Executor has been destroyed');
+            if (this.isBusy())
+                throw new Error('Codex thread is already running a command');
+            if (this.delegationWorker || this.delegation)
+                throw new Error('Native goals require managed delegation to be off and cannot run in a delegated worker.');
+            if (request.objective === undefined && !this.codexThreadId)
+                throw new Error('There is no saved native goal to resume.');
+        }
+        catch (error) {
+            return { success: false, error: (0, CodexGoals_1.nativeGoalError)(error) };
+        }
+        let resolve;
+        const done = new Promise(settle => { resolve = settle; });
+        const active = { options, resolve, turnId: null, output: [], sideEffectsStarted: false,
+            emittedTools: new Map(), itemPhases: new Map(), temporaryFiles: [], images: new CodexImages_1.CodexImages(), inactivityTimeoutMs: options.inactivityTimeout };
+        const run = { active, done, objective: request.objective, ready: false, inFlight: new Set(), retired: new Set(),
+            revision: 0, checking: false, controlling: false, stopping: false };
+        // Install ownership before any native loading or mutation can start a turn.
+        this.goalRun = run;
+        this.activeTurn = active;
+        this.activityTracker.setCallback(options.onActivity);
+        this.activityTracker.reset();
+        this.armInactivityTimer();
+        if (options.timeout && options.timeout > 0)
+            active.timeoutTimer = setTimeout(() => {
+                void this.failGoal(run, `Native goal timed out after ${options.timeout}ms. ${GOAL_RECOVERY_GUIDANCE}`);
+            }, options.timeout);
+        run.startup = this.startGoal(run, request).catch(error => this.failGoal(run, (0, CodexGoals_1.nativeGoalError)(error)));
+        return done;
+    }
+    pauseGoal() {
+        return this.controlGoal(false);
+    }
+    clearGoal() {
+        return this.controlGoal(true);
+    }
+    async startGoal(run, request) {
+        await this.goalDeadline(this.client.start());
+        this.assertGoalOwner(run);
+        (0, CodexGoals_1.assertNativeGoalsVersion)(this.client.getServerVersion?.());
+        let previous = null;
+        if (this.codexThreadId) {
+            previous = await this.getGoal();
+            this.assertGoalOwner(run);
+        }
+        if (request.objective === undefined && (!previous || previous.status === 'complete')) {
+            throw new Error('There is no unfinished native goal to resume.');
+        }
+        // Replacing an active saved goal must not briefly execute its old objective on load.
+        if (request.objective !== undefined && previous?.status === 'active' && !this.threadReady) {
+            throw new Error('Pause or clear the saved active goal before replacing its objective.');
+        }
+        run.goal = previous;
+        run.objective = request.objective ?? previous?.objective;
+        this.rememberGoalManagement();
+        if (previous?.status === 'active' && !this.threadReady) {
+            // Loading an active goal can dispatch before settings/update. Suspend it
+            // without loading, then restore activation only after native policy sync.
+            const response = await this.goalRequest('thread/goal/set', {
+                threadId: this.codexThreadId, status: 'paused', origin: 'user',
+            });
+            this.assertGoalOwner(run);
+            const paused = (0, CodexGoals_1.parseNativeGoal)(response?.goal, this.codexThreadId);
+            if (!paused || paused.status !== 'paused')
+                throw new Error('Codex did not pause the saved goal before loading its policies.');
+            run.goal = paused;
+            if (run.controlling)
+                return;
+        }
+        await this.ensureThread();
+        this.assertGoalOwner(run);
+        this.rememberGoalManagement();
+        if (run.controlling)
+            return;
+        // Native continuations bypass turn/start, so their settings must be sticky.
+        const goalPolicy = this.sandbox.turnOptions(this.currentWorkingDirectory);
+        if (this.model || this.effort || this.speed !== undefined || Object.keys(goalPolicy).length) {
+            const speedOptions = await this.speedOptions();
+            this.assertGoalOwner(run);
+            if (run.controlling)
+                return;
+            await this.goalRequest('thread/settings/update', { threadId: this.codexThreadId,
+                ...(this.model ? { model: this.model } : {}), ...(this.effort ? { effort: this.effort } : {}),
+                ...speedOptions, ...goalPolicy });
+            this.assertGoalOwner(run);
+            if (run.controlling)
+                return;
+        }
+        // A resumed active goal may already have completed while the load request ran.
+        if (request.objective !== undefined || run.goal?.status !== 'complete') {
+            const revision = run.revision;
+            const response = await this.goalRequest('thread/goal/set', {
+                threadId: this.codexThreadId, origin: 'user',
+                ...(request.objective !== undefined ? { objective: request.objective } : {}),
+                status: 'active', ...(request.tokenBudget !== undefined ? { tokenBudget: request.tokenBudget } : {}),
+            });
+            this.assertGoalOwner(run);
+            const goal = (0, CodexGoals_1.parseNativeGoal)(response?.goal, this.codexThreadId);
+            if (!goal)
+                throw new Error('Codex did not return the activated native goal.');
+            if (run.revision === revision)
+                run.goal = goal;
+        }
+        run.ready = true;
+        this.goalNeedsResume = false;
+        if (run.goal?.status === 'active') {
+            this.goalNotice(run, run.inFlight.size ? 'Native goal running' : 'Native goal active; waiting for native continuation');
+        }
+        this.maybeCompleteGoal(run);
+        if (this.goalRun === run && !run.inFlight.size)
+            void this.checkGoalAfterTurn(run);
+    }
+    assertGoalOwner(run) {
+        if (this.goalRun !== run || this.destroyed || run.stopping)
+            throw new Error('Native goal operation was cancelled.');
+    }
+    goalNotice(run, text) {
+        const bounded = Array.from(text).slice(0, 400).join('');
+        if (this.goalRun !== run || run.lastNotice === bounded)
+            return;
+        run.lastNotice = bounded;
+        try {
+            if (run.active.options.onActivity)
+                run.active.options.onActivity({ source: 'state', text: bounded });
+            else
+                run.active.options.onStream?.(`\n[${bounded}]\n`);
+        }
+        catch { /* A display failure cannot change native goal ownership. */ }
+    }
+    maybeCompleteGoal(run) {
+        if (this.goalRun !== run || !run.ready || run.controlling || run.stopping || run.inFlight.size
+            || run.goal === undefined || run.goal?.status === 'active')
+            return;
+        const status = run.goal?.status ?? 'cleared';
+        this.goalNotice(run, `Native goal ${status}`);
+        const summary = `\n\nNative goal ${status}.\n`;
+        run.active.output.push(summary);
+        try {
+            run.active.options.onStream?.(summary);
+        }
+        catch { /* Native completion still releases ownership. */ }
+        try {
+            run.active.options.onDisplayText?.(summary);
+        }
+        catch { /* Native completion still releases ownership. */ }
+        this.completeActive({ success: status === 'complete' || status === 'paused' || status === 'cleared',
+            output: run.active.output.join(''), sessionAbbr: this.codexThreadId?.slice(0, 8),
+            ...(['blocked', 'usageLimited', 'budgetLimited'].includes(status) ? { error: `Native goal stopped: ${status}.` } : {}) });
+    }
+    async checkGoalAfterTurn(run) {
+        if (this.goalRun !== run || run.checking || run.controlling || run.stopping)
+            return;
+        run.checking = true;
+        const revision = run.revision;
+        try {
+            const goal = await this.getGoal();
+            if (this.goalRun !== run || run.controlling || run.stopping)
+                return;
+            if (revision === run.revision)
+                run.goal = goal;
+            this.maybeCompleteGoal(run);
+        }
+        catch (error) {
+            if (this.goalRun === run)
+                await this.failGoal(run, `Could not reconcile native goal: ${(0, CodexGoals_1.nativeGoalError)(error)}`);
+        }
+        finally {
+            run.checking = false;
+        }
+    }
+    goalDeadline(promise) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error('Native goal control timed out.')), GOAL_CONTROL_TIMEOUT_MS);
+            promise.then(value => { clearTimeout(timer); resolve(value); }, error => { clearTimeout(timer); reject(error); });
+        });
+    }
+    goalRequest(method, params) {
+        if (this.destroyed)
+            return Promise.reject(new Error('Executor has been destroyed'));
+        return this.goalDeadline(this.client.request(method, params, GOAL_CONTROL_TIMEOUT_MS));
+    }
+    async stopGoalTransport() {
+        this.threadReady = false;
+        this.goalNeedsResume = this.goalManaged;
+        this.goalTransportStops++;
+        try {
+            await this.goalDeadline(this.client.stop());
+            if (this.client.waitForExit)
+                await this.goalDeadline(this.client.waitForExit());
+            else if (this.client.isRunning())
+                throw new Error('Codex goal process exit could not be confirmed.');
+        }
+        finally {
+            this.goalTransportStops--;
+        }
+    }
+    async failGoal(run, error) {
+        if (this.goalRun !== run || run.stopping)
+            return;
+        run.stopping = true;
+        this.clearInactivityTimer();
+        if (run.active.timeoutTimer)
+            clearTimeout(run.active.timeoutTimer);
+        try {
+            await this.stopGoalTransport();
+            if (this.goalRun === run)
+                this.completeActive({ success: false, error });
+        }
+        catch (stopError) {
+            run.stopping = false;
+            this.goalNotice(run, `Native goal stop unconfirmed: ${(0, CodexGoals_1.nativeGoalError)(stopError)}. Retry /abort.`);
+        }
+    }
+    controlGoal(clear) {
+        if (this.goalControl) {
+            if (this.goalControlClear === clear)
+                return this.goalControl;
+            return this.goalControl.then(result => result.success ? this.controlGoal(clear) : result);
+        }
+        const control = this.stopGoalControl(this.goalRun, clear);
+        this.goalControl = control;
+        this.goalControlClear = clear;
+        void control.then(() => { if (this.goalControl === control)
+            this.goalControl = null; });
+        return control;
+    }
+    async stopGoalControl(run, clear) {
+        if (this.destroyed)
+            return { success: false, error: 'Executor has been destroyed' };
+        if (!run && (this.activeTurn || this.compactWaiter || this.threadLoads)) {
+            return { success: false, error: 'Wait for the current ordinary task before changing its goal.' };
+        }
+        if (!this.codexThreadId && !run)
+            return { success: true, output: 'No native goal is set.' };
+        if (run)
+            run.controlling = true;
+        try {
+            if (run?.startup)
+                await this.goalDeadline(run.startup);
+            if (run && this.goalRun !== run)
+                return { success: false, error: 'The native goal run already stopped.' };
+            await this.goalDeadline(this.client.start());
+            (0, CodexGoals_1.assertNativeGoalsVersion)(this.client.getServerVersion?.());
+            const threadId = this.codexThreadId;
+            if (!threadId)
+                throw new Error('No native goal session was created.');
+            this.rememberGoalManagement();
+            const existing = await this.getGoal();
+            let goal = existing;
+            if (existing && existing.status !== 'complete') {
+                const paused = await this.goalRequest('thread/goal/set', { threadId, status: 'paused', origin: 'user' });
+                goal = (0, CodexGoals_1.parseNativeGoal)(paused?.goal, threadId);
+                if (!goal || goal.status === 'active')
+                    throw new Error('Codex did not confirm that the native goal is paused.');
+            }
+            if (clear && existing) {
+                const response = await this.goalRequest('thread/goal/clear', { threadId, origin: 'user' });
+                if (typeof response?.cleared !== 'boolean')
+                    throw new Error('Codex did not confirm clearing the native goal.');
+                goal = null;
+            }
+            if (run) {
+                run.goal = goal;
+                for (const pending of this.pendingUserInputs.splice(0)) {
+                    this.finishApproval(pending, 'expired');
+                    this.client.respond(pending.id, pending.method === 'item/tool/requestUserInput' ? { answers: {} }
+                        : pending.method === 'item/permissions/requestApproval' ? { permissions: {}, scope: 'turn' } : { decision: 'cancel' });
+                }
+                for (const turnId of [...run.inFlight])
+                    await this.goalRequest('turn/interrupt', { threadId, turnId });
+                if (run.inFlight.size)
+                    await this.goalDeadline(new Promise(resolve => { run.onIdle = resolve; }));
+                if (this.goalRun !== run)
+                    throw new Error('The native goal stopped before its control operation finished.');
+            }
+            // A late dispatched continuation must not outlive a successful stop ACK.
+            // Reopening this process is safe because native state is now paused/cleared.
+            await this.stopGoalTransport();
+            this.goalNeedsResume = false;
+            if (run) {
+                if (this.goalRun !== run)
+                    throw new Error('The native goal stopped before its control operation finished.');
+                run.inFlight.clear();
+                run.ready = true;
+                run.controlling = false;
+                this.maybeCompleteGoal(run);
+                const result = await this.goalDeadline(run.done);
+                if (!result.success)
+                    throw new Error(result.error ?? 'Native goal did not stop successfully.');
+            }
+            return { success: true, output: clear ? 'Native goal cleared; execution stopped.'
+                    : goal?.status === 'complete' ? 'Native goal was already complete; execution stopped.'
+                        : goal ? 'Native goal paused; execution stopped.' : 'No native goal is set; execution stopped.' };
+        }
+        catch (error) {
+            if (run && this.goalRun === run) {
+                run.controlling = false;
+                await this.failGoal(run, `Native goal control failed: ${(0, CodexGoals_1.nativeGoalError)(error)}. ${GOAL_RECOVERY_GUIDANCE}`);
+            }
+            return { success: false, error: (0, CodexGoals_1.nativeGoalError)(error) };
+        }
+    }
     getExecutionMetadata() {
         const data = (0, ExecutionMetadata_1.configuredExecutionMetadata)(this.model, this.effort);
         if (this.threadReady && this.client.isRunning() && this.reportedModel) {
@@ -288,7 +643,7 @@ class CodexAppServerExecutor {
             this.reportedEffort = response.reasoningEffort;
     }
     isBusy() {
-        return this.activeTurn !== null || this.compactWaiter !== null;
+        return this.activeTurn !== null || this.compactWaiter !== null || this.goalControl !== null || this.threadLoads > 0;
     }
     async setWorkingDirectory(targetPath) {
         const resolved = this.directoryGuard.resolveWorkingDirectory(targetPath, this.currentWorkingDirectory);
@@ -341,6 +696,8 @@ class CodexAppServerExecutor {
         }
     }
     resetContext() {
+        if (this.goalRun)
+            throw new Error('Stop the native goal before clearing its conversation.');
         this.taskNotifications.clear();
         const previousId = this.codexThreadId;
         if (this.activeTurn || this.compactWaiter) {
@@ -349,6 +706,8 @@ class CodexAppServerExecutor {
             void this.client.stop();
         }
         this.codexThreadId = null;
+        this.goalManaged = false;
+        this.goalNeedsResume = false;
         this.threadReady = false;
         this.pendingUserInputs = [];
         this.clearThreadId();
@@ -357,6 +716,8 @@ class CodexAppServerExecutor {
         }
     }
     async abort() {
+        if (this.goalRun)
+            return (await this.pauseGoal()).success;
         const active = this.activeTurn;
         if (!active || !this.codexThreadId)
             return false;
@@ -384,12 +745,17 @@ class CodexAppServerExecutor {
         return true;
     }
     async destroy() {
-        if (this.destroyed)
+        if (this.destroyed && !this.goalRun)
             return;
         this.destroyed = true;
         this.taskNotifications.clear();
         this.unsubscribeClient?.();
         this.unsubscribeClient = null;
+        if (this.goalRun) {
+            this.goalRun.stopping = true;
+            this.clearInactivityTimer();
+            await this.stopGoalTransport();
+        }
         if (this.activeTurn)
             this.completeActive({ success: false, error: 'Executor destroyed' });
         this.completeCompact({ success: false, error: 'Executor destroyed' });
@@ -505,15 +871,22 @@ class CodexAppServerExecutor {
     }
     async listModels() {
         await this.refreshModelCatalogAfterCommandUpgrade();
+        return this.readModelCatalog();
+    }
+    async readModelCatalog() {
         const models = [];
         let cursor = null;
         const currentModelId = this.reportedModel ?? this.model;
         do {
-            const response = await this.client.request('model/list', {
+            const owner = this.goalRun;
+            const params = {
                 cursor,
                 limit: 100,
                 includeHidden: false,
-            });
+            };
+            const response = await (owner ? this.goalRequest('model/list', params) : this.client.request('model/list', params));
+            if (owner)
+                this.assertGoalOwner(owner);
             for (const model of Array.isArray(response?.data) ? response.data : []) {
                 if (typeof model?.id !== 'string')
                     continue;
@@ -530,6 +903,11 @@ class CodexAppServerExecutor {
                         ? model.defaultReasoningEffort
                         : undefined,
                     inputModalities: Array.isArray(model.inputModalities) ? model.inputModalities : undefined,
+                    ...(Array.isArray(model.serviceTiers) && model.serviceTiers.length <= 32
+                        && model.serviceTiers.every((tier) => tier && this.validSpeedValue(tier.id) && this.validSpeedValue(tier.name)
+                            && (tier.description === undefined || (typeof tier.description === 'string' && tier.description.length <= 4096)))
+                        ? { serviceTiers: model.serviceTiers.map((tier) => ({ id: tier.id, name: tier.name, description: tier.description })),
+                            ...(model.defaultServiceTier === null || this.validSpeedValue(model.defaultServiceTier) ? { defaultServiceTier: model.defaultServiceTier } : {}) } : {}),
                 });
             }
             cursor = typeof response?.nextCursor === 'string' ? response.nextCursor : null;
@@ -582,6 +960,10 @@ class CodexAppServerExecutor {
             if (!selected) {
                 return { success: false, error: `Unknown Codex model: ${model}. Use /model to list available models.` };
             }
+            if (typeof this.speed === 'string' && (!selected.serviceTiers?.length
+                || (this.speed !== 'default' && !selected.serviceTiers.some(tier => tier.id === this.speed)))) {
+                return { success: false, error: 'The saved speed is incompatible with this model. Follow native config in the Speed section before changing models.' };
+            }
             if (this.effort && !selected.supportedReasoningEfforts?.includes(this.effort)) {
                 return { success: false, error: 'The saved reasoning effort is incompatible with this model. Reset /effort auto before changing models.' };
             }
@@ -595,10 +977,157 @@ class CodexAppServerExecutor {
         }
     }
     clearModel() {
+        if (typeof this.speed === 'string')
+            throw new Error('Follow native config in the Speed section before clearing the model override.');
         this.model = undefined;
         this.reportedModel = undefined;
         this.reportedEffort = undefined;
     }
+    validSpeedValue(value) {
+        return typeof value === 'string' && value.length > 0 && value.length <= 512 && !/[\x00-\x1f\x7f]/.test(value);
+    }
+    async listSpeeds(models) {
+        const catalog = models ?? await this.listModels();
+        const recovery = this.speed !== undefined ? { choices: [], current: this.speed ?? undefined } : undefined;
+        // Do not add config RPCs to legacy catalogs or to models with no tier choices.
+        if (!catalog.some(model => model.serviceTiers?.length))
+            return recovery;
+        let id = this.reportedModel ?? this.model;
+        if (!id) {
+            try {
+                id = (await this.readNativeSpeedConfig()).model;
+            }
+            catch (error) {
+                // A failed native query must not turn a catalog default into an offer of
+                // paid speed. A saved override can still be cleared without discovery.
+                if (recovery)
+                    return recovery;
+                throw error;
+            }
+        }
+        const selected = id ? catalog.find(model => model.id === id) : catalog.find(model => model.isDefault);
+        if (!selected?.serviceTiers?.length)
+            return recovery;
+        const choices = [{ value: 'default', displayName: 'Standard', description: 'Use standard processing.' },
+            ...selected.serviceTiers.filter(tier => tier.id !== 'default').map(tier => ({ value: tier.id, displayName: tier.name, description: tier.description }))];
+        return { choices, current: this.speed ?? undefined, default: selected.defaultServiceTier };
+    }
+    async assertReportedSpeed(speed) {
+        if (!this.reportedModel)
+            return;
+        const owner = this.goalRun;
+        const catalog = await (owner ? this.goalDeadline(this.readModelCatalog()) : this.readModelCatalog());
+        if (owner)
+            this.assertGoalOwner(owner);
+        const selected = catalog.find(model => model.id === this.reportedModel);
+        if (!selected?.serviceTiers?.length || (speed !== 'default' && !selected.serviceTiers.some(tier => tier.id === speed))) {
+            throw new Error('This speed is unavailable for the model reported by Codex. Follow native config in /model before starting work.');
+        }
+    }
+    async speedOptions(speed = this.speed) {
+        if (speed === undefined)
+            return {};
+        if (speed !== null)
+            return { serviceTier: speed };
+        // Avoid the public upgrade check while preparing a turn: replacing the
+        // transport here would discard the native thread just loaded by ensureThread.
+        const catalog = await this.readModelCatalog();
+        if (!catalog.some(model => model.serviceTiers !== undefined)) {
+            if (this.codexThreadId && !(this.threadReady && this.legacyFollowReady)) {
+                throw new Error('This Codex version cannot safely clear the speed of a saved conversation. Upgrade Codex or use /clear before resuming.');
+            }
+            // Old protocols must never receive unsupported serviceTier keys. A fresh
+            // thread can safely use native startup configuration without an override.
+            return {};
+        }
+        const config = await this.readNativeSpeedConfig();
+        const id = this.reportedModel ?? this.model ?? config.model;
+        const selected = id ? catalog.find(model => model.id === id) : catalog.find(model => model.isDefault);
+        if (config.tier === 'fast' || config.tier === 'priority') {
+            const fast = selected?.serviceTiers?.find(tier => tier.id === 'priority')
+                ?? selected?.serviceTiers?.find(tier => tier.id === 'fast');
+            return { serviceTier: config.fastMode && fast ? fast.id : null };
+        }
+        if (config.tier !== null && config.tier !== 'default' && config.tier !== 'flex'
+            && !selected?.serviceTiers?.some(tier => tier.id === config.tier)) {
+            throw new Error('Codex configured speed is unavailable for the selected model. Check native configuration before resuming.');
+        }
+        return { serviceTier: config.tier };
+    }
+    async readNativeSpeedConfig() {
+        const owner = this.goalRun;
+        const params = { includeLayers: false, cwd: this.currentWorkingDirectory };
+        const response = await (owner ? this.goalRequest('config/read', params) : this.client.request('config/read', params));
+        if (owner)
+            this.assertGoalOwner(owner);
+        if (!response?.config || typeof response.config !== 'object')
+            throw new Error('Codex did not provide its native speed configuration.');
+        const native = response.config.service_tier;
+        if (native !== undefined && native !== null && !this.validSpeedValue(native))
+            throw new Error('Codex returned an invalid native speed setting.');
+        const model = response.config.model;
+        if (model !== undefined && model !== null && !this.validSpeedValue(model))
+            throw new Error('Codex returned an invalid configured model.');
+        const features = response.config.features;
+        if (features !== undefined && (features === null || typeof features !== 'object' || Array.isArray(features)))
+            throw new Error('Codex returned invalid native speed features.');
+        const fastMode = features?.fast_mode;
+        if (fastMode !== undefined && typeof fastMode !== 'boolean')
+            throw new Error('Codex returned an invalid native Fast mode setting.');
+        return { model: model ?? undefined, tier: native ?? null, fastMode: fastMode !== false };
+    }
+    async setSpeed(speed) {
+        try {
+            const cwd = this.currentWorkingDirectory, threadId = this.codexThreadId;
+            const assertCurrent = () => {
+                if (this.isBusy() || this.destroyed || cwd !== this.currentWorkingDirectory || threadId !== this.codexThreadId)
+                    throw new Error('The Codex thread changed during speed selection.');
+            };
+            if (this.isBusy() || this.destroyed)
+                throw new Error('The Codex thread must be idle to change speed.');
+            if (speed === undefined) {
+                // Reset is recovery, not another selection. Never load a saved thread
+                // through its obsolete tier, nor resume suspended native goals here.
+                this.threadReady = false;
+                this.legacyFollowReady = false;
+                this.threadLoads++;
+                try {
+                    await this.client.stop();
+                    await this.client.waitForExit?.();
+                }
+                finally {
+                    this.threadLoads--;
+                }
+                assertCurrent();
+                this.speed = null;
+                return { success: true, output: 'Speed follows native configuration on the next safe resume. Older Codex versions may require an upgrade or /clear.' };
+            }
+            const choices = await this.listSpeeds();
+            assertCurrent();
+            if (!choices || !choices.choices.some(choice => choice.value === speed)) {
+                throw new Error('This speed is unavailable for the current Codex model. Refresh /model.');
+            }
+            if (this.isBusy() || this.destroyed)
+                throw new Error('The Codex thread changed during speed selection.');
+            if (this.codexThreadId && !(this.goalManaged && this.goalNeedsResume)) {
+                await this.ensureThread();
+                assertCurrent();
+                // Restored conversations can report a different model than the preview.
+                await this.assertReportedSpeed(speed);
+                assertCurrent();
+                // Explicit selections may update a live thread. Follow never loads it.
+                const { serviceTier } = await this.speedOptions(speed);
+                assertCurrent();
+                await this.client.request('thread/settings/update', { threadId: this.codexThreadId, serviceTier });
+                assertCurrent();
+            }
+            this.speed = speed;
+            return { success: true, output: 'Speed preference applied.' };
+        }
+        catch (error) {
+            return { success: false, error: this.errorMessage(error) };
+        }
+    }
     async listEfforts() {
         const models = await this.listModels();
         const currentModelId = this.reportedModel ?? this.model;
@@ -709,14 +1238,45 @@ class CodexAppServerExecutor {
         this.sandbox.deleteData();
     }
     async ensureThread() {
+        this.threadLoads++;
+        try {
+            await this.loadThread();
+        }
+        finally {
+            this.threadLoads--;
+        }
+    }
+    async loadThread() {
         (0, WorkingDirectory_1.assertWorkingDirectoryExists)(this.currentWorkingDirectory);
+        if (this.goalManaged && this.codexThreadId && !this.goalRun) {
+            const goal = await this.getGoal();
+            if (this.goalNeedsResume || goal?.status === 'active')
+                throw new Error(GOAL_RECOVERY_GUIDANCE);
+        }
         if (this.threadReady && this.client.isRunning())
             return;
+        this.threadReady = false;
+        this.legacyFollowReady = false;
+        const goalOwner = this.goalRun;
         this.reportedModel = undefined;
         this.reportedEffort = undefined;
         await this.client.start();
+        if (goalOwner)
+            this.assertGoalOwner(goalOwner);
+        if (typeof this.speed === 'string') {
+            const available = await (goalOwner ? this.goalDeadline(this.listSpeeds()) : this.listSpeeds());
+            if (goalOwner)
+                this.assertGoalOwner(goalOwner);
+            if (!available?.choices.some(choice => choice.value === this.speed)) {
+                throw new Error('The saved speed is unavailable for this Codex model. Follow native config in /model before starting work.');
+            }
+        }
+        const speedOptions = await this.speedOptions();
+        if (goalOwner)
+            this.assertGoalOwner(goalOwner);
         const common = {
             ...(this.model ? { model: this.model } : {}),
+            ...speedOptions,
             cwd: this.currentWorkingDirectory,
             ...(this.autoApprove ? {
                 approvalPolicy: 'never',
@@ -724,6 +1284,9 @@ class CodexAppServerExecutor {
             } : {}),
             ...this.sandbox.threadOptions(this.currentWorkingDirectory, this.delegationWorker || !!this.delegation),
         };
+        // A saved active goal can dispatch during resume, before settings/update.
+        if (goalOwner && this.effort)
+            common.config = { ...common.config, model_reasoning_effort: this.effort };
         if (this.delegationConfigured) {
             common.config = { ...common.config,
                 'mcp_servers.remote_cli_delegation': this.delegation
@@ -744,6 +1307,8 @@ class CodexAppServerExecutor {
                 if (response?.thread?.id !== this.codexThreadId) {
                     throw new Error('Codex app-server resumed an unexpected thread');
                 }
+                if (goalOwner)
+                    this.assertGoalOwner(goalOwner);
                 this.captureReportedSettings(response);
             }
             catch (error) {
@@ -761,14 +1326,23 @@ class CodexAppServerExecutor {
                 serviceName: 'remote_cli',
             });
             const id = response?.thread?.id;
+            if (goalOwner)
+                this.assertGoalOwner(goalOwner);
             if (typeof id !== 'string' || !id)
                 throw new Error('Codex app-server returned no thread ID');
             this.captureReportedSettings(response);
             this.setThreadId(id);
+            this.legacyFollowReady = this.speed === null && !Object.prototype.hasOwnProperty.call(common, 'serviceTier');
         }
+        if (typeof this.speed === 'string')
+            await this.assertReportedSpeed(this.speed);
+        if (goalOwner)
+            this.assertGoalOwner(goalOwner);
         this.threadReady = true;
     }
     handleMessage(message) {
+        if (this.destroyed)
+            return;
         const method = message.method;
         if (!method)
             return;
@@ -776,7 +1350,12 @@ class CodexAppServerExecutor {
         if (method === 'client/disconnected') {
             this.taskNotifications.clear();
             this.threadReady = false;
-            if (this.activeTurn) {
+            if (this.goalRun) {
+                if (!this.goalTransportStops) {
+                    void this.failGoal(this.goalRun, `${params.error ?? 'Codex app-server disconnected'}. ${GOAL_RECOVERY_GUIDANCE}`);
+                }
+            }
+            else if (this.activeTurn) {
                 this.completeActive({ success: false, error: params.error ?? 'Codex app-server disconnected' });
             }
             this.completeCompact({ success: false, error: params.error ?? 'Codex app-server disconnected' });
@@ -788,6 +1367,29 @@ class CodexAppServerExecutor {
         }
         if (params.threadId && params.threadId !== this.codexThreadId)
             return;
+        const goalRun = this.goalRun;
+        if (goalRun?.stopping)
+            return;
+        // Goal changes may arrive after their turn completed, or without any turn ID.
+        if (goalRun && (method === 'thread/goal/updated' || method === 'thread/goal/cleared')) {
+            if (params.threadId !== this.codexThreadId)
+                return;
+            try {
+                const goal = method === 'thread/goal/cleared' ? null : (0, CodexGoals_1.parseNativeGoal)(params.goal, this.codexThreadId);
+                if (method === 'thread/goal/updated' && !goal)
+                    throw new Error('Codex returned an empty native goal update.');
+                if (goal && (goalRun.objective && goal.objective !== goalRun.objective
+                    || goalRun.goal && goal.updatedAt < goalRun.goal.updatedAt))
+                    return;
+                goalRun.goal = goal;
+                goalRun.revision++;
+                this.maybeCompleteGoal(goalRun);
+            }
+            catch (error) {
+                void this.failGoal(goalRun, (0, CodexGoals_1.nativeGoalError)(error));
+            }
+            return;
+        }
         if (method === 'serverRequest/resolved') {
             this.pendingUserInputs = this.pendingUserInputs.filter(pending => {
                 if (pending.id !== params.requestId)
@@ -804,18 +1406,46 @@ class CodexAppServerExecutor {
             return;
         // Late background output must not become part of a subsequent turn.
         if (eventTurnId && !matchesActiveTurn && method !== 'turn/started'
+            && !(method === 'turn/completed' && goalRun?.inFlight.has(eventTurnId))
             && params.item?.type !== 'contextCompaction')
             return;
         if (this.activeTurn)
             this.armInactivityTimer();
         switch (method) {
             case 'turn/started':
+                if (goalRun) {
+                    const id = params.turn?.id;
+                    if (params.threadId !== this.codexThreadId || typeof id !== 'string' || !id || goalRun.retired.has(id))
+                        break;
+                    goalRun.inFlight.add(id);
+                    if (this.activeTurn?.turnId !== id) {
+                        if (goalRun.retired.size && goalRun.active.output.length) {
+                            goalRun.active.output.push('\n\n');
+                            goalRun.active.options.onStream?.('\n\n');
+                            goalRun.active.options.onDisplayText?.('\n\n');
+                        }
+                        goalRun.active.emittedTools.clear();
+                        goalRun.active.itemPhases.clear();
+                        goalRun.active.error = undefined;
+                        goalRun.active.errorCode = undefined;
+                    }
+                    this.goalNotice(goalRun, 'Native goal running');
+                }
                 if (this.activeTurn && typeof params.turn?.id === 'string')
                     this.activeTurn.turnId = params.turn.id;
                 break;
+            case 'thread/status/changed':
+                if (goalRun && params.status?.type === 'idle' && goalRun.goal?.status === 'active') {
+                    this.goalNotice(goalRun, 'Native goal active; waiting for native continuation or user control');
+                }
+                break;
             case 'item/agentMessage/delta':
                 if (this.activeTurn && typeof params.delta === 'string') {
                     this.activeTurn.output.push(params.delta);
+                    if (goalRun && this.activeTurn.output.reduce((size, part) => size + part.length, 0) > 65_536) {
+                        this.activeTurn.output = ['[Earlier native goal output omitted from this diagnostic buffer]\n',
+                            this.activeTurn.output.join('').slice(-65_536)];
+                    }
                     this.activeTurn.options.onStream?.(params.delta);
                     this.activeTurn.options.onDisplayText?.(params.delta);
                     const phase = params.itemId ? this.activeTurn.itemPhases.get(params.itemId) : undefined;
@@ -933,6 +1563,11 @@ class CodexAppServerExecutor {
         catch { /* Rendering failures must not make an accepted request executable again. */ }
     }
     handleServerRequest(id, method, params) {
+        if (this.goalRun && (this.goalRun.stopping || this.goalRun.controlling || !this.goalRun.inFlight.size
+            || params.turnId && !this.goalRun.inFlight.has(params.turnId))) {
+            this.client.respondError(id, 'Request does not belong to a running native goal turn');
+            return;
+        }
         if (params.threadId && params.threadId !== this.codexThreadId) {
             this.client.respondError(id, 'Request does not belong to this remote-cli thread');
             return;
@@ -1055,9 +1690,10 @@ class CodexAppServerExecutor {
             case 'mcpToolCall':
             case 'dynamicToolCall':
                 this.emitToolUse(active, id, item.tool ?? 'MCP', item.arguments ?? {});
+                this.handleGeneratedImage(active, item);
                 active.options.onToolResult?.({
                     tool_use_id: id,
-                    content: this.stringifyResult(item.result ?? item.contentItems ?? item.error ?? ''),
+                    content: (0, CodexImages_1.codexToolResultText)(item.result ?? item.contentItems ?? item.error ?? ''),
                     is_error: item.status !== 'completed' || item.success === false || Boolean(item.error),
                 });
                 break;
@@ -1081,6 +1717,35 @@ class CodexAppServerExecutor {
         const active = this.activeTurn;
         if (!active || !turn)
             return;
+        const run = this.goalRun;
+        if (run) {
+            if (!run.inFlight.has(turn.id) || run.retired.has(turn.id))
+                return;
+            run.inFlight.delete(turn.id);
+            if (!run.inFlight.size)
+                run.onIdle?.();
+            run.retired.add(turn.id);
+            if (run.retired.size > 256)
+                run.retired.delete(run.retired.values().next().value);
+            if (active.turnId === turn.id)
+                active.turnId = null;
+            this.pendingUserInputs = this.pendingUserInputs.filter(pending => {
+                if (pending.params.turnId && pending.params.turnId !== turn.id)
+                    return true;
+                this.finishApproval(pending, 'expired');
+                return false;
+            });
+            if (turn.status !== 'completed' && !run.controlling) {
+                void this.failGoal(run, turn.status === 'interrupted' ? 'Native goal interrupted. Resume explicitly to continue.'
+                    : turn.error?.message ?? active.error ?? 'Native goal turn failed.');
+            }
+            else {
+                this.maybeCompleteGoal(run);
+                if (run.ready && this.goalRun === run)
+                    void this.checkGoalAfterTurn(run);
+            }
+            return;
+        }
         if (active.turnId && turn.id && active.turnId !== turn.id)
             return;
         if (turn.status === 'completed') {
@@ -1126,27 +1791,27 @@ class CodexAppServerExecutor {
         this.activityTracker.emitTool(name, input, description ?? title);
     }
     handleGeneratedImage(active, item) {
-        if (item.status !== 'completed' || typeof item.result !== 'string' || !item.result)
-            return;
-        let data = item.result;
-        let mimeType = typeof item.mimeType === 'string' ? item.mimeType : 'image/png';
-        const dataUrlMatch = data.match(/^data:(image\/[a-z0-9.+-]+);base64,(.+)$/i);
-        if (dataUrlMatch) {
-            mimeType = dataUrlMatch[1];
-            data = dataUrlMatch[2];
-        }
-        if (!/^[a-z0-9+/]+={0,2}$/i.test(data) || data.length % 4 !== 0) {
-            console.warn('[CodexAppServer] Ignoring imageGeneration result with unsupported format');
-            return;
+        const parsed = active.images.extract(item, active.turnId);
+        for (const artifact of parsed.artifacts) {
+            if ('image' in artifact)
+                active.options.onImage?.(artifact.image);
+            else
+                active.options.onImageFile?.(artifact.path);
+        }
+        if (parsed.notice) {
+            active.output.push(parsed.notice);
+            active.options.onStream?.(parsed.notice);
         }
-        const image = { type: 'image', data, mimeType };
-        active.options.onImage?.(image);
     }
     completeActive(result) {
         const active = this.activeTurn;
         if (!active)
             return;
         this.activeTurn = null;
+        if (this.goalRun?.active === active) {
+            this.goalRun.onIdle?.();
+            this.goalRun = null;
+        }
         this.activityTracker.reset();
         this.activityTracker.setCallback(undefined);
         for (const pending of this.pendingUserInputs.splice(0))
@@ -1166,6 +1831,8 @@ class CodexAppServerExecutor {
         waiter.resolve(result);
     }
     async failAndRestart(error) {
+        if (this.goalRun)
+            return this.failGoal(this.goalRun, error);
         this.taskNotifications.clear();
         this.threadReady = false;
         this.completeActive({ success: false, error });
@@ -1222,15 +1889,19 @@ class CodexAppServerExecutor {
             const session = JSON.parse(fs.readFileSync(this.sessionFilePath, 'utf8'));
             if (typeof session.id === 'string' && session.id)
                 this.codexThreadId = session.id;
+            this.goalManaged = !!this.codexThreadId && session.goalManaged === true;
+            this.goalNeedsResume = this.goalManaged;
         }
         catch {
             this.codexThreadId = null;
+            this.goalManaged = false;
+            this.goalNeedsResume = false;
         }
     }
     setThreadId(id) {
         this.codexThreadId = id;
         const temporaryPath = `${this.sessionFilePath}.${process.pid}.tmp`;
-        const data = JSON.stringify({ id, savedAt: new Date().toISOString() });
+        const data = JSON.stringify({ id, savedAt: new Date().toISOString(), ...(this.goalManaged ? { goalManaged: true } : {}) });
         try {
             fs.writeFileSync(temporaryPath, data, { encoding: 'utf8', mode: 0o600 });
             fs.renameSync(temporaryPath, this.sessionFilePath);
@@ -1252,6 +1923,25 @@ class CodexAppServerExecutor {
                 console.error('[CodexAppServerExecutor] Failed to delete session file:', error);
         }
     }
+    /** Persist opt-in before a native mutation; a failed write must prevent activation. */
+    rememberGoalManagement() {
+        this.goalManaged = true;
+        if (!this.codexThreadId)
+            return;
+        const temporaryPath = `${this.sessionFilePath}.${process.pid}.goal.tmp`;
+        try {
+            fs.writeFileSync(temporaryPath, JSON.stringify({ id: this.codexThreadId, goalManaged: true,
+                savedAt: new Date().toISOString() }), { encoding: 'utf8', mode: 0o600 });
+            fs.renameSync(temporaryPath, this.sessionFilePath);
+        }
+        catch {
+            try {
+                fs.unlinkSync(temporaryPath);
+            }
+            catch { /* Keep the previous binding intact. */ }
+            throw new Error('Could not persist native goal ownership. No goal activation was requested.');
+        }
+    }
     extractErrorCode(info) {
         if (typeof info === 'string')
             return info;
@@ -1261,16 +1951,6 @@ class CodexAppServerExecutor {
             return info.type;
         return Object.keys(info)[0];
     }
-    stringifyResult(value) {
-        if (typeof value === 'string')
-            return value;
-        try {
-            return JSON.stringify(value).slice(0, 2_000);
-        }
-        catch {
-            return String(value);
-        }
-    }
     errorMessage(error) {
         return error instanceof Error ? error.message : String(error);
     }