mtech-ai-local-runner 0.1.38 → 0.1.40

package/README.md

@@ -1,3 +1,18 @@
+## 0.1.40: say why the owned guardian could not confirm cleanup
+
+When the owned guardian reports an unconfirmed cleanup, the `executor_cleanup` diagnostic now carries fixed
+`cleanup_guardian_*` observations: what started the cleanup, how TERM and KILL went, whether the executor group was
+still alive and its pipes still open, whether the root had exited, and whether the host's deadline passed. Cleanup
+decisions, deadlines and recovery are unchanged.
+
+## 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`,

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, cleanupObservations } 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)
@@ -308,17 +308,19 @@ export class CodexExecLaunchHost {
                 else
                     this.handle?.kill('SIGKILL');
             }
-            catch {
-                cleanupError = true;
+            catch (error) {
+                failed.add('cleanup_process_terminate_failed');
+                for (const observed of cleanupObservations(error))
+                    failed.add(observed);
             }
             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/process/node-process-group-host.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { OwnedLaunchObserver } from './owned-launch-observer.js';
+import { unconfirmedCleanupError } from '../safety/execution-failure.js';
 const startup = new WeakMap();
 const launchObservers = new WeakMap();
 export function freezeProcessLaunchObservation(handle) { return launchObservers.get(handle)?.freeze(); }
@@ -142,7 +143,7 @@ export class NodeProcessGroupHost {
                 return;
             realExit = true;
             observations.add('host_process_exited');
-            void guardian.terminate().then(() => { owned = false; const result = guardian.outcome(); terminated(result?.code ?? null, result?.signal ?? null); }, () => { failure = new Error('Provider process group cleanup could not be confirmed'); terminated(null, null); notify(); });
+            void guardian.terminate().then(() => { owned = false; const result = guardian.outcome(); terminated(result?.code ?? null, result?.signal ?? null); }, () => { failure = unconfirmedCleanupError('Provider process group cleanup could not be confirmed', guardian.cleanupObservations?.() ?? []); terminated(null, null); notify(); });
         });
         // Drain from spawn, not from the first adapter event read: official exec can
         // emit startup events before it initializes MCP, while the adapter awaits
@@ -266,7 +267,18 @@ export class NodeProcessGroupHost {
                         clearTimeout(timer);
                 }
             },
-            terminateOwned: () => cleanupPromise ??= (async () => { launch?.stop(); stopInput(); await guardian.terminate(); owned = false; })(),
+            terminateOwned: () => cleanupPromise ??= (async () => {
+                launch?.stop();
+                stopInput();
+                // Keep the fixed message; carry only the guardian's fixed cleanup observations.
+                try {
+                    await guardian.terminate();
+                }
+                catch {
+                    throw unconfirmedCleanupError('Provider process group cleanup could not be confirmed', guardian.cleanupObservations?.() ?? []);
+                }
+                owned = false;
+            })(),
             once: (_event, callback) => { if (termination) {
                 const ended = termination;
                 queueMicrotask(() => callback(ended.code, ended.signal));

package/dist/src/process/owned-process-guardian.js

@@ -12,30 +12,35 @@ let child, ownedPid, ownedGone=false, cleaning, ready=Promise.resolve(), rootExi
 const send=value=>{if(!control.destroyed)control.write(JSON.stringify(value)+'\n');};
 const delay=ms=>new Promise(resolve=>setTimeout(resolve,ms));
 const alive=()=>{if(!ownedPid||ownedGone)return false;try{process.kill(-ownedPid,0);return true;}catch(e){if(e.code==='ESRCH'){ownedGone=true;return false;}if(e.code==='EPERM')return true;throw Error('cleanup');}};
-const signal=s=>{if(!ownedPid)throw Error('ownership');if(ownedGone)return;try{process.kill(-ownedPid,s);}catch(e){if(e.code==='ESRCH'){ownedGone=true;return;}if(e.code==='EPERM'){if(!rootExited)child.kill(s);return;}throw Error('cleanup');}};
-function cleanup(immediate=false){
+const signal=s=>{if(!ownedPid)throw Error('ownership');if(ownedGone)return 'esrch';try{process.kill(-ownedPid,s);return 'sent';}catch(e){if(e.code==='ESRCH'){ownedGone=true;return 'esrch';}if(e.code==='EPERM'){if(!rootExited)child.kill(s);return 'eperm';}throw Error('cleanup');}};
+// Fixed words only: what started cleanup, each signal outcome and what was still open.
+function cleanup(immediate=false,trigger='terminate'){
  if(cleaning)return cleaning;
+ const detail={trigger,term:'not_needed',kill:'not_needed'};
  cleaning=(async()=>{
   try{
    if(!child)throw Error('ownership');
    await ready;
    child.stdin.end();
    if(ownedPid){
-    if(alive())signal(immediate?'SIGKILL':'SIGTERM');
+    if(alive())detail.term=signal(immediate?'SIGKILL':'SIGTERM');
     const deadline=Date.now()+(immediate?0:2000);
     while(alive()&&Date.now()<deadline)await delay(20);
-    if(alive())signal('SIGKILL');
+    if(alive())detail.kill=signal('SIGKILL');
     const killed=Date.now()+2000;
     while((alive()||!closed)&&Date.now()<killed)await delay(20);
     if(alive()||!closed)throw Error('cleanup');
    }
    send({type:'cleaned'});finish(0);
-  }catch{send({type:'unconfirmed'});finish(1);}
+  }catch{
+   let groupAlive=true;try{groupAlive=alive();}catch{/* an unknown liveness error stays alive */}
+   send({type:'unconfirmed',detail:{...detail,alive:groupAlive,closed,root:rootExited}});finish(1);
+  }
  })();
  return cleaning;
 }
 function finish(code){process.exitCode=code;process.stdin.destroy();liveness.destroy();control.end(()=>control.destroy());process.stdout.end();process.stderr.end();}
-function lost(){orphaned=true;if(configured)void cleanup();else finish(1);}
+function lost(){orphaned=true;if(configured)void cleanup(false,'lost');else finish(1);}
 liveness.on('data',()=>{});liveness.once('end',lost);liveness.once('error',lost);
 control.on('error',lost);control.on('end',lost);
 control.on('data',chunk=>{
@@ -47,19 +52,19 @@ control.on('data',chunk=>{
    configured=true;
    try{child=spawn(message.command,message.args,{cwd:message.cwd,env:message.env,shell:false,detached:true,stdio:['pipe','pipe','pipe']});}catch{send({type:'spawn_failed'});finish(0);return;}
    ready=new Promise(resolve=>{
-    child.once('spawn',()=>{ownedPid=child.pid;send({type:'spawned',pid:ownedPid,parentPid:process.pid});resolve();if(orphaned)void cleanup();});
-    child.once('error',()=>{send({type:'spawn_failed'});closed=true;resolve();void cleanup(true);});
+    child.once('spawn',()=>{ownedPid=child.pid;send({type:'spawned',pid:ownedPid,parentPid:process.pid});resolve();if(orphaned)void cleanup(false,'lost');});
+    child.once('error',()=>{send({type:'spawn_failed'});closed=true;resolve();void cleanup(true,'spawn_error');});
    });
    child.stdin.on('error',()=>{});
    process.stdin.pipe(child.stdin);child.stdout.pipe(process.stdout,{end:false});child.stderr.pipe(process.stderr,{end:false});
-   child.once('exit',(code,signal)=>{rootExited=true;send({type:'root_exit',code,signal});void cleanup();});
+   child.once('exit',(code,signal)=>{rootExited=true;send({type:'root_exit',code,signal});void cleanup(false,'root_exit');});
    child.once('close',()=>{closed=true;});
-  }else if(message.type==='terminate')void cleanup(message.immediate===true);
+  }else if(message.type==='terminate')void cleanup(message.immediate===true,'terminate');
   else lost();
  }
 });
-process.stdout.on('error',()=>{child?.stdout.resume();void cleanup(true);});
-process.stderr.on('error',()=>{child?.stderr.resume();void cleanup(true);});
+process.stdout.on('error',()=>{child?.stdout.resume();void cleanup(true,'output_error');});
+process.stderr.on('error',()=>{child?.stderr.resume();void cleanup(true,'output_error');});
 `;
 export function spawnOwnedGuardian(command, args, options) {
     const child = spawn(process.execPath, ['--input-type=commonjs', '-e', GUARDIAN_SOURCE], {
@@ -73,6 +78,7 @@ export function spawnOwnedGuardian(command, args, options) {
     // Hosts can attach observers after spawn returns without unhandled rejection.
     void started.catch(() => { });
     let confirmed = false, spawnFailed = false, protocolFailed = false, buffer = '';
+    let terminateWritten = false, hostTimeout = false, detail;
     let outcome;
     let closePromise;
     const closed = new Promise(resolve => child.once('close', () => { liveness.destroy(); resolve(); }));
@@ -109,8 +115,11 @@ export function spawnOwnedGuardian(command, args, options) {
                 outcome = { code: message.code, signal: message.signal };
             else if (message.type === 'cleaned')
                 confirmed = true;
-            else if (message.type === 'unconfirmed')
+            else if (message.type === 'unconfirmed') {
                 protocolFailed = true;
+                if (message.detail && typeof message.detail === 'object' && !Array.isArray(message.detail))
+                    detail = message.detail;
+            }
             else {
                 protocolFailed = true;
                 liveness.destroy();
@@ -121,14 +130,16 @@ export function spawnOwnedGuardian(command, args, options) {
     child.once('close', () => { rejectStarted(new Error('Provider process could not start')); });
     control.write(JSON.stringify({ type: 'launch', command, args, ...options }) + '\n');
     return { child, started, closed, outcome: () => outcome, spawnFailed: () => spawnFailed,
-        signal(immediate) { if (child.exitCode === null && child.signalCode === null && !confirmed && !spawnFailed && !control.destroyed)
-            control.write(JSON.stringify({ type: 'terminate', immediate }) + '\n'); },
+        signal(immediate) { if (child.exitCode === null && child.signalCode === null && !confirmed && !spawnFailed && !control.destroyed) {
+            control.write(JSON.stringify({ type: 'terminate', immediate }) + '\n');
+            terminateWritten = true;
+        } },
         terminate(immediate = false) {
             if (closePromise)
                 return closePromise;
             this.signal(immediate);
             closePromise = new Promise((resolve, reject) => {
-                const timer = setTimeout(() => { protocolFailed = true; liveness.destroy(); reject(new Error('Provider process group cleanup could not be confirmed')); }, 5500);
+                const timer = setTimeout(() => { protocolFailed = true; hostTimeout = true; liveness.destroy(); reject(new Error('Provider process group cleanup could not be confirmed')); }, 5500);
                 void closed.then(() => { clearTimeout(timer); if (protocolFailed || !confirmed)
                     reject(new Error('Provider process group cleanup could not be confirmed'));
                 else
@@ -136,5 +147,36 @@ export function spawnOwnedGuardian(command, args, options) {
             });
             return closePromise;
         },
+        /** Fixed cleanup observations after an unconfirmed cleanup; empty once cleanup is confirmed. */
+        cleanupObservations() {
+            if (confirmed && !protocolFailed)
+                return [];
+            if (!protocolFailed && !hostTimeout)
+                return [];
+            const observed = [terminateWritten ? 'cleanup_guardian_terminate_written' : 'cleanup_guardian_terminate_not_written'];
+            if (hostTimeout)
+                observed.push('cleanup_guardian_host_timeout');
+            if (!detail) {
+                if (!hostTimeout)
+                    observed.push('cleanup_guardian_protocol_failed');
+                return observed;
+            }
+            const word = (value, allowed) => allowed.find(item => item === value);
+            const trigger = word(detail.trigger, ['terminate', 'root_exit', 'lost', 'output_error', 'spawn_error']);
+            const term = word(detail.term, ['sent', 'eperm', 'esrch', 'not_needed']), kill = word(detail.kill, ['sent', 'eperm', 'esrch', 'not_needed']);
+            if (trigger)
+                observed.push(`cleanup_guardian_trigger_${trigger}`);
+            if (term)
+                observed.push(`cleanup_guardian_term_${term}`);
+            if (kill)
+                observed.push(`cleanup_guardian_kill_${kill}`);
+            if (typeof detail.alive === 'boolean')
+                observed.push(detail.alive ? 'cleanup_guardian_group_alive' : 'cleanup_guardian_group_gone');
+            if (typeof detail.closed === 'boolean')
+                observed.push(detail.closed ? 'cleanup_guardian_pipes_closed' : 'cleanup_guardian_pipes_open');
+            if (typeof detail.root === 'boolean')
+                observed.push(detail.root ? 'cleanup_guardian_root_exited' : 'cleanup_guardian_root_running');
+            return observed;
+        },
     };
 }

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

@@ -13,6 +13,19 @@ 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',
+    // The owned guardian's own account of an unconfirmed cleanup (fixed words, no PIDs or paths).
+    'cleanup_guardian_terminate_written', 'cleanup_guardian_terminate_not_written', 'cleanup_guardian_host_timeout', 'cleanup_guardian_protocol_failed',
+    'cleanup_guardian_trigger_terminate', 'cleanup_guardian_trigger_root_exit', 'cleanup_guardian_trigger_lost', 'cleanup_guardian_trigger_output_error', 'cleanup_guardian_trigger_spawn_error',
+    'cleanup_guardian_term_sent', 'cleanup_guardian_term_eperm', 'cleanup_guardian_term_esrch', 'cleanup_guardian_term_not_needed',
+    'cleanup_guardian_kill_sent', 'cleanup_guardian_kill_eperm', 'cleanup_guardian_kill_esrch', 'cleanup_guardian_kill_not_needed',
+    'cleanup_guardian_group_alive', 'cleanup_guardian_group_gone', 'cleanup_guardian_pipes_closed', 'cleanup_guardian_pipes_open',
+    'cleanup_guardian_root_exited', 'cleanup_guardian_root_running',
 ]);
 const issued = new WeakMap();
 export function executionFailure(error, stage, fallback = 'EXECUTION_FAILED') {
@@ -42,6 +55,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.38",
+  "version": "0.1.40",
   "private": false,
   "license": "UNLICENSED",
   "bin": {