mtech-ai-local-runner 0.1.30 → 0.1.32

package/dist/src/daemon/execution-coordinator.js

@@ -1,9 +1,13 @@
+import { PublicationOutcomeUnknownError } from '../publication/publisher.js';
 import { executionError, executionFailure } from '../safety/execution-failure.js';
+import { isUnsupportedSupervisorCommand } from '../safety/unsupported-supervisor-command.js';
 import { requireSecurityRequirements } from '../safety/security-requirements.js';
 import { GatewayToolError } from "../gateway-client.js";
 import { createHash } from "node:crypto";
 import { completionReportDiagnostic } from "../adapters/completion-report.js";
 import { PROTOCOL_VERSION, isTerminalEventType, validateEvent, MAX_EVENT_SUMMARY_CHARS } from "../protocol.js";
+import { DAEMON_BLOCKED_REASONS, DAEMON_CANCELLED_REASONS } from "../state-store.js";
+import { PreparationDeadlineError, PreparationLease, validateJobLease } from './preparation-lease.js';
 function canonical(value) {
     if (Array.isArray(value))
         return value.map(canonical);
@@ -40,7 +44,18 @@ function immutable(value) {
     }
     return value;
 }
-class PreparationDeadlineError extends Error {
+class LocalFixHostRequired extends Error {
+}
+function daemonOutcome(event) {
+    const source = event.eventType;
+    const suppliedReason = event.payload?.reason;
+    const reason = source === 'blocked' ? 'executor_blocked'
+        : source === 'question' ? 'executor_question' : source === 'scope_conflict' ? 'scope_conflict'
+            : source === 'cancelled' ? (DAEMON_CANCELLED_REASONS.includes(suppliedReason) ? suppliedReason : 'cancelled')
+                : source === 'failed' && DAEMON_BLOCKED_REASONS.includes(suppliedReason) ? suppliedReason : undefined;
+    const eventType = ['blocked', 'question', 'scope_conflict'].includes(source) ? 'failed' : source;
+    return { event: { ...event, eventType, summary: event.summary.slice(0, MAX_EVENT_SUMMARY_CHARS), ...(reason ? { payload: { ...event.payload, reason } } : {}) },
+        status: eventType === 'completed' ? 'completed' : eventType === 'cancelled' ? 'cancelled' : reason ? 'blocked' : 'failed', ...(reason ? { reason } : {}) };
 }
 export class ExecutionCoordinator {
     deps;
@@ -53,24 +68,20 @@ export class ExecutionCoordinator {
         let workspace;
         let adapter;
         let binding;
+        let fixSession;
+        let localFixPublication;
+        const isLocalFix = job.taskPackage.local_fix_scope !== undefined;
+        const lifecycle = { frozen: false, current: true };
         const deadline = Date.now() + (this.deps.preparationTimeoutMs ?? 900_000);
-        const step = async (operation) => {
-            const remaining = deadline - Date.now();
-            if (remaining <= 0)
-                throw new PreparationDeadlineError();
-            let timer;
-            try {
-                return await Promise.race([operation(), new Promise((_, reject) => {
-                        timer = setTimeout(() => reject(new PreparationDeadlineError()), remaining);
-                    })]);
-            }
-            finally {
-                if (timer)
-                    clearTimeout(timer);
-            }
-        };
+        let leaseExpiresAt = job.leaseExpiresAt;
+        const preparation = new PreparationLease(job, deadline, signal => this.deps.gateway.renewJob(job, signal), expiry => { this.deps.gateway.confirmJobLease?.(job, expiry); leaseExpiresAt = expiry; });
+        const step = (operation) => preparation.step(operation);
+        let bindingAttempted = false;
         try {
+            await preparation.start();
             const pkg = job.taskPackage;
+            if (isLocalFix && (!this.deps.localFixHost || pkg.repository?.access !== "write"))
+                throw new LocalFixHostRequired();
             const repository = pkg.repository;
             const adapterId = text(pkg.runtime_adapter, "runtime adapter");
             const adapterVersion = text(pkg.runtime_adapter_version, "runtime adapter version");
@@ -78,29 +89,48 @@ export class ExecutionCoordinator {
             requireSecurityRequirements(pkg.security_requirements, { adapterId, adapterVersion });
             if (!/^[a-f0-9]{64}$/.test(job.launchFingerprint ?? '') || job.gatewayContractFingerprint !== expectedContractFingerprint
                 || job.gatewayTaskPackageFingerprint !== fingerprint(pkg))
-                throw new Error("Claimed launch fingerprints differ");
+                throw new GatewayToolError("Claimed launch fingerprints differ", 'local_agent_jobs_wait', 'JOB_LAUNCH_FENCE_INVALID');
             stage = "workspace";
             workspace = await step(() => this.deps.workspaces.create({
                 jobId: job.id,
                 repositoryKey: text(repository?.key, "repository key"),
                 providerUrl: text(repository?.provider_url, "repository provider URL"),
                 baseCommitSha: text(repository?.base_commit_sha, "repository SHA"),
+                ...(isLocalFix ? { workingBranch: text(repository?.working_branch, "approved fix branch") } : {})
             }));
             stage = "adapter";
-            adapter = await step(() => this.deps.registry.select(adapterId, adapterVersion, { worktreePath: workspace.path, jobId: job.id }));
-            await this.deps.state.save({ jobId: job.id, generation: job.generation, leaseToken: job.leaseToken, phase: "shadow", workspaceManifest: workspace.manifest });
+            adapter = await preparation.step(() => this.deps.registry.select(adapterId, adapterVersion, { worktreePath: workspace.path, jobId: job.id }), late => late.cancel());
+            await step(() => this.deps.state.save({ jobId: job.id, generation: job.generation, leaseToken: job.leaseToken, phase: "shadow", workspaceManifest: workspace.manifest }));
             stage = "shadow";
-            const gatewayShadow = await step(() => this.deps.gateway.shadow(job));
+            const gatewayShadow = await step(() => this.deps.gateway.shadow(job, preparation.signal));
             stage = "fingerprint";
             if (contractFingerprint(gatewayShadow.contractPayload) !== expectedContractFingerprint || gatewayShadow.contractFingerprint !== expectedContractFingerprint || gatewayShadow.taskPackageFingerprint !== fingerprint(pkg)) {
-                throw new Error("contract or task-package fingerprint mismatch before binding");
+                throw new GatewayToolError("contract or task-package fingerprint mismatch before binding", 'work_execution_contract_show', 'JOB_SHADOW_FENCE_INVALID');
             }
             stage = "binding";
-            await this.deps.state.save({ jobId: job.id, generation: job.generation, leaseToken: job.leaseToken, phase: "binding" });
-            binding = await step(() => this.deps.gateway.createBinding({ ...job, checkoutPath: workspace.path }));
+            await step(() => this.deps.state.save({ jobId: job.id, generation: job.generation, leaseToken: job.leaseToken, phase: "binding" }));
+            preparation.beginBinding();
+            bindingAttempted = true;
+            binding = await step(() => this.deps.gateway.createBinding({ ...job, checkoutPath: workspace.path }, preparation.signal));
+            await step(() => this.deps.state.save({ jobId: job.id, generation: job.generation, leaseToken: job.leaseToken, phase: "running", bindingId: binding.bindingId, workspaceManifest: workspace.manifest }));
+            await preparation.stop();
+            preparation.assert();
         }
         catch (error) {
+            if (stage === 'fingerprint')
+                preparation.fail(error);
+            if (error instanceof GatewayToolError && !['GATEWAY_TRANSPORT_ERROR', 'GATEWAY_HTTP_500', 'GATEWAY_HTTP_502', 'GATEWAY_HTTP_503', 'GATEWAY_HTTP_504'].includes(error.code))
+                preparation.fail(error);
+            try {
+                await preparation.stop();
+            }
+            catch { /* The original error and latched fence remain authoritative. */ }
+            preparation.dispose();
+            if (adapter)
+                await adapter.cancel();
             const diagnostic = { stage, code: "PREPARATION_FAILED" };
+            if (error instanceof LocalFixHostRequired)
+                diagnostic.code = "LOCAL_FIX_HOST_REQUIRED";
             if (error instanceof PreparationDeadlineError)
                 diagnostic.code = "PREPARATION_DEADLINE_EXCEEDED";
             if (error instanceof GatewayToolError) {
@@ -108,49 +138,137 @@ export class ExecutionCoordinator {
                 diagnostic.code = error.code;
             }
             this.deps.reportPreparationFailure?.(diagnostic);
-            if (stage === "binding" && !(error instanceof GatewayToolError && error.code === "GATEWAY_TOOL_REJECTED")) {
+            if (bindingAttempted && !(error instanceof GatewayToolError && error.code === "GATEWAY_TOOL_REJECTED")) {
                 // The server may have committed the binding. Never fabricate a blocked result
                 // or repeat the mutation before the deterministic binding reference is reconciled.
                 await this.deps.state.save({ jobId: job.id, generation: job.generation, leaseToken: job.leaseToken,
                     phase: "binding_uncertain", preparationFailure: diagnostic });
                 throw new Error("Binding outcome requires reconciliation");
             }
+            if (!preparation.hasLiveFence || (error instanceof PreparationDeadlineError && stage === 'adapter'))
+                throw error;
             // Retain this exact safe terminal payload until Gateway acknowledges it.
             const completionRequest = { jobId: job.id, generation: job.generation, leaseToken: job.leaseToken,
                 status: "blocked", result: { preparation_failure: { ...diagnostic } } };
             await this.deps.state.save({ jobId: job.id, generation: job.generation, leaseToken: job.leaseToken,
                 phase: "terminal_pending", preparationFailure: diagnostic, completionRequest: structuredClone(completionRequest) });
+            if (!preparation.hasLiveFence) {
+                preparation.dispose();
+                throw error;
+            }
             await this.deps.gateway.complete(completionRequest);
             await this.deps.state.clear();
+            preparation.dispose();
             return;
         }
-        await this.deps.state.save({ jobId: job.id, generation: job.generation, leaseToken: job.leaseToken, phase: "running", bindingId: binding.bindingId, workspaceManifest: workspace.manifest });
+        const executor = adapter;
         let heartbeatFailure;
+        const evidenceAbort = new AbortController();
+        const controlAbort = new AbortController();
+        let leaseBoundary;
+        let rejectFence;
+        const lostFence = new Promise((_, reject) => { rejectFence = reject; });
+        void lostFence.catch(() => { });
         let executionStage = 'binding_model';
         let requestedTerminal;
+        let rejectControlStop;
+        const controlStopped = new Promise((_, reject) => { rejectControlStop = reject; });
+        void controlStopped.catch(() => { });
+        let publicationPending = false;
         let commandCursor = 0;
         let controlsStopped = false;
         let controlsInFlight;
+        let executorStop;
+        let stopUnconfirmed = false;
+        let rejectUnconfirmedStop;
+        const unconfirmedStop = new Promise((_, reject) => { rejectUnconfirmedStop = reject; });
+        void unconfirmedStop.catch(() => { });
+        const stopExecutor = () => {
+            if (!executorStop) {
+                try {
+                    executorStop = executor.cancel();
+                }
+                catch (error) {
+                    executorStop = Promise.reject(error);
+                }
+                void executorStop.catch(error => { stopUnconfirmed = true; rejectUnconfirmedStop(error); failFence(error); });
+            }
+            return executorStop;
+        };
+        const failFence = (error) => {
+            if (heartbeatFailure)
+                return;
+            lifecycle.current = false;
+            heartbeatFailure = executionError(error, 'heartbeat', 'EXECUTION_FAILED');
+            controlAbort.abort();
+            evidenceAbort.abort();
+            rejectFence(heartbeatFailure);
+            // Cancellation cannot queue behind transport or generator cleanup.
+            void stopExecutor().catch(() => { });
+        };
+        const requireControlFence = () => {
+            if (!heartbeatFailure && (leaseExpiresAt === undefined || Date.now() >= leaseExpiresAt * 1000))
+                failFence(new GatewayToolError('Job lease expired', 'local_agent_job_heartbeat', 'JOB_LEASE_FENCE_INVALID'));
+            if (heartbeatFailure)
+                throw heartbeatFailure;
+        };
+        const armLeaseBoundary = () => {
+            if (leaseBoundary)
+                clearTimeout(leaseBoundary);
+            leaseBoundary = setTimeout(() => { try {
+                requireControlFence();
+            }
+            catch { /* The latched fence rejects all pending operations. */ } }, Math.max(0, (leaseExpiresAt ?? 0) * 1000 - Date.now()));
+            leaseBoundary.unref?.();
+        };
+        const fenced = (work) => Promise.race([work, lostFence]);
+        armLeaseBoundary();
         const readControls = async () => {
+            requireControlFence();
             if (!this.deps.gateway.readCommands || controlsStopped || requestedTerminal)
                 return;
             if (controlsInFlight)
                 return controlsInFlight;
             controlsInFlight = (async () => {
-                for (const command of await this.deps.gateway.readCommands(binding.bindingId, commandCursor)) {
+                const commands = await fenced(this.deps.gateway.readCommands(binding.bindingId, commandCursor, controlAbort.signal));
+                requireControlFence();
+                for (const command of commands) {
+                    requireControlFence();
                     if (controlsStopped)
                         return;
+                    let commandTerminal;
                     if (["cancel", "pause", "request_replan"].includes(command.command)) {
-                        requestedTerminal = { eventType: command.command === "cancel" ? "cancelled" : "blocked", summary: `supervisor ${command.command} acknowledged` };
-                        await adapter.cancel();
+                        lifecycle.current = false;
+                        commandTerminal = { eventType: "cancelled", summary: `supervisor ${command.command} acknowledged`,
+                            payload: { reason: command.command === 'pause' ? 'paused' : command.command === 'request_replan' ? 'replan_requested' : 'cancelled' } };
+                        await stopExecutor();
                     }
                     else {
-                        await adapter.command(command);
+                        try {
+                            await fenced(adapter.command(command));
+                        }
+                        catch (error) {
+                            requireControlFence();
+                            // Classify the host capability outcome before executionError wraps it.
+                            if (!isUnsupportedSupervisorCommand(error))
+                                throw error;
+                            lifecycle.current = false;
+                            await stopExecutor();
+                            requireControlFence();
+                            commandTerminal = { eventType: 'failed', summary: 'supervisor command is unsupported for the approved launch',
+                                payload: { reason: 'unsupported_supervisor_command' } };
+                        }
                     }
+                    requireControlFence();
                     if (!this.deps.gateway.acknowledgeCommand)
                         throw new Error("daemon command acknowledgement is unavailable");
-                    await this.deps.gateway.acknowledgeCommand(binding.bindingId, command.sequence);
+                    await fenced(this.deps.gateway.acknowledgeCommand(binding.bindingId, command.sequence, controlAbort.signal));
+                    requireControlFence();
                     commandCursor = command.sequence;
+                    if (commandTerminal) {
+                        requestedTerminal = commandTerminal;
+                        rejectControlStop(new Error('Supervisor stopped execution'));
+                    }
                     if (requestedTerminal)
                         break;
                 }
@@ -165,30 +283,70 @@ export class ExecutionCoordinator {
                 controlsInFlight = undefined;
             }
         };
+        let heartbeatInFlight;
         const heartbeatTimer = this.deps.gateway.heartbeat || this.deps.gateway.readCommands ? setInterval(() => {
-            void (async () => { await this.deps.gateway.heartbeat?.(binding.bindingId, job); await readControls(); })().catch(async (error) => {
-                heartbeatFailure = executionError(error, 'heartbeat', 'EXECUTION_FAILED');
-                await adapter.cancel().catch(() => undefined);
-            });
+            if (requestedTerminal || heartbeatInFlight)
+                return;
+            heartbeatInFlight = (async () => {
+                await readControls();
+                requireControlFence();
+                if (!requestedTerminal && this.deps.gateway.heartbeat) {
+                    const renewed = await fenced(this.deps.gateway.heartbeat(binding.bindingId, job, controlAbort.signal));
+                    requireControlFence();
+                    const expiry = validateJobLease(renewed, job, true);
+                    if (!['running', 'review_pending'].includes(renewed.job.status))
+                        throw new GatewayToolError('Running Job lease status is invalid', 'local_agent_job_heartbeat', 'JOB_LEASE_FENCE_INVALID');
+                    this.deps.gateway.confirmJobLease?.(job, expiry);
+                    leaseExpiresAt = expiry;
+                    armLeaseBoundary();
+                }
+            })().catch((error) => {
+                failFence(error);
+            }).finally(() => { heartbeatInFlight = undefined; });
         }, 30_000) : undefined;
         heartbeatTimer?.unref();
         let terminal;
         let failureDiagnostic;
         let sequence = 0;
         let checkpointSeen = false;
+        let eventUncertain = false;
+        const stop = async (ignoreControlFailure = false) => {
+            controlsStopped = true;
+            const cancelled = stopExecutor();
+            if (stopUnconfirmed)
+                await cancelled;
+            let controlFailure;
+            try {
+                if (controlsInFlight)
+                    await controlsInFlight;
+            }
+            catch (error) {
+                controlFailure = error;
+            }
+            if (heartbeatInFlight)
+                await heartbeatInFlight;
+            await cancelled;
+            if (!ignoreControlFailure && (controlFailure || heartbeatFailure))
+                throw controlFailure || heartbeatFailure;
+        };
         const append = async (event) => {
             const previousStage = executionStage;
             let payload = event.payload;
             if (isTerminalEventType(event.eventType)) {
                 executionStage = 'terminal_evidence';
-                const evidence = this.deps.terminalEvidenceCollector.collect({ checkoutPath: workspace.path, baseSha: workspace.baseCommitSha });
+                requireControlFence();
+                const evidence = localFixPublication && typeof localFixPublication.diff_hash === 'string' && typeof localFixPublication.changed_file_manifest_hash === 'string' ? { diffHash: localFixPublication.diff_hash, changedFileManifestHash: localFixPublication.changed_file_manifest_hash } : await fenced(this.deps.terminalEvidenceCollector.collect({ checkoutPath: workspace.path, baseSha: workspace.baseCommitSha, signal: evidenceAbort.signal }));
+                requireControlFence();
                 payload = { ...payload, diff_hash: evidence.diffHash, changed_file_manifest_hash: evidence.changedFileManifestHash };
             }
             // A vendor report cannot supply host observations, even when its shape looks valid.
             if (payload) {
                 payload = { ...payload };
                 delete payload.local_read_observations;
+                delete payload.local_fix_publication;
             }
+            if (event.eventType === "completed" && localFixPublication)
+                payload = { ...payload, local_fix_publication: structuredClone(localFixPublication) };
             if (isTerminalEventType(event.eventType) || event.eventType === 'blocked' || event.eventType === 'scope_conflict') {
                 const reads = safeLocalReadObservations(adapter.localReadObservations?.());
                 if (reads)
@@ -205,91 +363,207 @@ export class ExecutionCoordinator {
             validateEvent(normalized);
             if (!this.deps.gateway.appendEvent)
                 throw new Error("daemon event reporting is unavailable");
-            await this.deps.gateway.appendEvent(binding.bindingId, normalized);
+            // Keep lease renewal responsive during evidence collection, then settle
+            // its last fence before the terminal event consumes the execution lease.
+            if (isTerminalEventType(event.eventType)) {
+                if (heartbeatTimer)
+                    clearInterval(heartbeatTimer);
+                if (heartbeatInFlight)
+                    await heartbeatInFlight;
+            }
+            requireControlFence();
+            eventUncertain = true;
+            await fenced(this.deps.gateway.appendEvent(binding.bindingId, normalized));
+            requireControlFence();
             sequence = normalized.sequence;
             executionStage = 'state_save';
             if (event.eventType === "checkpoint_ready")
                 checkpointSeen = true;
             await this.deps.state.save({ jobId: job.id, generation: job.generation, leaseToken: job.leaseToken, phase: "running", bindingId: binding.bindingId, eventCursor: sequence, ...(isTerminalEventType(event.eventType) ? { terminalEventType: event.eventType } : {}), workspaceManifest: workspace.manifest });
+            eventUncertain = false;
             executionStage = previousStage;
         };
+        const publicationStep = async (operation) => {
+            requireControlFence();
+            if (requestedTerminal)
+                throw new Error('Supervisor stopped execution');
+            const value = await fenced(Promise.race([operation(), controlStopped]));
+            requireControlFence();
+            if (requestedTerminal)
+                throw new Error('Supervisor stopped execution');
+            return value;
+        };
         try {
             if (!job.taskPackage.resolved_model_id
                 || binding.resolvedModelId !== job.taskPackage.resolved_model_id)
                 throw new Error("Binding model differs from approved launch");
             executionStage = 'adapter_start';
-            await adapter.start({ securityBinding: { launchFingerprint: job.launchFingerprint, contractFingerprint: job.gatewayContractFingerprint, taskPackageFingerprint: job.gatewayTaskPackageFingerprint }, generation: job.generation, approvedTaskPackage: job.taskPackage, bindingId: binding.bindingId, sessionId: binding.bindingId, taskPackage: binding.taskPackage, resolvedModelId: binding.resolvedModelId });
+            preparation.assert();
+            requireControlFence();
+            if (isLocalFix) {
+                await readControls();
+                if (!requestedTerminal)
+                    fixSession = await publicationStep(() => this.deps.localFixHost.prepare({ job, checkoutPath: workspace.path, bindingId: binding.bindingId, lifecycle: {
+                            isFrozen: () => lifecycle.frozen,
+                            isCurrent: () => lifecycle.current && !requestedTerminal && !heartbeatFailure && leaseExpiresAt !== undefined && Date.now() < leaseExpiresAt * 1000,
+                            securityReceipt: () => adapter.securityReceipt?.(),
+                        } }).then(async (session) => {
+                        if (!lifecycle.current || requestedTerminal || heartbeatFailure) {
+                            await session.close();
+                            throw new Error('Local fix preparation lost its lease');
+                        }
+                        return session;
+                    }));
+            }
+            if (!requestedTerminal) {
+                await fenced(Promise.race([adapter.start({ securityBinding: { launchFingerprint: job.launchFingerprint, contractFingerprint: job.gatewayContractFingerprint, taskPackageFingerprint: job.gatewayTaskPackageFingerprint }, generation: job.generation, approvedTaskPackage: job.taskPackage, bindingId: binding.bindingId, sessionId: binding.bindingId, taskPackage: binding.taskPackage, resolvedModelId: binding.resolvedModelId }), unconfirmedStop]));
+            }
             executionStage = 'commands';
             await readControls();
             executionStage = 'event_stream';
             if (adapter.events && !requestedTerminal) {
-                for await (const event of adapter.events()) {
-                    if (heartbeatFailure)
-                        throw heartbeatFailure;
-                    if (requestedTerminal)
-                        break;
-                    if (event.eventType === "completed" && !checkpointSeen) {
-                        await append({ eventType: "checkpoint_ready", summary: "final checkpoint ready" });
-                    }
-                    if (isTerminalEventType(event.eventType)) {
-                        if (controlsInFlight)
-                            await controlsInFlight;
+                const iterator = adapter.events()[Symbol.asyncIterator]();
+                try {
+                    while (true) {
+                        const next = await fenced(Promise.race([iterator.next(), unconfirmedStop]));
+                        if (next.done)
+                            break;
+                        const event = next.value;
+                        if (heartbeatFailure)
+                            throw heartbeatFailure;
                         if (requestedTerminal)
                             break;
-                        controlsStopped = true;
+                        if (isTerminalEventType(event.eventType)) {
+                            if (event.eventType === "completed" && fixSession) {
+                                // Stop only this owned model before running verified host publication.
+                                // Controls/heartbeat remain active throughout the publication phase.
+                                if (this.deps.localFixHost?.requiresOwnedFreeze) {
+                                    if (!adapter.freezeForPublication)
+                                        throw new Error('LOCAL_FIX_OWNED_FREEZE_UNAVAILABLE');
+                                    await publicationStep(() => adapter.freezeForPublication());
+                                }
+                                else
+                                    await publicationStep(() => stopExecutor());
+                                lifecycle.frozen = true;
+                                await readControls();
+                                if (requestedTerminal || heartbeatFailure)
+                                    break;
+                                executionStage = 'local_fix_publication';
+                                if (!checkpointSeen)
+                                    await append({ eventType: 'checkpoint_ready', summary: 'final checkpoint ready' });
+                                await publicationStep(() => this.deps.state.save({ jobId: job.id, generation: job.generation, leaseToken: job.leaseToken, phase: 'publication_pending', bindingId: binding.bindingId, eventCursor: sequence, workspaceManifest: workspace.manifest, publicationRecovery: { version: 1, job, checkoutPath: workspace.path, bindingId: binding.bindingId, completedEvent: event, gatewayContext: this.deps.gateway.publicationRecoveryContext?.(binding.bindingId), securityReceipt: adapter.securityReceipt?.(), freezeConfirmed: lifecycle.frozen } }));
+                                publicationPending = true;
+                                localFixPublication = await publicationStep(() => fixSession.finalize());
+                                if (this.deps.gateway.syncPublicationCursor) {
+                                    try {
+                                        const cursor = await publicationStep(() => this.deps.gateway.syncPublicationCursor(binding.bindingId, sequence));
+                                        if (!Number.isSafeInteger(cursor) || cursor < sequence)
+                                            throw new Error('Invalid event cursor');
+                                        sequence = cursor;
+                                    }
+                                    catch {
+                                        throw new PublicationOutcomeUnknownError();
+                                    }
+                                }
+                                if (controlsInFlight)
+                                    await controlsInFlight;
+                                requireControlFence();
+                                if (requestedTerminal)
+                                    throw new PublicationOutcomeUnknownError();
+                                executionStage = 'event_stream';
+                            }
+                        }
+                        if (isTerminalEventType(event.eventType) || ["blocked", "scope_conflict", "question"].includes(event.eventType)) {
+                            terminal = event;
+                            void stopExecutor().catch(() => { });
+                            // Resolve already-issued controls before choosing the terminal receipt,
+                            // and stop writes before the generator's deferred cleanup or evidence.
+                            if (controlsInFlight)
+                                await Promise.race([controlsInFlight, unconfirmedStop]);
+                            await stop();
+                            break;
+                        }
+                        await append(event);
+                        await readControls();
                     }
-                    await append(event);
-                    if (isTerminalEventType(event.eventType) || ["blocked", "scope_conflict"].includes(event.eventType)) {
-                        controlsStopped = true;
-                        terminal = event;
-                        break;
+                }
+                finally {
+                    // A failed owned stop cannot wait behind a blocked generator next().
+                    // Keep disposal attached, but return to durable suspension promptly.
+                    if (stopUnconfirmed || heartbeatFailure) {
+                        try {
+                            void Promise.resolve(iterator.return?.()).catch(() => { });
+                        }
+                        catch { /* Unconfirmed cleanup already fences reporting. */ }
                     }
-                    await readControls();
+                    else
+                        await iterator.return?.();
                 }
             }
-            if (controlsInFlight)
-                await controlsInFlight;
-            if (requestedTerminal) {
+            await stop();
+            if (publicationPending && requestedTerminal)
+                throw new PublicationOutcomeUnknownError();
+            if (requestedTerminal)
                 terminal = requestedTerminal;
-                await append(terminal);
-            }
-            if (heartbeatFailure)
-                throw heartbeatFailure;
             if (!terminal) {
                 terminal = { eventType: "failed", summary: "adapter ended without a terminal event" };
-                await append(terminal);
             }
+            terminal = daemonOutcome(terminal).event;
+            if (terminal.eventType === 'completed' && !checkpointSeen)
+                await append({ eventType: 'checkpoint_ready', summary: 'final checkpoint ready' });
+            await append(terminal);
         }
         catch (error) {
-            await adapter.cancel().catch(() => undefined);
-            // Do not complete a job whose terminal evidence was not acknowledged.
-            // A safe bounded reason prevents raw adapter/transport errors leaking.
-            const diagnostic = executionFailure(error, executionStage);
-            failureDiagnostic = diagnostic;
-            // Log before reporting so an unavailable Gateway does not erase the cause.
-            try {
-                this.deps.reportExecutionFailure?.(structuredClone(diagnostic));
+            await stop(true);
+            if (error instanceof PublicationOutcomeUnknownError || (publicationPending && (heartbeatFailure || requestedTerminal))) {
+                // The provider may already have committed/pushed/opened a PR. Do not
+                // release this run as failed or let restart begin another model session.
+                throw new Error('Local publication outcome requires reconciliation');
+            }
+            if (requestedTerminal && !heartbeatFailure && !eventUncertain) {
+                terminal = daemonOutcome(requestedTerminal).event;
+            }
+            else {
+                // Do not complete a job whose terminal evidence was not acknowledged.
+                // A safe bounded reason prevents raw adapter/transport errors leaking.
+                const diagnostic = executionFailure(error, executionStage);
+                failureDiagnostic = diagnostic;
+                // Log before reporting so an unavailable Gateway does not erase the cause.
+                try {
+                    this.deps.reportExecutionFailure?.(structuredClone(diagnostic));
+                }
+                catch { /* logging must not change terminal reconciliation */ }
+                if (heartbeatFailure)
+                    throw error;
+                if (eventUncertain || ['GATEWAY_TOOL_REJECTED', 'GATEWAY_TRANSPORT_ERROR', 'WORK_LOOP_CANCELLED'].includes(diagnostic.code)
+                    || diagnostic.stage === 'terminal_evidence')
+                    throw error;
+                terminal = { eventType: "failed", summary: "daemon execution or event reporting failed", payload: { execution_failure: { ...diagnostic } } };
             }
-            catch { /* logging must not change terminal reconciliation */ }
-            terminal = { eventType: "failed", summary: "daemon execution or event reporting failed", payload: { execution_failure: { ...diagnostic } } };
             await append(terminal);
         }
         finally {
             controlsStopped = true;
             if (heartbeatTimer)
                 clearInterval(heartbeatTimer);
+            lifecycle.current = false;
+            if (leaseBoundary)
+                clearTimeout(leaseBoundary);
+            await fixSession?.close();
         }
-        const status = terminal.eventType === "completed" ? "completed" : terminal.eventType === "cancelled" ? "cancelled" : terminal.eventType === "blocked" || terminal.eventType === "scope_conflict" ? "blocked" : "failed";
-        const diagnostic = status === "failed" || terminal.eventType === "blocked" ? completionReportDiagnostic(terminal.payload?.completion_report) : undefined;
-        const reportDiagnostic = diagnostic && (terminal.eventType === "blocked"
+        const { status, reason } = daemonOutcome(terminal);
+        const diagnostic = status === "failed" || status === "blocked" ? completionReportDiagnostic(terminal.payload?.completion_report) : undefined;
+        const reportDiagnostic = diagnostic && (status === "blocked"
             ? diagnostic.code === "CODEX_COMPLETION_REPORT_BLOCKED" : diagnostic.code !== "CODEX_COMPLETION_REPORT_BLOCKED") ? diagnostic : undefined;
         const securityReceipt = adapter.securityReceipt?.();
         const reads = safeLocalReadObservations(adapter.localReadObservations?.());
-        const completionRequest = structuredClone({ jobId: job.id, generation: job.generation, leaseToken: job.leaseToken, status, result: { binding_id: binding.bindingId, event_type: terminal.eventType, summary: terminal.summary, ...(reads ? { local_read_observations: reads } : {}), ...(failureDiagnostic ? { execution_failure: { ...failureDiagnostic } } : {}), ...(reportDiagnostic ? { completion_report: reportDiagnostic } : {}), ...(securityReceipt ? { security_receipt: securityReceipt } : {}) } });
+        const completionRequest = structuredClone({ jobId: job.id, generation: job.generation, leaseToken: job.leaseToken, status, result: { binding_id: binding.bindingId, event_type: terminal.eventType, summary: terminal.summary, ...(localFixPublication ? { local_fix_publication: structuredClone(localFixPublication) } : {}), ...(reason ? { reason } : {}), ...(reads ? { local_read_observations: reads } : {}), ...(failureDiagnostic ? { execution_failure: { ...failureDiagnostic } } : {}), ...(reportDiagnostic ? { completion_report: reportDiagnostic } : {}), ...(securityReceipt ? { security_receipt: securityReceipt } : {}) } });
         await this.deps.state.save({ jobId: job.id, generation: job.generation, leaseToken: job.leaseToken,
             phase: "terminal_pending", bindingId: binding.bindingId, terminalEventType: terminal.eventType,
             completionRequest: structuredClone(completionRequest) });
+        requireControlFence();
         await this.deps.gateway.complete(completionRequest);
+        requireControlFence();
         await this.deps.state.clear();
     }
 }

package/dist/src/daemon/job-poller.js

@@ -20,7 +20,10 @@ export class JobPoller {
             this.failures = 0;
         }
         catch {
-            this.deps.reportError?.({ stage, code: stage === "execute" ? "EXECUTION_UNACKNOWLEDGED" : "GATEWAY_UNAVAILABLE" });
+            try {
+                this.deps.reportError?.({ stage, code: stage === "execute" ? "EXECUTION_UNACKNOWLEDGED" : "GATEWAY_UNAVAILABLE" });
+            }
+            catch { /* Observational logging cannot bypass stop/backoff or discard recovery state. */ }
             // Unknown execution/terminal outcomes must reconcile before any new claim.
             if (stage === "execute") {
                 this.stop();