mtech-ai-local-runner 0.1.37 → 0.1.39

package/README.md

@@ -1,3 +1,19 @@
+## 0.1.39: keep the first failure when executor cleanup is unconfirmed
+
+A job whose Codex executor could not confirm its cleanup was suspended with only `EXECUTION_UNACKNOWLEDGED` in the
+daemon log: the unconfirmed stop was rethrown before the failure was logged. The daemon now writes the stage that
+failed first (P1 runs use `p1_freeze`, `p1_verify` and `p1_receipts`) and a second `execution_failed` line with
+stage `executor_cleanup`, whose fixed `cleanup_*` observations name the cleanup step that failed or was still
+pending at the deadline. Suspension and manual reconciliation are unchanged.
+
+## 0.1.38: find the Codex app shipped as ChatGPT.app
+
+0.1.37 looked only for `Codex.app`, so a Mac whose Codex app is the ChatGPT app (`/Applications/ChatGPT.app`,
+bundle id `com.openai.codex`) reported `chatgpt: null` and got no [Open in ChatGPT] button. The runner now also
+takes `ChatGPT.app`, in `/Applications` or `~/Applications`, when its Info.plist registers the `codex` URL
+scheme. It reads the plist with `/usr/bin/plutil` (no shell, five-second timeout). The plain ChatGPT chat app
+registers no `codex` scheme and is still not taken. Nothing else changes.
+
 ## 0.1.37: open my AI session from Slack
 
 The daemon runs a second loop beside the job poller. When its employee presses [Open in Claude] or

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

@@ -1,4 +1,4 @@
-import { executionError } from '../../safety/execution-failure.js';
+import { executionError, unconfirmedCleanupError, cleanupObservations } 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';
@@ -250,9 +250,27 @@ export class CodexAdapter {
         if (this.cancelPromise)
             return this.cancelPromise;
         this.cancelled = true;
-        let finish, reject, failed = false;
+        let finish, reject;
+        // Fixed step names only: which cleanup step failed, or was still pending at the deadline.
+        const failed = new Set(), pending = new Set();
+        const unconfirmed = () => unconfirmedCleanupError('Provider process group cleanup could not be confirmed', [...failed, ...pending]);
+        const step = async (name, work) => {
+            const waiting = `cleanup_${name}_pending`;
+            pending.add(waiting);
+            try {
+                await work();
+            }
+            catch (error) {
+                failed.add(`cleanup_${name}_failed`);
+                for (const inner of cleanupObservations(error))
+                    failed.add(inner);
+            }
+            finally {
+                pending.delete(waiting);
+            }
+        };
         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);
+        const timer = setTimeout(() => { failed.add('cleanup_timeout'); reject(unconfirmed()); }, 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.
@@ -262,68 +280,53 @@ export class CodexAdapter {
                 officialStop = this.ownedExec?.cancel();
             }
             catch {
-                failed = true;
+                failed.add('cleanup_owner_stop_failed');
             }
         }
         try {
             this.options.revokeSecurity?.();
         }
         catch {
-            failed = true;
+            failed.add('cleanup_security_revoke_failed');
         }
         try {
             this.tools?.revoke();
         }
         catch {
-            failed = true;
+            failed.add('cleanup_tools_revoke_failed');
         }
         this.startupAbort.abort();
-        const ownerStop = (async () => {
+        const ownerStop = step('owner_stop', async () => {
             if (this.usingOfficialExec) {
-                try {
-                    await officialStop;
-                }
-                catch {
-                    failed = true;
-                }
+                await officialStop;
+                return;
             }
-            else {
-                try {
-                    this.handle?.stdin.end();
-                }
-                catch {
-                    failed = true;
-                }
-                try {
-                    if (this.handle?.terminateOwned)
-                        await this.handle.terminateOwned();
-                    else
-                        this.handle?.kill('SIGKILL');
-                }
-                catch {
-                    failed = true;
-                }
+            let stopFailed = false;
+            try {
+                this.handle?.stdin.end();
+            }
+            catch {
+                stopFailed = 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?.();
+                if (this.handle?.terminateOwned)
+                    await this.handle.terminateOwned();
+                else
+                    this.handle?.kill('SIGKILL');
             }
             catch {
-                failed = true;
+                stopFailed = true;
             }
+            if (stopFailed)
+                throw Error('owner stop failed');
+        });
+        const toolsClose = step('tools_close', () => this.tools?.close());
+        void (async () => {
+            await Promise.all([ownerStop, toolsClose, step('pending_handle', () => this.pendingHandle)]);
+            await step('official_exec_close', () => this.options.closeOfficialExec?.());
             clearTimeout(timer);
-            if (failed)
-                reject(new Error('Provider process group cleanup could not be confirmed'));
+            if (failed.size)
+                reject(unconfirmed());
             else
                 finish();
         })();

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

@@ -2,7 +2,7 @@ import { performance } from 'node:perf_hooks';
 import { PreparationClock, CODEX_PREPARATION_BUDGET_MS } from '../../safety/preparation-timing.js';
 import { localEndpointObservations, localEndpointReadObservations } from '../../safety/local-tool-server.js';
 import { processStartupObservations, freezeProcessLaunchObservation } from '../../process/node-process-group-host.js';
-import { executionError } from '../../safety/execution-failure.js';
+import { executionError, unconfirmedCleanupError } from '../../safety/execution-failure.js';
 import { UNMANAGED_EXEC_MODE } from './unmanaged-scope.js';
 import { fingerprint as taskFingerprint } from '../../daemon/execution-coordinator.js';
 import { securityRequirementsFingerprint as hash } from '../../safety/security-requirements.js';
@@ -280,19 +280,19 @@ export class CodexExecLaunchHost {
         }
         let finish, reject;
         this.closePromise = new Promise((resolve, rejectPromise) => { finish = resolve; reject = rejectPromise; });
-        let cleanupError = false;
+        const failed = new Set();
         // Publish closePromise first: synchronous exit/cancel cannot recurse or skip cleanup.
         try {
             this.deps.execTools?.revoke();
         }
         catch {
-            cleanupError = true;
+            failed.add('cleanup_exec_tools_revoke_failed');
         }
         try {
             this.deps.revokeTools();
         }
         catch {
-            cleanupError = true;
+            failed.add('cleanup_job_tools_revoke_failed');
         }
         this.abort.abort();
         Promise.resolve().then(async () => {
@@ -300,7 +300,7 @@ export class CodexExecLaunchHost {
                 this.handle?.stdin.end();
             }
             catch {
-                cleanupError = true;
+                failed.add('cleanup_stdin_end_failed');
             }
             try {
                 if (this.handle?.terminateOwned)
@@ -309,16 +309,16 @@ export class CodexExecLaunchHost {
                     this.handle?.kill('SIGKILL');
             }
             catch {
-                cleanupError = true;
+                failed.add('cleanup_process_terminate_failed');
             }
             try {
                 await this.deps.closeTools();
             }
             catch {
-                cleanupError = true;
+                failed.add('cleanup_tool_server_close_failed');
             }
-            if (cleanupError)
-                reject(new Error('CODEX_EXEC_CLEANUP_UNCONFIRMED'));
+            if (failed.size)
+                reject(unconfirmedCleanupError('CODEX_EXEC_CLEANUP_UNCONFIRMED', failed));
             else
                 finish();
         });

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

@@ -476,9 +476,12 @@ export class ExecutionCoordinator {
                                     await publicationStep(() => adapter.freezeForPublication());
                                     lifecycle.frozen = true;
                                 } await assertModelFrozen(); };
+                                executionStage = 'p1_freeze';
                                 await freezeOwnedModel();
                                 await readControls();
+                                executionStage = 'p1_verify';
                                 p1Result = await publicationStep(() => this.deps.p1Host.verify({ job, checkoutPath: workspace.path, bindingId: binding.bindingId, signal: verificationAbort.signal, current, freezeOwnedModel, assertModelFrozen }));
+                                executionStage = 'p1_receipts';
                                 await readControls();
                                 await assertModelFrozen();
                                 const seen = new Set();
@@ -491,6 +494,7 @@ export class ExecutionCoordinator {
                                     const id = await publicationStep(() => append({ eventType: 'test_result', summary: 'runner command observed', payload: { observer: 'runner', runner_receipt: receipt } }, true));
                                     p1ReceiptIds.push(id);
                                 }
+                                executionStage = 'event_stream';
                             }
                             if (event.eventType === "completed" && fixSession) {
                                 // Stop only this owned model before running verified host publication.
@@ -572,7 +576,22 @@ export class ExecutionCoordinator {
             await append(terminal);
         }
         catch (error) {
-            await stop(true);
+            try {
+                await stop(true);
+            }
+            catch (cleanupError) {
+                // An unconfirmed executor stop keeps the job suspended, but it must not erase
+                // the stage that failed first: log both fixed diagnostics before rethrowing.
+                try {
+                    this.deps.reportExecutionFailure?.(executionFailure(error, executionStage));
+                }
+                catch { /* logging must not change terminal reconciliation */ }
+                try {
+                    this.deps.reportExecutionFailure?.(executionFailure(cleanupError, 'executor_cleanup'));
+                }
+                catch { /* logging must not change terminal reconciliation */ }
+                throw cleanupError;
+            }
             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.

package/dist/src/daemon/session-opener.js

@@ -32,19 +32,46 @@ const LINKS = {
 const defaultExists = async (path) => access(path).then(() => true, () => false);
 // A timeout keeps a hung `open` from blocking the opens loop; there is still no shell.
 const defaultRun = (file, args) => execFileAsync(file, args, { timeout: 10_000 });
-/** The app each client opens on this Mac: the Claude desktop app before Claude Code's URL handler. */
+// plutil reads both XML and binary property lists.
+const defaultUrlSchemes = async (infoPlist) => {
+    const stdout = await new Promise((resolve, reject) => {
+        execFile("/usr/bin/plutil", ["-convert", "json", "-o", "-", infoPlist], { timeout: 5_000 }, (error, out) => error ? reject(error) : resolve(String(out)));
+    });
+    const types = JSON.parse(stdout).CFBundleURLTypes;
+    return Array.isArray(types) ? types.flatMap(type => {
+        const schemes = type?.CFBundleURLSchemes;
+        return Array.isArray(schemes) ? schemes.filter((scheme) => typeof scheme === "string") : [];
+    }) : [];
+};
+/**
+ * The app each client opens on this Mac: the Claude desktop app before Claude Code's URL handler. The Codex app
+ * is Codex.app, or ChatGPT.app when that app registers the codex scheme (the ChatGPT app that bundles Codex
+ * ships as com.openai.codex); the plain ChatGPT chat app registers no codex scheme and is not taken.
+ */
 export async function detectSessionSurfaces(deps) {
     const exists = deps.exists ?? defaultExists;
+    const urlSchemes = deps.urlSchemes ?? defaultUrlSchemes;
     const anyOf = async (paths) => {
         for (const path of paths)
             if (await exists(path))
                 return true;
         return false;
     };
+    const registersCodex = async (paths) => {
+        for (const path of paths) {
+            if (!await exists(path))
+                continue;
+            const schemes = await urlSchemes(join(path, "Contents", "Info.plist")).catch(() => []);
+            if (schemes.includes("codex"))
+                return true;
+        }
+        return false;
+    };
     const userApplications = deps.home === "" ? [] : [join(deps.home, "Applications")];
-    const desktop = await anyOf(["/Applications/Claude.app", ...userApplications.map(dir => join(dir, "Claude.app"))]);
+    const inApplications = (app) => [join("/Applications", app), ...userApplications.map(dir => join(dir, app))];
+    const desktop = await anyOf(inApplications("Claude.app"));
     const cli = deps.home !== "" && await exists(join(deps.home, "Applications", "Claude Code URL Handler.app"));
-    const codex = await anyOf(["/Applications/Codex.app", ...userApplications.map(dir => join(dir, "Codex.app"))]);
+    const codex = await anyOf(inApplications("Codex.app")) || await registersCodex(inApplications("ChatGPT.app"));
     return { claude: desktop ? "claude_desktop" : cli ? "claude_cli" : null, chatgpt: codex ? "codex_app" : null };
 }
 export async function sessionOpenAdvertisement(deps) {
@@ -67,7 +94,7 @@ export class SessionOpener {
             return { status: "failed", failureCode: "invalid_request" };
         let clients;
         try {
-            clients = await detectSessionSurfaces({ home: this.deps.home, exists: this.deps.exists });
+            clients = await detectSessionSurfaces({ home: this.deps.home, exists: this.deps.exists, urlSchemes: this.deps.urlSchemes });
         }
         catch {
             return { status: "failed", failureCode: "handler_missing" };

package/dist/src/safety/execution-failure.js

@@ -13,6 +13,12 @@ export const STARTUP_OBSERVATIONS = Object.freeze([
     'native_stdin_read', 'native_model_catalog_failed', 'native_cloud_policy_failed', 'native_cloud_policy_timeout',
     'native_required_mcp_failed', 'native_config_failed', 'native_auth_refresh_unsupported',
     'local_mcp_request_received', 'local_mcp_auth_rejected', 'local_mcp_origin_or_host_rejected', 'local_mcp_initialize_received',
+    // Unconfirmed executor cleanup: which fixed step failed, or was still pending at its deadline.
+    'cleanup_owner_stop_failed', 'cleanup_owner_stop_pending', 'cleanup_security_revoke_failed', 'cleanup_tools_revoke_failed',
+    'cleanup_tools_close_failed', 'cleanup_tools_close_pending', 'cleanup_pending_handle_failed', 'cleanup_pending_handle_pending',
+    'cleanup_official_exec_close_failed', 'cleanup_official_exec_close_pending',
+    'cleanup_exec_tools_revoke_failed', 'cleanup_job_tools_revoke_failed', 'cleanup_stdin_end_failed', 'cleanup_process_terminate_failed',
+    'cleanup_tool_server_close_failed', 'cleanup_timeout',
 ]);
 const issued = new WeakMap();
 export function executionFailure(error, stage, fallback = 'EXECUTION_FAILED') {
@@ -42,6 +48,20 @@ export function executionFailure(error, stage, fallback = 'EXECUTION_FAILED') {
     }
     return { stage, code: fallback };
 }
+/** An unconfirmed cleanup keeps its fixed message for callers and carries only fixed
+ * `cleanup_*` observations, never the underlying error, path or provider output. */
+export function unconfirmedCleanupError(message, observations) {
+    const seen = new Set(observations);
+    const fixed = STARTUP_OBSERVATIONS.filter(value => value.startsWith('cleanup_') && seen.has(value));
+    const error = new Error(message);
+    issued.set(error, Object.freeze({ stage: 'executor_cleanup', code: 'EXECUTION_FAILED', ...(fixed.length ? { observations: fixed } : {}) }));
+    return error;
+}
+/** The fixed cleanup observations an inner owner issued, for an outer owner to carry. */
+export function cleanupObservations(error) {
+    const trusted = error && typeof error === 'object' ? issued.get(error) : undefined;
+    return (trusted?.observations ?? []).filter(value => value.startsWith('cleanup_'));
+}
 export function executionError(error, stage, fallback, detail, observations, preparationTiming, launchObservation) {
     const diagnostic = executionFailure(error, stage, fallback);
     // Only trusted callers supply this fixed vocabulary. Serialized provider

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mtech-ai-local-runner",
-  "version": "0.1.37",
+  "version": "0.1.39",
   "private": false,
   "license": "UNLICENSED",
   "bin": {