mtech-ai-local-runner 0.1.31 → 0.1.32

package/README.md

@@ -1,3 +1,65 @@
+## Unreleased: P0 terminal safety baseline (local verification only)
+
+The upstream source package is `0.1.31`; P0 does not bump or publish a version.
+Deploy a compatible Gateway receiver before upgrading any runner. Publication,
+installation, restart, flag activation and live acceptance require their own
+delivery gates; this local change authorizes none of them. See the repository
+runbook at `docs/ai-ops-gateway/runbooks/local-agent-daemon-rollout.md`.
+
+Pause/replan now report Runtime `cancelled` and Job `cancelled`. Blocked reports,
+required questions and scope conflicts report Runtime `failed` and Job `blocked`,
+with bounded useful diagnostics. Gateway retains compatibility with historical
+blocked pause/replan receipts. Claude revision messages preserve actual
+`acceptance_criteria` and `required_changes`. Unsupported active Codex controls
+stop the owned launch and acknowledge transport; that ACK does not mean the
+requested revision was performed. No automatic relaunch or grant reuse occurs.
+
+Terminal receipts are retained and replayed exactly. On restart, claimed/shadow
+attempts report failed `runner_restarted`; binding/binding_uncertain attempts
+report blocked `binding_outcome_unknown`. Running/reconciling attempts stay
+manually suspended because previous OS cleanup is unknown. Server expiry closure
+records failed provenance; it does not kill a process, complete a Loop or attest
+client evidence. Minimal fsynced recovery markers and invalid state (including
+JSON null) are preserved. Do not delete dirty workspaces, recovery or audit state
+to resume claims. State-store mutations are serialized and save/suspend/clear
+snapshot their input before queuing; a hung filesystem can leave durable recovery
+pending, without a false acknowledgement or new claims.
+
+A model-free guardian owns each newly created executor group and observes a
+private parent-liveness pipe. Parent EOF invokes TERM, a 2-second grace, then
+KILL for surviving owned processes. The 6-second cleanup-confirmation bound is
+not a model-runtime budget. Guardian death or descendants escaping the group
+remain an unconfirmed-cleanup/manual-reconciliation gap; local tests do not
+establish Task 7/P0 operational acceptance.
+
+Tracked diff hashing streams UTF-8-compatible input and retains only hashes and
+manifest metadata; collection is abort-fenced. Preparation immediately renews the
+Job lease with a single-flight heartbeat, checking exact job ID, generation,
+status and expiry. The existing 900000 ms deadline bounds preparation only.
+Transient retries use 1/2/4-second backoff, at most three, only within the last
+confirmed lease and deadline. Authentication (401/403), fingerprint and fence
+failures are fatal. Git workspace preparation has no abort API: late audit
+workspaces are retained, but late completion cannot launch a downstream model.
+OAuth policy, admission and manual pause behavior remain unchanged.
+
+Running execution has an independent watchdog for the last server-confirmed Job
+lease. Hung startup, control, heartbeat, stream, evidence or event-response waits
+cannot defer cancellation past that lease. Late responses cannot renew host
+authority, acknowledge a command or advance reporting/state after fence loss;
+an unknown remote append remains uncertain for reconciliation. Healthy validated
+renewals extend execution without a fixed model-runtime limit.
+
+Local-fix preparation, owned freeze, publication finalization and server cursor
+synchronization share that fence. A stopped or expired attempt cannot regain
+publication authority through a late response. Once publication may have taken
+effect, retain `publication_pending` recovery instead of falsely completing,
+failing or restarting the attempt. Canonical publication approval remains required.
+
+Component, shadow admission, installed-package and live-provider evidence are
+separate. Historical 0.1.10 hook behavior below is not current Claude admission;
+Claude parity requires the actual current isolation/admission gate to pass.
+No live push/hook probe or real CLI/model run is part of this verification.
+
 ## 0.1.30: governed local alert investigation evidence
 
 The Gateway candidate offers explicit Local Codex Runner or Local Claude Runner
@@ -337,7 +399,8 @@ npx mtech-ai-local-runner doctor
 Cancelling a Work Loop also cancels its non-terminal local jobs. Repeating the
 cancellation repairs jobs left by an earlier Gateway version; terminal results
 are preserved. Claim/reclaim and lease-gated launch checks reject cancelled
-Loops. An active adapter stops when the next lease heartbeat fails; cancellation
+Loops. An active adapter stops on a failed heartbeat or expiry of its last
+confirmed Job lease, even when the current request never responds. Cancellation
 is not an immediate process-kill acknowledgement.
 
 Before binding, the Gateway permits at most three queue deliveries and a

package/dist/src/adapters/claude-code/adapter.js

@@ -44,6 +44,9 @@ export class ClaudeCodeAdapter {
     tools;
     cancelled = false;
     started = false;
+    startupAcquisition;
+    revokedTools;
+    revokeFailed = false;
     receipt;
     toolEndpoint;
     readSnapshot;
@@ -59,6 +62,8 @@ export class ClaudeCodeAdapter {
         this.options = options;
     }
     async start(ctx) {
+        if (this.cancelled)
+            throw new Error('adapter startup cancelled');
         const resolvedModelId = ctx.resolvedModelId;
         if (!resolvedModelId) {
             throw new Error("refusing to start: no Gateway-resolved model ID was supplied");
@@ -100,6 +105,10 @@ export class ClaudeCodeAdapter {
         }
         const hookCommand = this.requireTrustedHookCommand();
         const prompt = compilePrompt(ctx.taskPackage, { workItemLabel: this.options.workItemLabel });
+        if (this.cancelled)
+            throw new Error('adapter startup cancelled');
+        let acquired;
+        this.startupAcquisition = new Promise(resolve => { acquired = resolve; });
         try {
             if (!this.options.createTools || !this.options.writeLocalMcpConfig)
                 throw new Error("job-local tool setup is required");
@@ -165,9 +174,15 @@ export class ClaudeCodeAdapter {
             handle.stdin.write(`${JSON.stringify({ type: "user", message: { role: "user", content: [{ type: "text", text: prompt }] } })}\n`);
         }
         catch (error) {
+            // Settle only the ownership-acquisition fence before cleanup. Waiting for
+            // all of start() here would deadlock cancellation against this catch.
+            acquired();
             await this.cleanup();
             throw error;
         }
+        finally {
+            acquired();
+        }
     }
     async *events() {
         const handle = this.requireHandle();
@@ -223,38 +238,82 @@ export class ClaudeCodeAdapter {
         if (command.command === "answer_question" && typeof command.arguments?.answer === "string") {
             payload.answer = command.arguments.answer;
         }
-        if (command.command === "request_revision" && Array.isArray(command.arguments?.acceptance_criterion_ids)) {
-            payload.acceptance_criterion_ids = command.arguments?.acceptance_criterion_ids;
+        if (command.command === "request_revision") {
+            // The Gateway validates these exact string lists against the approved brief.
+            for (const key of ["acceptance_criteria", "required_changes"]) {
+                if (Array.isArray(command.arguments?.[key]))
+                    payload[key] = command.arguments[key];
+            }
         }
         handle.stdin.write(`${JSON.stringify({ type: "user", message: { role: "user", content: [{ type: "text", text: JSON.stringify(payload) }] } })}\n`);
     }
-    async cancel() {
+    cancelPromise;
+    cancel() {
         this.cancelled = true;
-        await this.cleanup();
+        if (this.cancelPromise)
+            return this.cancelPromise;
+        this.localReadObservations();
+        this.revokeTools(this.tools);
+        const cleanup = (async () => { await this.startupAcquisition; await this.cleanup(); })();
+        // This bounds cleanup confirmation, never admitted model runtime. Unknown
+        // acquisition stays unconfirmed; any late owner is still disposed by start.
+        this.cancelPromise = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error('Provider process group cleanup could not be confirmed')), 6000);
+            void cleanup.then(() => { clearTimeout(timer); resolve(); }, () => { clearTimeout(timer); reject(new Error('Provider process group cleanup could not be confirmed')); });
+        });
+        return this.cancelPromise;
+    }
+    revokeTools(tools) {
+        if (!tools || this.revokedTools === tools)
+            return;
+        this.revokedTools = tools;
+        try {
+            tools.revoke();
+        }
+        catch {
+            this.revokeFailed = true;
+        }
     }
-    async cleanup() {
+    cleanupPromise;
+    cleanup() {
+        if (this.cleanupPromise)
+            return this.cleanupPromise;
         this.localReadObservations();
         this.toolEndpoint = undefined;
         const tools = this.tools;
         const handle = this.handle;
         this.tools = undefined;
         this.handle = null;
-        try {
-            tools?.revoke();
-        }
-        finally {
+        const operation = Promise.resolve().then(async () => {
+            this.revokeTools(tools);
+            let failed = this.revokeFailed;
             try {
                 handle?.stdin.end();
             }
-            finally {
-                try {
-                    handle?.kill("SIGKILL");
-                }
-                finally {
-                    await tools?.close();
-                }
+            catch {
+                failed = true;
             }
-        }
+            try {
+                if (handle?.terminateOwned)
+                    await handle.terminateOwned();
+                else
+                    handle?.kill('SIGKILL');
+            }
+            catch {
+                failed = true;
+            }
+            try {
+                await tools?.close();
+            }
+            catch {
+                failed = true;
+            }
+            if (failed)
+                throw new Error('Provider process group cleanup could not be confirmed');
+        });
+        if (tools || handle)
+            this.cleanupPromise = operation;
+        return operation;
     }
     /** Claude Code treats a hook it cannot run as no objection, so the hook runs through Node. */
     requireTrustedHookCommand() {

package/dist/src/adapters/codex/adapter.js

@@ -1,4 +1,5 @@
 import { executionError } from '../../safety/execution-failure.js';
+import { UnsupportedSupervisorCommandError } from '../../safety/unsupported-supervisor-command.js';
 import { CodexExecLaunchHost } from './exec-launch-host.js';
 import { requireSecurityRequirements } from '../../safety/security-requirements.js';
 import { createJobSecurityReceipt } from '../../safety/job-security-receipt.js';
@@ -27,6 +28,8 @@ export class CodexAdapter {
     parser = new CodexStreamParser();
     startupAbort = new AbortController();
     securityPolicy;
+    /** Only the retained transport's pending owned-handle acquisition. */
+    pendingHandle;
     constructor(options) {
         this.options = options;
     }
@@ -117,6 +120,29 @@ export class CodexAdapter {
             await this.cancel();
             throw error;
         }
+        let lateCleanupFailed = false;
+        const stopReturnedHandle = async (handle) => {
+            let failed = false;
+            try {
+                handle.stdin.end();
+            }
+            catch {
+                failed = true;
+            }
+            try {
+                if (handle.terminateOwned)
+                    await handle.terminateOwned();
+                else
+                    handle.kill('SIGKILL');
+            }
+            catch {
+                failed = true;
+            }
+            if (failed) {
+                lateCleanupFailed = true;
+                throw new Error('Provider process group cleanup could not be confirmed');
+            }
+        };
         try {
             const prompt = compileCodexPrompt(pkg, this.options.jobId);
             this.tools = this.options.createTools(pkg, approved);
@@ -128,27 +154,46 @@ export class CodexAdapter {
                 worktreeRoot: this.options.cwd ?? this.options.worktreeRoot, sourceRoot: this.options.worktreeRoot, schemaPath, endpoint, env: this.options.env, scratch: this.options.scratch });
             if (!deferred)
                 assertAdmission();
-            const handle = await this.options.startVerifiedSession(invocation, prompt, this.startupAbort.signal, assertAdmission);
+            this.assertNotCancelled();
+            let settleHandle;
+            this.pendingHandle = new Promise((resolve, reject) => { settleHandle = error => { if (error)
+                reject(error);
+            else
+                resolve(); }; });
+            void this.pendingHandle.catch(() => { });
             try {
-                assertAdmission();
-            }
-            catch (error) {
-                this.tools.revoke();
-                handle.kill('SIGKILL');
-                throw error;
+                const handle = await this.options.startVerifiedSession(invocation, prompt, this.startupAbort.signal, assertAdmission);
+                try {
+                    assertAdmission();
+                }
+                catch (error) {
+                    try {
+                        this.tools.revoke();
+                    }
+                    finally {
+                        await stopReturnedHandle(handle);
+                    }
+                    throw error;
+                }
+                // Publish either the adopted handle or its exact disposal outcome before
+                // releasing cancellation. The outer catch may then await shared cancel.
+                if (this.cancelled) {
+                    await stopReturnedHandle(handle);
+                    this.assertNotCancelled();
+                }
+                this.handle = handle;
             }
-            // Cancellation may race with a transport returning its newly created handle.
-            if (this.cancelled) {
-                handle.kill("SIGKILL");
-                this.assertNotCancelled();
+            finally {
+                settleHandle(lateCleanupFailed ? new Error('Provider process group cleanup could not be confirmed') : undefined);
             }
-            this.handle = handle;
             if (deferred)
                 this.receipt = createJobSecurityReceipt(this.securityPolicy, { jobId: this.options.jobId, generation: ctx.generation, modelId: ctx.resolvedModelId, sourceSha: String(source.base_commit_sha), ...ctx.securityBinding, requirements: ctx.approvedTaskPackage?.security_requirements });
         }
         catch {
             const wasCancelled = this.cancelled;
             await this.cancel();
+            if (lateCleanupFailed)
+                throw new Error('Provider process group cleanup could not be confirmed');
             throw new Error(wasCancelled ? "Codex launch cancelled during startup" : "Codex job setup failed before execution could be confirmed");
         }
     }
@@ -200,33 +245,89 @@ export class CodexAdapter {
                 clearTimeout(timer);
         }
     }
-    async cancel() {
+    cancelPromise;
+    cancel() {
+        if (this.cancelPromise)
+            return this.cancelPromise;
         this.cancelled = true;
+        let finish, reject, failed = false;
+        this.cancelPromise = new Promise((resolve, rejectPromise) => { finish = resolve; reject = rejectPromise; });
+        const timer = setTimeout(() => reject(new Error('Provider process group cleanup could not be confirmed')), 6000);
+        // Let the official owner freeze its observations before external revocation.
+        // Known owner cleanup and endpoint closure start without waiting for a late
+        // retained handle; only confirmation waits for its acquisition/disposal.
+        let officialStop;
+        if (this.usingOfficialExec) {
+            try {
+                officialStop = this.ownedExec?.cancel();
+            }
+            catch {
+                failed = true;
+            }
+        }
         try {
-            if (this.usingOfficialExec)
-                await this.ownedExec?.cancel();
             this.options.revokeSecurity?.();
         }
-        finally {
-            try {
-                this.tools?.revoke();
+        catch {
+            failed = true;
+        }
+        try {
+            this.tools?.revoke();
+        }
+        catch {
+            failed = true;
+        }
+        this.startupAbort.abort();
+        const ownerStop = (async () => {
+            if (this.usingOfficialExec) {
+                try {
+                    await officialStop;
+                }
+                catch {
+                    failed = true;
+                }
             }
-            finally {
-                this.startupAbort.abort();
+            else {
                 try {
-                    if (!this.usingOfficialExec)
-                        this.handle?.kill("SIGKILL");
+                    this.handle?.stdin.end();
                 }
-                finally {
-                    try {
-                        await this.tools?.close();
-                    }
-                    finally {
-                        await this.options.closeOfficialExec?.();
-                    }
+                catch {
+                    failed = true;
+                }
+                try {
+                    if (this.handle?.terminateOwned)
+                        await this.handle.terminateOwned();
+                    else
+                        this.handle?.kill('SIGKILL');
+                }
+                catch {
+                    failed = true;
                 }
             }
+        })();
+        const toolsClose = (async () => { try {
+            await this.tools?.close();
         }
+        catch {
+            failed = true;
+        } })();
+        void (async () => {
+            const outcomes = await Promise.allSettled([ownerStop, toolsClose, this.pendingHandle]);
+            if (outcomes.some(outcome => outcome.status === 'rejected'))
+                failed = true;
+            try {
+                await this.options.closeOfficialExec?.();
+            }
+            catch {
+                failed = true;
+            }
+            clearTimeout(timer);
+            if (failed)
+                reject(new Error('Provider process group cleanup could not be confirmed'));
+            else
+                finish();
+        })();
+        return this.cancelPromise;
     }
     assertNotCancelled() {
         if (this.cancelled)
@@ -237,6 +338,6 @@ export class CodexAdapter {
             return this.cancel();
         if (command.command === "request_checkpoint")
             return;
-        throw new Error("Codex cannot resume or change an active approved launch");
+        throw new UnsupportedSupervisorCommandError();
     }
 }

package/dist/src/adapters/codex/exec-launch-host.js

@@ -120,7 +120,7 @@ export class CodexExecLaunchHost {
                 this.handle = h;
                 timing.mark('spawn_returned');
                 if (this.stopped) {
-                    h.kill('SIGKILL');
+                    await this.cancel();
                     throw fail();
                 }
                 h.once('exit', (code, signal) => {
@@ -295,16 +295,33 @@ export class CodexExecLaunchHost {
             cleanupError = true;
         }
         this.abort.abort();
-        try {
-            this.handle?.kill('SIGKILL');
-        }
-        catch {
-            cleanupError = true;
-        }
-        Promise.resolve().then(() => this.deps.closeTools()).then(() => { if (cleanupError)
-            reject(new Error('CODEX_EXEC_CLEANUP_UNCONFIRMED'));
-        else
-            finish(); }, () => reject(new Error('CODEX_EXEC_CLEANUP_UNCONFIRMED')));
+        Promise.resolve().then(async () => {
+            try {
+                this.handle?.stdin.end();
+            }
+            catch {
+                cleanupError = true;
+            }
+            try {
+                if (this.handle?.terminateOwned)
+                    await this.handle.terminateOwned();
+                else
+                    this.handle?.kill('SIGKILL');
+            }
+            catch {
+                cleanupError = true;
+            }
+            try {
+                await this.deps.closeTools();
+            }
+            catch {
+                cleanupError = true;
+            }
+            if (cleanupError)
+                reject(new Error('CODEX_EXEC_CLEANUP_UNCONFIRMED'));
+            else
+                finish();
+        });
         return this.closePromise;
     }
 }

package/dist/src/adapters/codex/stream-parser.js

@@ -1,21 +1,12 @@
 import { createHmac, randomBytes } from "node:crypto";
-import { completionEnvelope, completionEvent } from "../completion-report.js";
+import { completionEvent } from "../completion-report.js";
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
         ? value : undefined;
 }
-function finalReport(text) {
-    const complete = completionEvent(text);
-    if (complete.eventType === "completed")
-        return complete;
-    const value = completionEnvelope(text);
-    const bounded = (v, size) => typeof v === "string" && v.trim().length > 0 && v.length <= size;
-    const entries = (v, min) => Array.isArray(v) && v.length >= min && v.length <= 20 && v.every(item => bounded(item, 500));
-    if (!value || Object.keys(value).some(key => !["status", "report", "evidence", "pending_work"].includes(key))
-        || value.status !== "blocked" || !bounded(value.report, 2000)
-        || !entries(value.evidence, 0) || !entries(value.pending_work, 1))
-        return complete;
-    return { eventType: "blocked", summary: value.report.trim(), payload: { pending_work: value.pending_work, completion_evidence: value.evidence } };
+/** Valid blocked reports are terminal failures, but still count for uniqueness. */
+function acceptedReport(event) {
+    return event.eventType === "completed" || event.eventType === "failed" && event.payload?.reason === "executor_blocked";
 }
 /** Codex wire parsing is independent of Claude. Never forward reasoning or raw errors. */
 export class CodexStreamParser {
@@ -52,8 +43,8 @@ export class CodexStreamParser {
             }
             if (event.type === "item.completed" && item.type === "agent_message") {
                 this.messages += 1;
-                this.report = finalReport(item.text);
-                if (["completed", "blocked"].includes(this.report.eventType)) {
+                this.report = completionEvent(item.text);
+                if (acceptedReport(this.report)) {
                     this.candidates += 1;
                     // Bounded diagnostic sample only. Neither raw IDs nor text digests
                     // leave this parser, and sampling never changes report acceptance.
@@ -73,9 +64,9 @@ export class CodexStreamParser {
         const terminal = this.candidates === 0
             ? this.reportFailure(this.messages === 0 ? "CODEX_COMPLETION_REPORT_MISSING" : "CODEX_COMPLETION_REPORT_INVALID")
             : this.candidates > 1 ? this.reportFailure("CODEX_COMPLETION_REPORT_MULTIPLE")
-                : this.report && ["completed", "blocked"].includes(this.report.eventType) ? this.report
+                : this.report && acceptedReport(this.report) ? this.report
                     : this.reportFailure("CODEX_COMPLETION_REPORT_NOT_FINAL");
-        if (terminal.eventType === "blocked")
+        if (terminal.eventType === "failed" && terminal.payload?.reason === "executor_blocked")
             terminal.payload = { ...terminal.payload, completion_report: {
                     version: "codex-completion-report-v1", code: "CODEX_COMPLETION_REPORT_BLOCKED", agent_message_count: this.messages,
                     valid_report_count: this.candidates, invalid_message_count: this.messages - this.candidates, identity: this.reportIdentity(),

package/dist/src/adapters/completion-report.js

@@ -93,15 +93,18 @@ export function completionEvent(result, costUsd) {
     if (!value)
         return failed;
     if (Object.keys(value).some((key) => !["status", "report", "evidence", "pending_work"].includes(key))
-        || value.status !== "completed"
+        || value.status !== "completed" && value.status !== "blocked"
         || !boundedText(value.report, MAX_EVENT_SUMMARY_CHARS)
-        || !Array.isArray(value.pending_work) || value.pending_work.length !== 0
-        || !Array.isArray(value.evidence) || value.evidence.length < 1 || value.evidence.length > MAX_EVIDENCE_ITEMS
+        || !Array.isArray(value.pending_work) || value.pending_work.length > MAX_EVIDENCE_ITEMS
+        || (value.status === "completed" ? value.pending_work.length !== 0 : value.pending_work.length < 1)
+        || !value.pending_work.every((item) => boundedText(item, MAX_EVIDENCE_CHARS))
+        || !Array.isArray(value.evidence) || value.evidence.length < (value.status === "completed" ? 1 : 0) || value.evidence.length > MAX_EVIDENCE_ITEMS
         || !value.evidence.every((item) => boundedText(item, MAX_EVIDENCE_CHARS)))
         return failed;
     return {
-        eventType: "completed",
+        eventType: value.status === "completed" ? "completed" : "failed",
         summary: value.report.trim(),
-        payload: { ...usage, investigation_summary: value.report.trim(), completion_evidence: value.evidence },
+        payload: { ...usage, investigation_summary: value.report.trim(), completion_evidence: value.evidence,
+            ...(value.status === "blocked" ? { reason: "executor_blocked", pending_work: value.pending_work } : {}) },
     };
 }

package/dist/src/daemon/daemon.js

@@ -1,15 +1,73 @@
 export class Daemon {
     deps;
+    stopping = new AbortController();
     constructor(deps) {
         this.deps = deps;
     }
+    stop() { this.deps.poller.stop?.(); this.stopping.abort(); }
+    async suspend(state, duringExecution = false) {
+        const phase = state && typeof state === 'object' && 'phase' in state ? state.phase : undefined;
+        const reason = duringExecution ? 'execution_outcome_unknown' : phase === 'binding' || phase === 'binding_uncertain' ? 'binding_outcome_unknown' : 'runner_restarted';
+        try {
+            await this.deps.state.suspend?.(reason);
+        }
+        catch { /* Preserve original state and remain alive even if the marker cannot be written. */ }
+        try {
+            this.deps.reportRecoveryRequired?.(reason);
+        }
+        catch { /* Logging cannot reopen claims or exit suspended recovery. */ }
+        if (this.stopping.signal.aborted)
+            return;
+        if (this.deps.wait) {
+            await this.deps.wait(this.stopping.signal);
+            return;
+        }
+        // A pending promise does not keep Node alive. This timer deliberately stays
+        // referenced, holds the process lock and wakes only for explicit close.
+        await new Promise(resolve => {
+            const timer = setInterval(() => { }, 60_000);
+            this.stopping.signal.addEventListener('abort', () => { clearInterval(timer); resolve(); }, { once: true });
+        });
+    }
     async run() {
         await this.deps.lock.acquire();
         try {
-            const state = await this.deps.state.load();
-            if (state)
-                await this.deps.reconcile(state);
-            await this.deps.poller.run();
+            let state;
+            try {
+                state = await this.deps.state.load();
+                if (state !== null && state !== undefined) {
+                    await this.deps.reconcile(state);
+                    state = await this.deps.state.load();
+                }
+            }
+            catch {
+                await this.suspend(state);
+                return;
+            }
+            if (state !== null && state !== undefined) {
+                await this.suspend(state);
+                return;
+            }
+            if (this.stopping.signal.aborted)
+                return;
+            try {
+                await this.deps.poller.run();
+            }
+            catch {
+                try {
+                    this.deps.poller.stop?.();
+                }
+                catch { /* Still inspect retained state and suspend below. */ }
+            }
+            try {
+                state = await this.deps.state.load();
+            }
+            catch {
+                await this.suspend(undefined, true);
+                return;
+            }
+            if (state !== null && state !== undefined)
+                await this.suspend(state, true);
         }
         finally {
             await this.deps.lock.release();