@amaster.ai/employee-runtime-connector 0.1.0-beta.22 → 0.1.0-beta.24

package/README.md

@@ -38,7 +38,7 @@ The daemon reports its connector contract, exact package/build, platform/archite
 
 `AMASTER_RUNTIME_ATTESTATION_MODE` defaults to `shadow`. Set it to `enforce` only after the expected version and build marker are configured and shadow diagnostics are clean; enforce mode refuses to create or lease Runtime V2 mutation commands without a current exact attestation. `AMASTER_RUNTIME_ATTESTATION_TTL_SECONDS` defaults to `300` and accepts `60`–`3600`. Invalid mode or TTL values fail server startup visibly.
 
-Threat model: these facts are self-reported by a connector authenticated with its existing connector credential. There is no hardware-backed signature, remote attestation, or independent trust root. The proof detects accidental version/schema/executor drift by an honest connector and correlates commands to the observed facts; it does not prove that a compromised or malicious connector is running the claimed code. Keep the default `shadow` mode observational. Do not treat this mechanism as a production security boundary or enable `enforce` until credential-epoch identity, transactional create/lease revalidation, batch-local rejection, and recovery from honest drift have passed review.
+Threat model: these facts are self-reported by a connector authenticated with its existing connector credential. There is no hardware-backed signature, remote attestation, or independent trust root. The proof detects accidental version/schema/executor drift by an honest connector and correlates commands to the observed facts; it does not prove that a compromised or malicious connector is running the claimed code. Proof identity is stable for the exact connector credential and fact set, create/lease revalidate it under the connector transaction lock, stale commands are isolated within a poll batch, and an active connector can recover after restoring exact facts. Keep the default `shadow` mode observational, and do not treat this mechanism as a standalone production security boundary or enable `enforce` before expected markers are configured and shadow diagnostics are clean.
 
 The AMaster remote stack derives its runtime image from the Pi base image with
 `docker/Dockerfile.amaster-employee-pi-cli-runtime`. The build installs one exact

package/dist/amaster-runtime-daemon.mjs

@@ -2144,6 +2144,27 @@ function selectExecutor(config, command) {
 function processGroupIdForChild(child, processPlatform = process.platform) {
   return processPlatform === "win32" || typeof child.pid !== "number" || child.pid <= 0 ? null : child.pid;
 }
+function isExecutorProcessAlive(child, processGroupId = processGroupIdForChild(child), processApi = process) {
+  if (processGroupId !== null) {
+    try {
+      processApi.kill(-processGroupId, 0);
+      return true;
+    } catch (error) {
+      if (error?.code === "ESRCH") return false;
+      return true;
+    }
+  }
+  return child.exitCode === null && child.signalCode === null;
+}
+function isProcessIdAlive(pid, processApi = process) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    processApi.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code !== "ESRCH";
+  }
+}
 function signalExecutorProcess(child, signal, processGroupId = processGroupIdForChild(child), processApi = process) {
   if (processGroupId !== null) {
     try {
@@ -2156,7 +2177,7 @@ function signalExecutorProcess(child, signal, processGroupId = processGroupIdFor
       }
     }
   }
-  if (!child.killed) {
+  if (child.exitCode === null && child.signalCode === null) {
     try {
       return child.kill(signal);
     } catch {
@@ -3759,14 +3780,15 @@ function buildRuntimeConnectorAuthHeaders(config) {
   if (config.token) return { Authorization: `Bearer ${config.token}` };
   return {};
 }
-async function postRuntimeConnectorJson(config, path, payload) {
+async function postRuntimeConnectorJson(config, path, payload, options = {}) {
   const res = await fetch(`${config.serverUrl}${path}`, {
     method: "POST",
     headers: {
       "content-type": "application/json",
       ...buildRuntimeConnectorAuthHeaders(config)
     },
-    body: JSON.stringify(payload)
+    body: JSON.stringify(payload),
+    signal: options.signal
   });
   const text = await res.text();
   const body = text ? JSON.parse(text) : null;
@@ -3797,6 +3819,26 @@ async function postRuntimeConnectorBytes(config, path, body, headers = {}) {
   }
   return response;
 }
+function retryableRuntimeConnectorPost(error) {
+  const status = Number(error?.httpStatus);
+  return !Number.isInteger(status) || status === 408 || status === 429 || status >= 500;
+}
+async function postRuntimeConnectorJsonWithRetry(config, path, payload, options = {}) {
+  const maxAttempts = Math.max(1, Math.min(5, Number(options.maxAttempts ?? 3)));
+  const timeoutMs = Math.max(1, Number(options.timeoutMs ?? 5e3));
+  const delayMs = Math.max(0, Number(options.delayMs ?? 100));
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    try {
+      return await postRuntimeConnectorJson(config, path, payload, { signal: AbortSignal.timeout(timeoutMs) });
+    } catch (error) {
+      lastError = error;
+      if (attempt >= maxAttempts || !retryableRuntimeConnectorPost(error)) throw error;
+      if (delayMs > 0) await new Promise((resolve9) => setTimeout(resolve9, delayMs));
+    }
+  }
+  throw lastError;
+}
 async function bestEffortPostRuntimeConnectorJson(config, path, payload, options = {}) {
   try {
     return await postRuntimeConnectorJson(config, path, payload);
@@ -3812,6 +3854,7 @@ async function bestEffortPostRuntimeConnectorJson(config, path, payload, options
   }
 }
 var postJson = postRuntimeConnectorJson;
+var postJsonWithRetry = postRuntimeConnectorJsonWithRetry;
 var bestEffortPostJson = bestEffortPostRuntimeConnectorJson;
 
 // src/amaster-runtime-daemon/runtime-artifact-upload.mjs
@@ -3874,6 +3917,38 @@ function prepareRuntimeArtifactUploads(cwd, mcpToolResults) {
   return [...uploads.values()];
 }
 
+// src/amaster-runtime-daemon/runtime-artifact-ingest-queue.mjs
+function createRuntimeArtifactIngestQueue({ ingest, onError }) {
+  const handledIntentIds = /* @__PURE__ */ new Set();
+  const artifacts = [];
+  let error = null;
+  let queue = Promise.resolve();
+  return {
+    enqueue(results) {
+      if (error) return;
+      const pending = results.filter((result2) => {
+        const intentId = readString(asRecord(result2).artifactIntent?.intentId);
+        if (!intentId || handledIntentIds.has(intentId)) return false;
+        handledIntentIds.add(intentId);
+        return true;
+      });
+      if (pending.length === 0) return;
+      queue = queue.then(async () => artifacts.push(...await ingest(pending))).catch((caught) => {
+        error ??= caught;
+        onError?.(caught);
+      });
+    },
+    hasHandled(intentId) {
+      return handledIntentIds.has(intentId);
+    },
+    async flush() {
+      await queue;
+      if (error) throw error;
+      return [...artifacts];
+    }
+  };
+}
+
 // src/amaster-runtime-daemon/workspace-guard.mjs
 import { createHash as createHash4 } from "node:crypto";
 import { existsSync as existsSync5, mkdirSync as mkdirSync4, realpathSync as realpathSync2, statSync as statSync3 } from "node:fs";
@@ -3928,6 +4003,7 @@ function createWorkspaceManifest(workspace, input = {}) {
     executorKind: input.executorKind ?? null,
     executorHome: workspace.executorHome ?? null,
     commandId: input.commandId ?? null,
+    generation: input.generation ?? null,
     runId: input.runId ?? null,
     issueId: input.issueId ?? null,
     workspaceKey: workspace.workspaceKey ?? null,
@@ -4041,6 +4117,7 @@ function resolveExecutionWorkspace(config, command, opts = {}) {
   createWorkspaceManifest(workspace, {
     executorKind,
     commandId: readString(command.commandId) ?? null,
+    generation: Number.isInteger(command.generation) ? command.generation : null,
     runId,
     issueId
   });
@@ -4618,7 +4695,7 @@ function readWorkspaceStatus(cwd, opts = {}) {
 }
 
 // src/amaster-runtime-daemon.mjs
-var CONNECTOR_VERSION = "0.1.0-beta.22";
+var CONNECTOR_VERSION = "0.1.0-beta.24";
 var CONNECTOR_CONTRACT_VERSION = "2026-06-04.v1";
 var MAX_CHECKPOINT_BYTES = 20 * 1024 * 1024;
 var CHECKPOINT_TTL_MS = 24 * 60 * 60 * 1e3;
@@ -4699,6 +4776,40 @@ function resultOutboxActiveRunCommands(config) {
   }
   return entries;
 }
+function resultOutboxFailedRunCommands(config) {
+  const dir = resultOutboxInvalidDir(config);
+  if (!existsSync9(dir)) return [];
+  const entries = [];
+  for (const file of readdirSync6(dir).filter((name) => name.endsWith(".json")).sort().slice(-100)) {
+    let entry;
+    try {
+      entry = asRecord(JSON.parse(readFileSync7(join10(dir, file), "utf8")));
+    } catch {
+      continue;
+    }
+    const failureReason = readString(entry.invalidReason);
+    if (!failureReason || !["server_rejected_terminal", "retry_exhausted"].includes(failureReason)) continue;
+    const activeRun = asRecord(entry.activeRun);
+    const commandId = readString(activeRun.commandId) ?? readString(entry.commandId);
+    if (!commandId) continue;
+    entries.push({
+      commandId,
+      ...readString(activeRun.runId) ? { runId: readString(activeRun.runId) } : {},
+      ...readString(activeRun.issueId) ? { issueId: readString(activeRun.issueId) } : {},
+      ...readString(activeRun.executorKind) ? { executorKind: readString(activeRun.executorKind) } : {},
+      ...readString(activeRun.workspacePath) ? { workspacePath: readString(activeRun.workspacePath) } : {},
+      ...readString(activeRun.startedAt) ? { startedAt: readString(activeRun.startedAt) } : {},
+      ...readString(activeRun.executorCompletedAt) ? { executorCompletedAt: readString(activeRun.executorCompletedAt) } : {},
+      phase: "result_outbox_failed",
+      outboxPending: 0,
+      evidenceDeliveryStatus: "failed",
+      evidenceFailureReason: failureReason,
+      ...typeof entry.httpStatus === "number" ? { evidenceHttpStatus: entry.httpStatus } : {},
+      ...readString(entry.invalidAt) ? { evidenceFailedAt: readString(entry.invalidAt) } : {}
+    });
+  }
+  return entries;
+}
 function clearDeliveredResultOutboxCommand(config, entry) {
   const commandId = readString(entry?.commandId);
   if (commandId) pendingResultOutboxRunCommands.delete(commandId);
@@ -5001,8 +5112,10 @@ function buildHeartbeatPayload(config, options = {}) {
   const orphanReaperSummary = asRecord(options.orphanReaper ?? lastOrphanReaperSummary);
   const activeRunCommandById = /* @__PURE__ */ new Map();
   for (const entry of [
+    ...Array.from(localDispatchCommandIds, (commandId) => ({ commandId, phase: "preparing" })),
     ...Array.from(activeRunCommands.values()),
     ...Array.from(pendingResultOutboxRunCommands.values()),
+    ...resultOutboxFailedRunCommands(config),
     ...resultOutboxActiveRunCommands(config)
   ]) {
     const commandId = readString(entry.commandId);
@@ -5993,7 +6106,7 @@ function buildExecutorInvocation(executor, command = {}, workspace = null) {
   }
   return { command: executor.command, args: [], stdin: "prompt" };
 }
-async function executeModelCallCommand(config, command) {
+async function executeModelCallCommand(config, command, signal) {
   const executor = selectExecutor(config, command);
   const payload = asRecord(command.payload);
   const prompt = readString(payload.prompt) ?? "";
@@ -6009,6 +6122,7 @@ async function executeModelCallCommand(config, command) {
     config.executorMaxOutputBytes,
     readNumber(payload.maxOutputBytes, 512 * 1024)
   ));
+  await ackCommand(config, command, "spawned");
   await ingestLog(config, command, "system", "info", `Starting ${executor.kind} runtime model call`, {
     executorKind: executor.kind,
     args: invocation.args,
@@ -6021,7 +6135,8 @@ async function executeModelCallCommand(config, command) {
     stdin: invocation.stdin === "prompt" ? prompt : "",
     timeoutSeconds,
     maxOutputBytes,
-    executorKind: executor.kind
+    executorKind: executor.kind,
+    signal
   });
   if (execution.stdout) {
     await ingestLog(config, command, "stdout", "info", truncateText(execution.stdout, 4e3));
@@ -6059,6 +6174,17 @@ async function executeModelCallCommand(config, command) {
     } : {}
   }, error ?? void 0);
 }
+async function executeTrackedModelCallCommand(config, command) {
+  const abortController = new AbortController();
+  const forgetActiveModelCall = rememberActiveRunCommand(command, {});
+  const stopActiveModelCallHeartbeats = startActiveRunHeartbeats(config, command, abortController);
+  try {
+    return await executeModelCallCommand(config, command, abortController.signal);
+  } finally {
+    stopActiveModelCallHeartbeats();
+    forgetActiveModelCall();
+  }
+}
 function redactProtectedText(value, protectedValues = []) {
   let text = String(value ?? "");
   for (const protectedValue of protectedValues) {
@@ -6066,7 +6192,7 @@ function redactProtectedText(value, protectedValues = []) {
   }
   return text;
 }
-function createLiveOutputLogger(config, command, executorKind, protectedValues = []) {
+function createLiveOutputLogger(config, command, executorKind, protectedValues = [], onMcpToolResults = null) {
   const buffers = { stdout: "", stderr: "" };
   const displayCounts = { stdout: 0, stderr: 0, system: 0 };
   const sourceCounts = { stdout: 0, stderr: 0 };
@@ -6164,7 +6290,11 @@ function createLiveOutputLogger(config, command, executorKind, protectedValues =
     if (executorKind === "pi" && readString(asRecord(event).type) === "session") {
       executorSessionId = readString(asRecord(event).sessionId ?? asRecord(event).id) ?? executorSessionId;
     }
-    if (executorKind === "pi" && event) liveMcpToolResults.push(...piMcpToolResults(event));
+    if (executorKind === "pi" && event) {
+      const results = piMcpToolResults(event);
+      liveMcpToolResults.push(...results);
+      if (results.length > 0) onMcpToolResults?.(results);
+    }
     let entry = null;
     if (event && shouldPreserveExecutorJsonlForTranscript(executorKind, event)) {
       entry = {
@@ -6305,6 +6435,7 @@ function realOrResolvedPath(value) {
     return resolve8(value);
   }
 }
+var LSOF_COMMAND = process.platform === "darwin" && existsSync9("/usr/sbin/lsof") ? "/usr/sbin/lsof" : "lsof";
 function processCwdForPid(pid) {
   if (process.platform === "linux") {
     try {
@@ -6314,7 +6445,7 @@ function processCwdForPid(pid) {
     }
   }
   if (process.platform === "darwin") {
-    const result2 = spawnSync5("lsof", ["-a", "-p", String(pid), "-d", "cwd", "-Fn"], {
+    const result2 = spawnSync5(LSOF_COMMAND, ["-a", "-p", String(pid), "-d", "cwd", "-Fn"], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     });
@@ -6344,7 +6475,7 @@ function allProcessCwdsByPid() {
     return cwds;
   }
   if (process.platform === "darwin") {
-    const result2 = spawnSync5("lsof", ["-nP", "-d", "cwd", "-Fp", "-Fn"], {
+    const result2 = spawnSync5(LSOF_COMMAND, ["-nP", "-d", "cwd", "-Fp", "-Fn"], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
     });
@@ -6514,8 +6645,8 @@ function runOrphanReaper(config, options = {}) {
     return finishSummary();
   }
   const refs = activeRuntimeExecutionRefs();
-  const processRows = allProcessRows();
-  const processCwdsByPid = allProcessCwdsByPid();
+  let processRows = null;
+  let processCwdsByPid = null;
   for (const workdir of walkManagedWorkdirs(config.runtimeWorkspacesRoot)) {
     const manifest = readWorkspaceManifest(workspaceManifestPath(workdir));
     if (!manifest || manifest.managed !== true) continue;
@@ -6524,6 +6655,8 @@ function runOrphanReaper(config, options = {}) {
       summary.protectedWorkdirCount += 1;
       continue;
     }
+    processRows ??= allProcessRows();
+    processCwdsByPid ??= allProcessCwdsByPid();
     const residents = listWorkspaceResidentProcesses(workdir, null, { processRows, processCwdsByPid });
     if (residents.length === 0) continue;
     summary.orphanWorkdirCount += 1;
@@ -6562,8 +6695,19 @@ function runExecutor(command, args, options) {
     let timer = null;
     let rssTimer = null;
     let stopKillTimer = null;
-    let stoppedExitDrainTimer = null;
+    let quiescenceTimer = null;
+    let stoppedResidentTimer = null;
     let completionOutputDrainTimer = null;
+    let stopReason = null;
+    let childExited = false;
+    let childClosed = false;
+    let closeCode = null;
+    let closeSignal = null;
+    let spawnError = null;
+    let outputDrainForcedClosed = false;
+    let killedWorkspaceResidents = [];
+    let stoppedResidentDrainUntil = 0;
+    const residentSignalledAt = /* @__PURE__ */ new Map();
     let piCompletionOutputLineBuffer = "";
     const outputBytes = { stdout: 0, stderr: 0 };
     const maxOutputBytes = parsePositiveInteger(options.maxOutputBytes, 50 * 1024 * 1024);
@@ -6582,11 +6726,10 @@ function runExecutor(command, args, options) {
       if (timer) clearTimeout(timer);
       if (rssTimer) clearInterval(rssTimer);
       if (stopKillTimer) clearTimeout(stopKillTimer);
-      if (stoppedExitDrainTimer) clearTimeout(stoppedExitDrainTimer);
+      if (quiescenceTimer) clearTimeout(quiescenceTimer);
+      if (stoppedResidentTimer) clearTimeout(stoppedResidentTimer);
       if (completionOutputDrainTimer) clearTimeout(completionOutputDrainTimer);
       options.signal?.removeEventListener?.("abort", abort);
-      const shouldCleanupWorkspaceResidents = Boolean(aborted || outputFlood || memoryLimit || result2.timedOut || completionOutputType);
-      const killedWorkspaceResidents = shouldCleanupWorkspaceResidents ? killWorkspaceResidentProcesses(options.cwd, processGroupId) : [];
       resolveRun({
         stdout,
         stderr,
@@ -6595,25 +6738,77 @@ function runExecutor(command, args, options) {
         memoryLimit,
         completionOutputType,
         killedWorkspaceResidents,
+        ...outputDrainForcedClosed ? { outputDrainForcedClosed: true } : {},
         ...result2
       });
     };
     const scheduleStopKill = () => {
-      if (stopKillTimer) clearTimeout(stopKillTimer);
+      if (stopKillTimer) return;
       stopKillTimer = setTimeout(() => signalExecutorProcess(child, "SIGKILL", processGroupId), 2e3);
-      stopKillTimer.unref?.();
     };
-    const destroyExecutorOutputPipes = () => {
-      child.stdout.destroy();
-      child.stderr.destroy();
+    const requestStop = (reason) => {
+      if (settled || stopReason) return;
+      stopReason = reason;
+      signalExecutorProcess(child, "SIGTERM", processGroupId);
+      scheduleStopKill();
     };
-    const finishStoppedExecutorAfterExit = (code, signal) => {
-      if (settled || !aborted && !outputFlood && !memoryLimit && !(completionOutputType && signal === "SIGTERM") || stoppedExitDrainTimer) return;
-      stoppedExitDrainTimer = setTimeout(() => {
-        destroyExecutorOutputPipes();
-        finish({ exitCode: code, signal, timedOut: false, spawnError: null, cancelled: aborted });
-      }, 100);
-      stoppedExitDrainTimer.unref?.();
+    const reapStoppedWorkspaceResidents = () => {
+      if (settled || !stopReason || stopReason === "completion_cleanup") return;
+      const residents = listWorkspaceResidentProcesses(options.cwd, processGroupId, {
+        processRows: allProcessRows(),
+        processCwdsByPid: allProcessCwdsByPid()
+      });
+      const seen = new Set(killedWorkspaceResidents.map((resident) => resident.pid));
+      const now = Date.now();
+      for (const resident of residents) {
+        if (!seen.has(resident.pid)) killedWorkspaceResidents.push(resident);
+        if (!residentSignalledAt.has(resident.pid)) {
+          residentSignalledAt.set(resident.pid, now);
+          try {
+            process.kill(resident.pid, "SIGTERM");
+          } catch {
+          }
+        }
+      }
+      for (const resident of killedWorkspaceResidents) {
+        const signalledAt = residentSignalledAt.get(resident.pid) ?? now;
+        if (now - signalledAt < 2e3 || !isProcessIdAlive(resident.pid)) continue;
+        try {
+          process.kill(resident.pid, "SIGKILL");
+        } catch {
+        }
+      }
+      if (isExecutorProcessAlive(child, processGroupId) || now < stoppedResidentDrainUntil || killedWorkspaceResidents.some((resident) => isProcessIdAlive(resident.pid))) {
+        stoppedResidentTimer = setTimeout(reapStoppedWorkspaceResidents, 100);
+      } else {
+        stoppedResidentTimer = null;
+      }
+      maybeFinishQuiescent();
+    };
+    const maybeFinishQuiescent = () => {
+      if (settled || !childExited && !childClosed) return;
+      if (isExecutorProcessAlive(child, processGroupId) || !childClosed && Date.now() < stoppedResidentDrainUntil || killedWorkspaceResidents.some((resident) => isProcessIdAlive(resident.pid))) {
+        requestStop("completion_cleanup");
+        if (!quiescenceTimer) {
+          quiescenceTimer = setTimeout(() => {
+            quiescenceTimer = null;
+            maybeFinishQuiescent();
+          }, 25);
+        }
+        return;
+      }
+      if (!childClosed) {
+        outputDrainForcedClosed = true;
+        child.stdout.destroy();
+        child.stderr.destroy();
+      }
+      finish({
+        exitCode: closeCode,
+        signal: closeSignal,
+        timedOut: stopReason === "timeout",
+        spawnError,
+        cancelled: aborted
+      });
     };
     const maybeSchedulePiCompletionDrain = (text) => {
       if (settled || outputFlood || options.executorKind !== "pi" || completionOutputType) return;
@@ -6638,8 +6833,7 @@ function runExecutor(command, args, options) {
             completionOutputType = stopType;
             completionOutputDrainTimer = setTimeout(() => {
               if (settled) return;
-              signalExecutorProcess(child, "SIGTERM", processGroupId);
-              scheduleStopKill();
+              requestStop("completion_output");
             }, PI_COMPLETION_OUTPUT_GRACE_MS);
             completionOutputDrainTimer.unref?.();
             return;
@@ -6655,8 +6849,7 @@ function runExecutor(command, args, options) {
         bytes: outputBytes[stream],
         limitBytes: maxOutputBytes
       };
-      signalExecutorProcess(child, "SIGTERM", processGroupId);
-      scheduleStopKill();
+      requestStop("output_flood");
     };
     const killForMemoryLimit = (rssBytes) => {
       if (settled || memoryLimit) return;
@@ -6664,23 +6857,17 @@ function runExecutor(command, args, options) {
         rssBytes,
         limitBytes: maxRssBytes
       };
-      signalExecutorProcess(child, "SIGTERM", processGroupId);
-      scheduleStopKill();
+      requestStop("memory_limit");
     };
     const abort = () => {
       if (settled) return;
       aborted = true;
-      signalExecutorProcess(child, "SIGTERM", processGroupId);
-      scheduleStopKill();
+      requestStop("cancel");
     };
     options.signal?.addEventListener?.("abort", abort, { once: true });
     if (options.signal?.aborted) abort();
     timer = setTimeout(() => {
-      signalExecutorProcess(child, "SIGTERM", processGroupId);
-      const timeoutKillTimer = setTimeout(() => signalExecutorProcess(child, "SIGKILL", processGroupId), 2e3);
-      timeoutKillTimer.unref?.();
-      destroyExecutorOutputPipes();
-      finish({ exitCode: null, signal: "SIGTERM", timedOut: true, spawnError: null });
+      requestStop("timeout");
     }, options.timeoutSeconds * 1e3);
     if (maxRssMb > 0 && processGroupId !== null) {
       rssTimer = setInterval(() => {
@@ -6707,13 +6894,27 @@ function runExecutor(command, args, options) {
       if (outputBytes.stderr > maxOutputBytes) killForOutputFlood("stderr");
     });
     child.on("error", (err) => {
-      finish({ exitCode: null, signal: null, timedOut: false, spawnError: err.message });
+      spawnError = err.message;
     });
     child.on("exit", (code, signal) => {
-      finishStoppedExecutorAfterExit(code, signal);
+      childExited = true;
+      closeCode = code;
+      closeSignal = signal;
+      stoppedResidentDrainUntil = Date.now() + 100;
+      if (!stopReason && isExecutorProcessAlive(child, processGroupId)) {
+        requestStop("completion_cleanup");
+      }
+      if (stopReason && stopReason !== "completion_cleanup") {
+        stoppedResidentDrainUntil = Date.now() + 100;
+        reapStoppedWorkspaceResidents();
+      }
+      maybeFinishQuiescent();
     });
     child.on("close", (code, signal) => {
-      finish({ exitCode: code, signal, timedOut: false, spawnError: null, cancelled: aborted });
+      childClosed = true;
+      closeCode = code;
+      closeSignal = signal;
+      maybeFinishQuiescent();
     });
     if (options.stdin) child.stdin.end(options.stdin);
     else child.stdin.end();
@@ -7516,10 +7717,12 @@ function piOutputValidationError(parsed, options = {}) {
   }
   return null;
 }
-async function ackCommand(config, command) {
+async function ackCommand(config, command, phase = "preparing") {
   const connectorId = requireConnectorId(config);
-  return await postJson(config, `/api/amaster/runtime-connectors/${connectorId}/commands/${command.commandId}/ack`, {
-    leaseId: command.leaseId
+  return await postJsonWithRetry(config, `/api/amaster/runtime-connectors/${connectorId}/commands/${command.commandId}/ack`, {
+    leaseId: command.leaseId,
+    generation: command.generation,
+    phase
   });
 }
 async function executeRunCommand(config, command) {
@@ -7608,6 +7811,7 @@ async function executeRunCommand(config, command) {
     presentationKind: "context_manifest",
     contextManifest
   });
+  await ackCommand(config, command, "spawned");
   await ingestLog(config, command, "system", "info", `Starting ${executor.kind} executor`, {
     executorKind: executor.kind,
     cwd,
@@ -7625,7 +7829,18 @@ async function executeRunCommand(config, command) {
   const abortController = new AbortController();
   const stopActiveRunHeartbeats = startActiveRunHeartbeats(config, command, abortController);
   const protectedExecutorValues = managedMcpProfile?.protectedValues ?? (managedMcpProfile ? [governedMcp.sessionToken] : []);
-  const liveOutputLogger = createLiveOutputLogger(config, command, executor.kind, protectedExecutorValues);
+  const runtimeArtifacts = [];
+  const runtimeArtifactIngest = createRuntimeArtifactIngestQueue({
+    ingest: (results) => ingestRuntimeArtifacts(config, command, cwd, results),
+    onError: () => abortController.abort()
+  });
+  const liveOutputLogger = createLiveOutputLogger(
+    config,
+    command,
+    executor.kind,
+    protectedExecutorValues,
+    (results) => runtimeArtifactIngest.enqueue(results)
+  );
   let execution;
   try {
     try {
@@ -7646,6 +7861,7 @@ async function executeRunCommand(config, command) {
     } finally {
       await liveOutputLogger.flush();
     }
+    runtimeArtifacts.push(...await runtimeArtifactIngest.flush());
     execution.stdout = redactProtectedText(execution.stdout, protectedExecutorValues);
     execution.stderr = redactProtectedText(execution.stderr, protectedExecutorValues);
     patchActiveRunCommand(command, {
@@ -7702,7 +7918,15 @@ async function executeRunCommand(config, command) {
       ...Array.isArray(parsed.mcpToolResults) ? parsed.mcpToolResults.map(asRecord) : [],
       ...liveOutputLogger.mcpToolResults().map(asRecord)
     ];
-    const runtimeArtifacts = await ingestRuntimeArtifacts(config, command, cwd, mcpToolResults);
+    runtimeArtifacts.push(...await ingestRuntimeArtifacts(
+      config,
+      command,
+      cwd,
+      mcpToolResults.filter((result3) => {
+        const intentId = readString(asRecord(result3).artifactIntent?.intentId);
+        return !intentId || !runtimeArtifactIngest.hasHandled(intentId);
+      })
+    ));
     const shouldPreserveNativeSession = managedMcpProfile && parsed.sessionId && (execution.exitCode === 0 || execution.completionOutputType === "approval_required") && !execution.timedOut && execution.cancelled !== true && !execution.spawnError && ["codex", "pi"].includes(executor.kind) && mcpToolResults.some((result3) => readString(result3.status) === "approval_required");
     if (shouldPreserveNativeSession) {
       try {
@@ -7796,6 +8020,7 @@ async function executeRunCommand(config, command) {
       });
     }
     const result2 = {
+      evidenceContract: { version: 1 },
       executorKind: executor.kind,
       command: invocation.command,
       args: invocation.args,
@@ -7805,6 +8030,7 @@ async function executeRunCommand(config, command) {
       exitCode: execution.exitCode,
       signal: execution.signal,
       timedOut: execution.timedOut,
+      ...execution.outputDrainForcedClosed ? { outputDrainForcedClosed: true } : {},
       ...readString(execution.completionOutputType) ? { completionOutputType: readString(execution.completionOutputType) } : {},
       ...cancelled ? { cancelledByControlPlane: true } : {},
       ...invocation.nativeSession ? { nativeSession: invocation.nativeSession } : {},
@@ -7900,7 +8126,7 @@ async function processCommand(config, command) {
       return;
     }
     if (command.commandType === "model_call") {
-      await executeModelCallCommand(config, command);
+      await executeTrackedModelCallCommand(config, command);
       return;
     }
     await completeCommand(config, command, "succeeded", {

package/dist/amaster-runtime.mjs

@@ -5,7 +5,7 @@ import { dirname, join, resolve } from "node:path";
 import { homedir, hostname } from "node:os";
 import { fileURLToPath } from "node:url";
 
-const CONNECTOR_VERSION = "0.1.0-beta.22";
+const CONNECTOR_VERSION = "0.1.0-beta.24";
 
 const CAPABILITIES = [
   "remote_registration",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amaster.ai/employee-runtime-connector",
-  "version": "0.1.0-beta.22",
+  "version": "0.1.0-beta.24",
   "description": "AMaster Employee runtime connector CLI and daemon",
   "license": "MIT",
   "type": "module",