@yu_robotics/remote-cli 1.6.170 → 1.6.173

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';
@@ -142,6 +146,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;
@@ -196,11 +207,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 +224,10 @@ 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);
+            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 +238,7 @@ class CodexAppServerExecutor {
                     emittedTools: new Map(),
                     itemPhases: new Map(),
                     temporaryFiles,
+                    images: new CodexImages_1.CodexImages(),
                     inactivityTimeoutMs: options.inactivityTimeout,
                 };
                 this.activityTracker.setCallback(options.onActivity);
@@ -269,6 +287,332 @@ 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 || Object.keys(goalPolicy).length) {
+            await this.goalRequest('thread/settings/update', { threadId: this.codexThreadId,
+                ...(this.model ? { model: this.model } : {}), ...(this.effort ? { effort: this.effort } : {}), ...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 +632,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 +685,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 +695,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 +705,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 +734,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' });
@@ -709,12 +1064,29 @@ 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;
+        const goalOwner = this.goalRun;
         this.reportedModel = undefined;
         this.reportedEffort = undefined;
         await this.client.start();
+        if (goalOwner)
+            this.assertGoalOwner(goalOwner);
         const common = {
             ...(this.model ? { model: this.model } : {}),
             cwd: this.currentWorkingDirectory,
@@ -724,6 +1096,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 +1119,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,6 +1138,8 @@ 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);
@@ -769,6 +1148,8 @@ class CodexAppServerExecutor {
         this.threadReady = true;
     }
     handleMessage(message) {
+        if (this.destroyed)
+            return;
         const method = message.method;
         if (!method)
             return;
@@ -776,7 +1157,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 +1174,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 +1213,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 +1370,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 +1497,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 +1524,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 +1598,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 +1638,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 +1696,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 +1730,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 +1758,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);
     }