mtech-ai-local-runner 0.1.12 → 0.1.13

package/README.md

@@ -125,6 +125,20 @@ or cost termination limits on an approved unbounded employee-local Claude run.
 Existing generation fencing, scope restrictions, cancellation and audit remain
 in force.
 
+### MCP startup failure diagnostics (0.1.13)
+
+Codex startup now distinguishes an owned process exiting before admission,
+preparation timeout, explicit abort and rejected MCP discovery. A fixed `detail`
+reports whether initialize, initialized notification or tool inventory is still
+missing (or discovery completed). The first issued cause survives cleanup and
+outer catches and reaches both the failed event and terminal Job result.
+Raw provider stderr remains excluded. These diagnostics do not establish the
+historical failure cause or prove whether provider inference occurred.
+
+The preparation deadline and mandatory authenticated MCP checks are unchanged.
+There is no automatic model retry or task duration/count cap. Installing this
+patch does not authorize another actual Codex attempt or change login/settings.
+
 ### Post-binding execution diagnostics (0.1.12)
 
 The manual command and daemon log an `execution_failed` diagnostic (the manual

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

@@ -63,13 +63,16 @@ export class CodexExecLaunchHost {
         this.ownsAttempt = true;
         this.used = true;
         let stage = 'codex_context';
+        let interruption;
+        const mcpDetail = () => stage === 'codex_mcp' ? this.deps.execTools?.discoveryDetail() : undefined;
+        const interrupt = (code) => { interruption ??= executionError(fail(), stage, code, mcpDetail()); };
         let timer, external;
         try {
             this.assertContext(ctx, jobId);
             requireOfficialExecPlan(this.plan);
             if (typeof prompt !== 'string' || !prompt || prompt.length > 1_000_000 || signal?.aborted)
                 throw fail();
-            const stopped = new Promise((_, reject) => { external = () => { void this.cancel().catch(() => { }); reject(fail()); }; this.abort.signal.addEventListener('abort', () => reject(fail()), { once: true }); signal?.addEventListener('abort', external, { once: true }); timer = setTimeout(external, 30_000); });
+            const stopped = new Promise((_, reject) => { external = () => { interrupt('CODEX_EXEC_ABORTED'); void this.cancel().catch(() => { }); reject(interruption); }; this.abort.signal.addEventListener('abort', () => reject(interruption ?? fail()), { once: true }); signal?.addEventListener('abort', external, { once: true }); timer = setTimeout(() => { interrupt('CODEX_EXEC_PREPARATION_TIMEOUT'); external(); }, 30_000); });
             const preparation = (async () => {
                 const supported = isReleaseExecMode(this.plan.mode);
                 stage = 'codex_inspection';
@@ -95,6 +98,8 @@ export class CodexExecLaunchHost {
                     throw fail();
                 }
                 h.once('exit', (code, signal) => {
+                    if (!this.stopped && !this.receiptValue)
+                        interrupt('CODEX_EXEC_PROCESS_EXITED');
                     // Preserve audit only for a clean owned exit that was still authorized.
                     // This immutable record never restores tool or spawn authority.
                     if (code === 0 && signal === null && !this.stopped && this.receiptValue) {
@@ -153,7 +158,7 @@ export class CodexExecLaunchHost {
             return await Promise.race([preparation, stopped]);
         }
         catch (error) {
-            const safe = executionError(error, stage, 'CODEX_EXEC_PREFLIGHT_REJECTED');
+            const safe = executionError(interruption ?? error, stage, 'CODEX_EXEC_PREFLIGHT_REJECTED', mcpDetail());
             await this.cancel().catch(() => { });
             throw safe;
         }

package/dist/src/adapters/codex/exec-tool-gate.js

@@ -1,6 +1,7 @@
 import { isReleaseExecMode, requireOfficialExecPlan } from './exec-invocation.js';
 import { localDiscoveryScopeMatches, localToolInventory } from '../../safety/local-tool-server.js';
 import { securityRequirementsFingerprint as hash } from '../../safety/security-requirements.js';
+import { executionError } from '../../safety/execution-failure.js';
 const denied = () => Error('EXEC_TOOL_GATE_REJECTED');
 /** Host-owned capability, never populated from stdout/task data. Authenticated
  * discovery is server-side evidence; it does not attest OS client identity. */
@@ -29,6 +30,9 @@ export class ExecToolGate {
     catch {
         return false;
     } }
+    /** Metadata only: survives revocation; contains no endpoint or credential. */
+    discoveryDetail() { return ['mcp_initialize_missing', 'mcp_initialized_missing', 'mcp_inventory_missing', 'mcp_discovery_complete'][this.stage]; }
+    readinessError() { return executionError(denied(), 'codex_mcp', 'CODEX_EXEC_MCP_REJECTED', this.discoveryDetail()); }
     promptSubmitted(process) { if (this.process !== process || this.submitted || !this.active())
         throw denied(); this.submitted = true; }
     discovery = (event, scope) => {
@@ -60,17 +64,17 @@ export class ExecToolGate {
     };
     async wait(process, signal) {
         if (this.process !== process || !this.submitted || !this.active() || signal.aborted)
-            throw denied();
+            throw this.readinessError();
         if (this.stage !== 3)
             await new Promise((resolve, reject) => {
-                const abort = () => { clear(); reject(denied()); };
+                const abort = () => { clear(); reject(this.readinessError()); };
                 const clear = () => { signal.removeEventListener('abort', abort); this.settle = undefined; this.reject = undefined; };
                 this.reject = abort;
                 this.settle = () => { clear(); resolve(); };
                 signal.addEventListener('abort', abort, { once: true });
             });
         if (!this.active() || signal.aborted || this.stage !== 3)
-            throw denied();
+            throw this.readinessError();
         return { process, executionNonce: this.plan.executionNonce, endpoint: this.plan.endpoint, authenticated: true, ready: true, toolSchemaFingerprint: this.plan.identity.toolSchemaFingerprint, tools: localToolInventory().map(t => t.name), isCurrent: () => this.active() && this.stage === 3 };
     }
     authorize(process) { if (process !== this.process || !this.active() || this.stage !== 3)

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

@@ -24,8 +24,12 @@ export function executionFailure(error, stage, fallback = 'EXECUTION_FAILED') {
     }
     return { stage, code: fallback };
 }
-export function executionError(error, stage, fallback) {
+export function executionError(error, stage, fallback, detail) {
     const diagnostic = executionFailure(error, stage, fallback);
+    // Only trusted callers supply this fixed vocabulary. Serialized provider
+    // errors, messages and stderr never become diagnostic authority.
+    if (!issued.has(error) && ['mcp_initialize_missing', 'mcp_initialized_missing', 'mcp_inventory_missing', 'mcp_discovery_complete'].includes(detail))
+        diagnostic.detail = detail;
     const safe = new Error(fallback);
     issued.set(safe, Object.freeze(diagnostic));
     return safe;

package/package.json

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