@amaster.ai/employee-runtime-connector 0.1.0-beta.49 → 0.1.0-beta.50

package/dist/amaster-runtime-daemon.mjs

@@ -3,9 +3,9 @@
 
 // src/amaster-runtime-daemon.mjs
 import { createHash as createHash12 } from "node:crypto";
-import { chmodSync as chmodSync6, copyFileSync as copyFileSync3, existsSync as existsSync13, lstatSync as lstatSync7, mkdirSync as mkdirSync8, readFileSync as readFileSync10, readdirSync as readdirSync8, realpathSync as realpathSync4, renameSync as renameSync5, rmSync as rmSync7, statSync as statSync7, symlinkSync as symlinkSync4, unlinkSync, writeFileSync as writeFileSync8 } from "node:fs";
+import { chmodSync as chmodSync6, copyFileSync as copyFileSync3, existsSync as existsSync14, lstatSync as lstatSync7, mkdirSync as mkdirSync9, readFileSync as readFileSync11, readdirSync as readdirSync9, realpathSync as realpathSync5, renameSync as renameSync6, rmSync as rmSync7, statSync as statSync7, symlinkSync as symlinkSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync9 } from "node:fs";
 import { arch as arch3, homedir as homedir3, hostname as hostname2, platform as platform3 } from "node:os";
-import { basename as basename6, delimiter as delimiter2, dirname as dirname9, extname as extname2, isAbsolute as isAbsolute8, join as join14, relative as relative9, resolve as resolve12 } from "node:path";
+import { basename as basename6, delimiter as delimiter2, dirname as dirname9, extname as extname2, isAbsolute as isAbsolute8, join as join15, relative as relative9, resolve as resolve12 } from "node:path";
 import { spawn, spawnSync as spawnSync6 } from "node:child_process";
 import { createRequire } from "node:module";
 
@@ -59,7 +59,7 @@ function quoteShell(value) {
 
 // src/amaster-runtime-daemon/codex-managed-mcp-profile.mjs
 import { createHash } from "node:crypto";
-import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { arch, platform } from "node:os";
 import { basename, dirname, isAbsolute, join as join2, relative, resolve } from "node:path";
 import { spawnSync } from "node:child_process";
@@ -1489,6 +1489,7 @@ function cleanupManagedCodexMcpProfile(profile, owner) {
 function reconcileManagedCodexMcpProfiles(rootPath, options = {}) {
   const root = resolve(rootPath);
   if (!existsSync(root)) return { scanned: 0, removed: 0, removedProfiles: 0, removedRollouts: 0, failed: 0, failures: [] };
+  const canonicalRoot = realpathSync(root);
   const profileMarkers = [];
   const rolloutMarkers = [];
   const pending = [root];
@@ -1504,16 +1505,23 @@ function reconcileManagedCodexMcpProfiles(rootPath, options = {}) {
     }
   }
   let removedProfiles = 0;
+  let preservedProfiles = 0;
   let removedRollouts = 0;
   const failures = [];
+  const protectedCommandIds = new Set(Array.isArray(options.protectedCommandIds) ? options.protectedCommandIds.filter((value) => typeof value === "string" && value) : []);
   for (const markerPath of profileMarkers) {
     const profileRoot = dirname(markerPath);
     try {
       const marker = JSON.parse(readFileSync(markerPath, "utf8"));
-      if (!within(profileRoot, root) || marker?.profileRoot !== profileRoot) {
+      const markerProfileRoot = typeof marker?.profileRoot === "string" ? resolve(marker.profileRoot) : null;
+      if (!markerProfileRoot || !existsSync(markerProfileRoot) || !within(realpathSync(profileRoot), canonicalRoot) || realpathSync(markerProfileRoot) !== realpathSync(profileRoot)) {
         throw new Error("ownership marker root mismatch");
       }
-      cleanupManagedCodexMcpProfile({ profileRoot }, { commandId: marker.commandId, runId: marker.runId });
+      if (protectedCommandIds.has(marker?.commandId)) {
+        preservedProfiles += 1;
+        continue;
+      }
+      cleanupManagedCodexMcpProfile({ profileRoot: markerProfileRoot }, { commandId: marker.commandId, runId: marker.runId });
       removedProfiles += 1;
     } catch (error) {
       failures.push({ profileRoot, error: error instanceof Error ? error.message : String(error) });
@@ -1527,7 +1535,8 @@ function reconcileManagedCodexMcpProfiles(rootPath, options = {}) {
       const markerStat = lstatSync(markerPath);
       const cacheStat = lstatSync(cacheRoot);
       const marker = JSON.parse(readFileSync(markerPath, "utf8"));
-      if (!within(cacheRoot, root) || basename(cacheRoot) !== "session-rollout" || markerStat.isSymbolicLink() || !markerStat.isFile() || cacheStat.isSymbolicLink() || !cacheStat.isDirectory() || marker?.version !== 1 || typeof marker?.companyId !== "string" || typeof marker?.agentId !== "string" || typeof marker?.sourceRunId !== "string" || typeof marker?.sourceCommandId !== "string" || typeof marker?.sessionId !== "string" || marker?.cacheRoot != null && marker.cacheRoot !== cacheRoot) {
+      const markerCacheRoot = typeof marker?.cacheRoot === "string" ? resolve(marker.cacheRoot) : null;
+      if (!within(realpathSync(cacheRoot), canonicalRoot) || basename(cacheRoot) !== "session-rollout" || markerStat.isSymbolicLink() || !markerStat.isFile() || cacheStat.isSymbolicLink() || !cacheStat.isDirectory() || marker?.version !== 1 || typeof marker?.companyId !== "string" || typeof marker?.agentId !== "string" || typeof marker?.sourceRunId !== "string" || typeof marker?.sourceCommandId !== "string" || typeof marker?.sessionId !== "string" || markerCacheRoot != null && (!existsSync(markerCacheRoot) || realpathSync(markerCacheRoot) !== realpathSync(cacheRoot))) {
         throw new Error("session rollout ownership marker mismatch");
       }
       const preservedAtMs = typeof marker.preservedAt === "string" ? Date.parse(marker.preservedAt) : Number.NaN;
@@ -1544,6 +1553,7 @@ function reconcileManagedCodexMcpProfiles(rootPath, options = {}) {
     scanned: profileMarkers.length + rolloutMarkers.length,
     removed: removedProfiles + removedRollouts,
     removedProfiles,
+    preservedProfiles,
     removedRollouts,
     failed: failures.length,
     failures
@@ -1559,7 +1569,7 @@ import {
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync3,
   readFileSync as readFileSync3,
-  realpathSync,
+  realpathSync as realpathSync2,
   readdirSync as readdirSync2,
   rmSync as rmSync2,
   statSync as statSync2,
@@ -1886,7 +1896,7 @@ function createManagedPiMcpProfileApi(options = {}) {
   const PI_ATTESTATION_MAX_ATTEMPTS = 2;
   const PI_ATTESTATION_RECENT_LIVE_TTL_MS = Number.isFinite(options.recentLiveTtlMs) && options.recentLiveTtlMs > 0 ? options.recentLiveTtlMs : 30 * 60 * 1e3;
   const recentLivePiVersionProbes = /* @__PURE__ */ new Map();
-  function record4(value) {
+  function record5(value) {
     return value && typeof value === "object" && !Array.isArray(value) ? value : {};
   }
   function npmPackageName(source) {
@@ -1942,7 +1952,7 @@ function createManagedPiMcpProfileApi(options = {}) {
     return matches[0];
   }
   function restoreManagedPiSessionRollout(input, sessionsRoot, runDir, executorHome, authority) {
-    const session = record4(input.nativeSession);
+    const session = record5(input.nativeSession);
     if (session.mode !== "governed_action_approval" || session.required !== true) return null;
     const sessionId = nonEmpty2(session.sessionId, "nativeSession.sessionId");
     const sourceRunId = nonEmpty2(session.sourceRunId, "nativeSession.sourceRunId");
@@ -1998,7 +2008,7 @@ function createManagedPiMcpProfileApi(options = {}) {
   }
   function piExecutableIdentity(executorCommand) {
     try {
-      const realPath = realpathSync(executorCommand);
+      const realPath = realpathSync2(executorCommand);
       const executableStat = lstatSync2(realPath);
       if (!executableStat.isFile() || executableStat.isSymbolicLink()) {
         throw Object.assign(new Error("Pi executable is not a regular file"), { code: "EUNSAFE" });
@@ -2019,8 +2029,8 @@ function createManagedPiMcpProfileApi(options = {}) {
     }
   }
   function validateAuthority2(input) {
-    const runtimeAuth = record4(input.runtimeAuth);
-    const gateway = record4(runtimeAuth.governedMcp);
+    const runtimeAuth = record5(input.runtimeAuth);
+    const gateway = record5(runtimeAuth.governedMcp);
     const runId = nonEmpty2(input.runId, "runId");
     if (runtimeAuth.runId !== runId) throw new Error("pi_managed_mcp_owner_mismatch: command runId does not match runtime authority");
     if (gateway.schemaVersion !== SUPPORTED_SCHEMA_VERSION2) throw new Error("pi_managed_mcp_invalid: unsupported schema version");
@@ -2036,7 +2046,7 @@ function createManagedPiMcpProfileApi(options = {}) {
     if (!Number.isFinite(expiresAt) || expiresAt <= Date.now() + 3e4) {
       throw new Error("pi_managed_mcp_session_expired: Gateway session must remain valid through spawn preflight");
     }
-    const headers = record4(gateway.headers);
+    const headers = record5(gateway.headers);
     for (const name of REQUIRED_AUTHORITY_HEADERS2) nonEmpty2(headers[name], `headers.${name}`);
     const allowedHeaderNames = /* @__PURE__ */ new Set([...REQUIRED_AUTHORITY_HEADERS2, ...runtimeAuth.issueId ? ["x-amaster-issue-id"] : []]);
     if (Object.keys(headers).some((name) => !allowedHeaderNames.has(name)) || Object.keys(headers).length !== allowedHeaderNames.size) {
@@ -2065,7 +2075,7 @@ function createManagedPiMcpProfileApi(options = {}) {
     return output;
   }
   function assertInvocationIsolation2(input) {
-    for (const name of Object.keys(record4(input.commandEnv))) {
+    for (const name of Object.keys(record5(input.commandEnv))) {
       if (FORBIDDEN_COMMAND_ENV2.has(name)) throw new Error(`pi_managed_mcp_env_override_blocked: ${name}`);
       if (!ALLOWED_COMMAND_ENV2.has(name)) throw new Error(`pi_managed_mcp_env_injection_blocked: ${name}`);
     }
@@ -2097,7 +2107,7 @@ function createManagedPiMcpProfileApi(options = {}) {
       const value = safeProxyValue2(baseEnv?.[name], name);
       if (value) env[name] = value;
     }
-    return { ...env, ...record4(commandEnv) };
+    return { ...env, ...record5(commandEnv) };
   }
   function projectMcpConfigHasContent(filePath) {
     if (!existsSync3(filePath)) return false;
@@ -2107,8 +2117,8 @@ function createManagedPiMcpProfileApi(options = {}) {
     } catch {
       return true;
     }
-    const config = record4(parsed);
-    return Object.keys(record4(config.mcpServers)).length > 0 || Object.keys(record4(config.servers)).length > 0 || Array.isArray(config.imports) && config.imports.length > 0;
+    const config = record5(parsed);
+    return Object.keys(record5(config.mcpServers)).length > 0 || Object.keys(record5(config.servers)).length > 0 || Array.isArray(config.imports) && config.imports.length > 0;
   }
   function assertNoProjectMcpOverride(cwd, runDir) {
     let cursor = resolve2(cwd);
@@ -2124,7 +2134,7 @@ function createManagedPiMcpProfileApi(options = {}) {
     }
   }
   function selectManagedBrowserUse(sourceSettings, npmSource) {
-    const plugin = record4(record4(sourceSettings.plugins)[MANAGED_BROWSER_USE_PLUGIN]);
+    const plugin = record5(record5(sourceSettings.plugins)[MANAGED_BROWSER_USE_PLUGIN]);
     if (plugin.enabled !== true || plugin.package !== MANAGED_BROWSER_USE_PACKAGE) return null;
     const packageSpec = Array.isArray(sourceSettings.packages) ? sourceSettings.packages.find((entry) => npmPackageName(entry) === MANAGED_BROWSER_USE_PACKAGE) : null;
     if (typeof packageSpec !== "string") return null;
@@ -2141,7 +2151,7 @@ function createManagedPiMcpProfileApi(options = {}) {
     if (packageMetadata.name !== MANAGED_BROWSER_USE_PACKAGE) {
       throw new Error(`pi_managed_mcp_attestation_failed: enabled ${MANAGED_BROWSER_USE_PACKAGE} package identity mismatch`);
     }
-    const sourceConfig = record4(sourceSettings["pi-browser-use"]);
+    const sourceConfig = record5(sourceSettings["pi-browser-use"]);
     const config = {};
     for (const key of MANAGED_BROWSER_USE_BOOLEAN_SETTINGS) {
       if (typeof sourceConfig[key] === "boolean") config[key] = sourceConfig[key];
@@ -2185,7 +2195,7 @@ function createManagedPiMcpProfileApi(options = {}) {
     }
     return {
       packageSpec,
-      config: record4(sourceSettings["pi-telemetry"])
+      config: record5(sourceSettings["pi-telemetry"])
     };
   }
   function seedPiRuntime(sourceHome, agentDir) {
@@ -2206,7 +2216,7 @@ function createManagedPiMcpProfileApi(options = {}) {
     let sourceSettings = {};
     if (existsSync3(settingsSource)) {
       try {
-        sourceSettings = record4(JSON.parse(readFileSync3(settingsSource, "utf8")));
+        sourceSettings = record5(JSON.parse(readFileSync3(settingsSource, "utf8")));
       } catch {
         throw new Error("pi_managed_mcp_attestation_failed: source Pi settings are invalid");
       }
@@ -2337,7 +2347,7 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
       const owner = Object.freeze({ commandId: input.commandId, runId });
       writePrivateFile2(markerPath, `${JSON.stringify({ version: 1, ...owner, profileRoot })}
 `);
-      const runtimeAuth = record4(input.runtimeAuth);
+      const runtimeAuth = record5(input.runtimeAuth);
       const authority = Object.freeze({
         companyId: nonEmpty2(runtimeAuth.companyId, "runtimeAuth.companyId"),
         agentId: nonEmpty2(runtimeAuth.agentId, "runtimeAuth.agentId"),
@@ -2472,6 +2482,7 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
   function reconcileManagedPiMcpProfiles2(rootPath, options2 = {}) {
     const root = resolve2(rootPath);
     if (!existsSync3(root)) return { scanned: 0, removed: 0, removedProfiles: 0, removedRollouts: 0, failed: 0, failures: [] };
+    const canonicalRoot = realpathSync2(root);
     const profileMarkers = [];
     const rolloutMarkers = [];
     const pending = [root];
@@ -2487,14 +2498,21 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
       }
     }
     let removedProfiles = 0;
+    let preservedProfiles = 0;
     let removedRollouts = 0;
     const failures = [];
+    const protectedCommandIds = new Set(Array.isArray(options2.protectedCommandIds) ? options2.protectedCommandIds.filter((value) => typeof value === "string" && value) : []);
     for (const markerPath of profileMarkers) {
       const profileRoot = dirname3(markerPath);
       try {
         const marker = JSON.parse(readFileSync3(markerPath, "utf8"));
-        if (!within4(profileRoot, root) || marker?.profileRoot !== profileRoot) throw new Error("ownership marker root mismatch");
-        cleanupManagedPiMcpProfile2({ profileRoot }, { commandId: marker.commandId, runId: marker.runId });
+        const markerProfileRoot = typeof marker?.profileRoot === "string" ? resolve2(marker.profileRoot) : null;
+        if (!markerProfileRoot || !existsSync3(markerProfileRoot) || !within4(realpathSync2(profileRoot), canonicalRoot) || realpathSync2(markerProfileRoot) !== realpathSync2(profileRoot)) throw new Error("ownership marker root mismatch");
+        if (protectedCommandIds.has(marker?.commandId)) {
+          preservedProfiles += 1;
+          continue;
+        }
+        cleanupManagedPiMcpProfile2({ profileRoot: markerProfileRoot }, { commandId: marker.commandId, runId: marker.runId });
         removedProfiles += 1;
       } catch (error) {
         failures.push({ profileRoot, error: error instanceof Error ? error.message : String(error) });
@@ -2508,7 +2526,8 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         const markerStat = lstatSync2(markerPath);
         const cacheStat = lstatSync2(cacheRoot);
         const marker = JSON.parse(readFileSync3(markerPath, "utf8"));
-        if (!within4(cacheRoot, root) || basename2(cacheRoot) !== "session-rollout" || markerStat.isSymbolicLink() || !markerStat.isFile() || cacheStat.isSymbolicLink() || !cacheStat.isDirectory() || marker?.version !== 1 || typeof marker?.companyId !== "string" || typeof marker?.agentId !== "string" || typeof marker?.sourceRunId !== "string" || typeof marker?.sourceCommandId !== "string" || typeof marker?.sessionId !== "string" || marker?.cacheRoot !== cacheRoot) throw new Error("session rollout ownership marker mismatch");
+        const markerCacheRoot = typeof marker?.cacheRoot === "string" ? resolve2(marker.cacheRoot) : null;
+        if (!within4(realpathSync2(cacheRoot), canonicalRoot) || basename2(cacheRoot) !== "session-rollout" || markerStat.isSymbolicLink() || !markerStat.isFile() || cacheStat.isSymbolicLink() || !cacheStat.isDirectory() || marker?.version !== 1 || typeof marker?.companyId !== "string" || typeof marker?.agentId !== "string" || typeof marker?.sourceRunId !== "string" || typeof marker?.sourceCommandId !== "string" || typeof marker?.sessionId !== "string" || !markerCacheRoot || !existsSync3(markerCacheRoot) || realpathSync2(markerCacheRoot) !== realpathSync2(cacheRoot)) throw new Error("session rollout ownership marker mismatch");
         const preservedAtMs = typeof marker.preservedAt === "string" ? Date.parse(marker.preservedAt) : Number.NaN;
         const markerAgeMs = nowMs - (Number.isFinite(preservedAtMs) ? preservedAtMs : markerStat.mtimeMs);
         if (markerAgeMs < rolloutTtlMs) continue;
@@ -2523,6 +2542,7 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
       scanned: profileMarkers.length + rolloutMarkers.length,
       removed: removedProfiles + removedRollouts,
       removedProfiles,
+      preservedProfiles,
       removedRollouts,
       failed: failures.length,
       failures
@@ -2631,8 +2651,8 @@ function resultOutboxFileName(commandId, now = Date.now()) {
   return `${now}-${safeCommandId}.json`;
 }
 function isValidResultOutboxEntry(entry) {
-  const record4 = asRecord(entry);
-  return record4.version === 1 && Boolean(readString(record4.path)) && Object.keys(asRecord(record4.payload)).length > 0;
+  const record5 = asRecord(entry);
+  return record5.version === 1 && Boolean(readString(record5.path)) && Object.keys(asRecord(record5.payload)).length > 0;
 }
 function resultOutboxEntryAgeMs(entry, nowMs) {
   const createdAt = Date.parse(readString(entry.createdAt) ?? "");
@@ -2642,6 +2662,247 @@ function isTerminalResultOutboxStatus(status) {
   return typeof status === "number" && status >= 400 && status < 500;
 }
 
+// src/amaster-runtime-daemon/run-completion-state.mjs
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync4, readdirSync as readdirSync3, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join5 } from "node:path";
+var RUN_COMPLETION_STATE_VERSION = 1;
+var RUN_COMPLETION_USAGE_SCHEMA_VERSION = "runtime-command-usage-v1";
+var RUN_COMPLETION_PHASES = /* @__PURE__ */ new Set([
+  "executing",
+  "usage_snapshot_persisted",
+  "completion_check_pending",
+  "check_failed_retry",
+  "completion_check_outbox",
+  "disposition_required",
+  "closure_executing",
+  "ready_to_terminalize",
+  "cost_ingest_pending",
+  "profile_cleanup",
+  "result_post_pending",
+  "terminal"
+]);
+var PHASE_TRANSITIONS = /* @__PURE__ */ new Map([
+  ["executing:turn_recorded", "usage_snapshot_persisted"],
+  ["closure_executing:turn_recorded", "usage_snapshot_persisted"],
+  ["closure_executing:completion_ready", "ready_to_terminalize"],
+  ["closure_executing:completion_disposition_required", "disposition_required"],
+  ["closure_executing:completion_check_failed", "check_failed_retry"],
+  ["closure_executing:completion_authority_rejected", "ready_to_terminalize"],
+  ["usage_snapshot_persisted:completion_check_requested", "completion_check_pending"],
+  ["completion_check_pending:completion_ready", "ready_to_terminalize"],
+  ["completion_check_pending:completion_disposition_required", "disposition_required"],
+  ["completion_check_pending:completion_check_failed", "check_failed_retry"],
+  ["completion_check_pending:completion_authority_rejected", "ready_to_terminalize"],
+  ["check_failed_retry:completion_retry_scheduled", "completion_check_pending"],
+  ["check_failed_retry:completion_retry_exhausted", "completion_check_outbox"],
+  ["check_failed_retry:completion_retry_abandoned", "ready_to_terminalize"],
+  ["completion_check_outbox:completion_retry_scheduled", "completion_check_pending"],
+  ["disposition_required:closure_started", "closure_executing"],
+  ["disposition_required:closure_exhausted", "ready_to_terminalize"],
+  ["ready_to_terminalize:cost_ingest_started", "cost_ingest_pending"],
+  ["cost_ingest_pending:cost_ingest_delivered", "profile_cleanup"],
+  ["cost_ingest_pending:cost_ingest_abandoned", "profile_cleanup"],
+  ["profile_cleanup:profile_cleaned", "result_post_pending"],
+  ["profile_cleanup:profile_cleanup_abandoned", "result_post_pending"],
+  ["result_post_pending:result_post_delivered", "terminal"]
+]);
+function record3(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function nonEmptyString(value, label) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`run_completion_state_invalid:${label}`);
+  }
+  return value.trim();
+}
+function nonNegativeInteger(value) {
+  const numeric = Number(value ?? 0);
+  return Number.isInteger(numeric) && numeric >= 0 ? numeric : 0;
+}
+function nonNegativeNumber(value) {
+  const numeric = Number(value ?? 0);
+  return Number.isFinite(numeric) && numeric >= 0 ? numeric : 0;
+}
+function runtimeCommandCostIdempotencyKey(commandId) {
+  return `runtime-command-cost:${nonEmptyString(commandId, "commandId")}`;
+}
+function runCompletionStateFileName(commandId) {
+  const safeCommandId = nonEmptyString(commandId, "commandId").replace(/[^a-zA-Z0-9._-]/g, "_");
+  return `${safeCommandId}.json`;
+}
+function normalizeRunTurnUsage(turn) {
+  const source = record3(turn);
+  const nestedUsage = record3(source.usage);
+  const usage = Object.keys(nestedUsage).length > 0 ? nestedUsage : source;
+  return {
+    turn: source.turn === "closure" ? "closure" : "primary",
+    attempt: source.turn === "closure" ? 1 : 0,
+    inputTokens: nonNegativeInteger(usage.inputTokens),
+    cachedInputTokens: nonNegativeInteger(usage.cachedInputTokens),
+    outputTokens: nonNegativeInteger(usage.outputTokens),
+    costUsd: nonNegativeNumber(usage.costUsd),
+    recordedAt: typeof source.recordedAt === "string" && source.recordedAt ? source.recordedAt : (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function aggregateRunTurnUsage(turns) {
+  const normalized = Array.isArray(turns) ? turns.map(normalizeRunTurnUsage) : [];
+  const aggregate = normalized.reduce((total, turn) => ({
+    inputTokens: total.inputTokens + turn.inputTokens,
+    cachedInputTokens: total.cachedInputTokens + turn.cachedInputTokens,
+    outputTokens: total.outputTokens + turn.outputTokens,
+    costUsd: total.costUsd + turn.costUsd
+  }), {
+    inputTokens: 0,
+    cachedInputTokens: 0,
+    outputTokens: 0,
+    costUsd: 0
+  });
+  const costUsd = Number(aggregate.costUsd.toFixed(12));
+  return {
+    ...aggregate,
+    costUsd,
+    costCents: costUsd > 0 ? Math.max(0, Math.round(costUsd * 100)) : 0
+  };
+}
+function createRunCompletionState(input) {
+  const command = record3(input.command);
+  const commandId = nonEmptyString(command.commandId ?? command.id, "command.commandId");
+  const connectorId = nonEmptyString(input.connectorId ?? command.connectorId, "connectorId");
+  const now = typeof input.now === "string" && input.now ? input.now : (/* @__PURE__ */ new Date()).toISOString();
+  const firstTurn = normalizeRunTurnUsage({ ...record3(input.turn), turn: "primary", recordedAt: now });
+  return {
+    version: RUN_COMPLETION_STATE_VERSION,
+    commandId,
+    connectorId,
+    phase: "usage_snapshot_persisted",
+    closureAttempt: 0,
+    command,
+    executor: record3(input.executor),
+    completionRequest: record3(input.completionRequest),
+    candidateStatus: nonEmptyString(input.candidateStatus, "candidateStatus"),
+    candidateResult: record3(input.candidateResult),
+    ...typeof input.candidateError === "string" && input.candidateError ? { candidateError: input.candidateError } : {},
+    usageRecord: {
+      schemaVersion: RUN_COMPLETION_USAGE_SCHEMA_VERSION,
+      idempotencyKey: runtimeCommandCostIdempotencyKey(commandId),
+      commandId,
+      turns: [firstTurn],
+      aggregate: aggregateRunTurnUsage([firstTurn]),
+      ingestStatus: "pending"
+    },
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function appendRunCompletionUsageTurn(state, input) {
+  const current = assertValidRunCompletionState(state);
+  const turn = normalizeRunTurnUsage(input);
+  const priorTurns = current.usageRecord.turns.filter((entry) => entry.turn !== turn.turn);
+  const turns = [...priorTurns, turn].sort((left, right) => left.attempt - right.attempt);
+  return {
+    ...current,
+    closureAttempt: turn.turn === "closure" ? 1 : current.closureAttempt,
+    phase: "usage_snapshot_persisted",
+    usageRecord: {
+      ...current.usageRecord,
+      turns,
+      aggregate: aggregateRunTurnUsage(turns),
+      ingestStatus: "pending"
+    },
+    updatedAt: turn.recordedAt
+  };
+}
+function transitionRunCompletionState(state, event, patch = {}, now = (/* @__PURE__ */ new Date()).toISOString()) {
+  const current = assertValidRunCompletionState(state);
+  const nextPhase = PHASE_TRANSITIONS.get(`${current.phase}:${event}`);
+  if (!nextPhase) {
+    throw new Error(`run_completion_state_transition_invalid:${current.phase}:${event}`);
+  }
+  return assertValidRunCompletionState({
+    ...current,
+    ...record3(patch),
+    phase: nextPhase,
+    updatedAt: now
+  });
+}
+function markRunCompletionCostDelivered(state, receipt, now = (/* @__PURE__ */ new Date()).toISOString()) {
+  const current = assertValidRunCompletionState(state);
+  return transitionRunCompletionState({
+    ...current,
+    usageRecord: {
+      ...current.usageRecord,
+      ingestStatus: "delivered",
+      deliveredAt: now,
+      receipt: record3(receipt)
+    }
+  }, "cost_ingest_delivered", {}, now);
+}
+function assertValidRunCompletionState(value) {
+  const state = record3(value);
+  if (state.version !== RUN_COMPLETION_STATE_VERSION) throw new Error("run_completion_state_invalid:version");
+  const commandId = nonEmptyString(state.commandId, "commandId");
+  const connectorId = nonEmptyString(state.connectorId, "connectorId");
+  if (!RUN_COMPLETION_PHASES.has(state.phase)) throw new Error("run_completion_state_invalid:phase");
+  const command = record3(state.command);
+  if (nonEmptyString(command.commandId ?? command.id, "command.commandId") !== commandId) {
+    throw new Error("run_completion_state_invalid:command_binding");
+  }
+  if (nonEmptyString(command.connectorId, "command.connectorId") !== connectorId) {
+    throw new Error("run_completion_state_invalid:connector_binding");
+  }
+  const usageRecord = record3(state.usageRecord);
+  if (usageRecord.schemaVersion !== RUN_COMPLETION_USAGE_SCHEMA_VERSION) {
+    throw new Error("run_completion_state_invalid:usage_schema");
+  }
+  if (usageRecord.commandId !== commandId) throw new Error("run_completion_state_invalid:usage_command_binding");
+  if (usageRecord.idempotencyKey !== runtimeCommandCostIdempotencyKey(commandId)) {
+    throw new Error("run_completion_state_invalid:usage_idempotency_key");
+  }
+  const turns = Array.isArray(usageRecord.turns) ? usageRecord.turns.map(normalizeRunTurnUsage) : [];
+  if (turns.length < 1 || turns.length > 2) throw new Error("run_completion_state_invalid:usage_turns");
+  const kinds = new Set(turns.map((turn) => turn.turn));
+  if (kinds.size !== turns.length || !kinds.has("primary")) {
+    throw new Error("run_completion_state_invalid:usage_turn_identity");
+  }
+  const aggregate = aggregateRunTurnUsage(turns);
+  return {
+    ...state,
+    commandId,
+    connectorId,
+    command,
+    executor: record3(state.executor),
+    completionRequest: record3(state.completionRequest),
+    candidateResult: record3(state.candidateResult),
+    usageRecord: {
+      ...usageRecord,
+      turns,
+      aggregate,
+      ingestStatus: ["delivered", "failed"].includes(usageRecord.ingestStatus) ? usageRecord.ingestStatus : "pending"
+    }
+  };
+}
+function writeRunCompletionState(directory, state) {
+  const valid = assertValidRunCompletionState(state);
+  mkdirSync4(directory, { recursive: true, mode: 448 });
+  const filePath = join5(directory, runCompletionStateFileName(valid.commandId));
+  const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync4(temporaryPath, `${JSON.stringify(valid, null, 2)}
+`, { mode: 384 });
+  renameSync2(temporaryPath, filePath);
+  return filePath;
+}
+function readRunCompletionState(filePath) {
+  return assertValidRunCompletionState(JSON.parse(readFileSync4(filePath, "utf8")));
+}
+function listRunCompletionStateFiles(directory) {
+  if (!existsSync4(directory)) return [];
+  return readdirSync3(directory).filter((name) => name.endsWith(".json")).sort().map((name) => join5(directory, name));
+}
+function removeRunCompletionState(directory, commandId) {
+  const filePath = join5(directory, runCompletionStateFileName(commandId));
+  if (existsSync4(filePath)) unlinkSync(filePath);
+}
+
 // src/amaster-runtime-daemon/prompt-compiler.mjs
 var DEFAULT_PROMPT_BUDGET_CHARS = 32e3;
 var DEADLINE_POSTURE_GUARD = "Named-window:skip_this_window_and_continue; no lower-quality/approval-bypass/fabrication/whole-task-stop; deadline_posture_receipt=targetMilestoneRef,posture,onMiss,taskContinuation,next owner/action; not Server proof";
@@ -2720,8 +2981,8 @@ function governedReadSection(context) {
   const reads = Array.isArray(context.governedReadResults) ? context.governedReadResults : [];
   if (reads.length === 0) return { content: "", provenance: [] };
   const normalized = reads.map((entry, index) => {
-    const record4 = asRecord(entry);
-    const receipt = asRecord(record4.receipt);
+    const record5 = asRecord(entry);
+    const receipt = asRecord(record5.receipt);
     const provider = readString(receipt.provider) ?? readString(receipt.transport);
     const operation = readString(receipt.operation);
     const observedAt = readString(receipt.retrievedAt) ?? readString(receipt.observedAt);
@@ -2731,7 +2992,7 @@ function governedReadSection(context) {
       throw new Error(`governed_read_context_provenance_invalid: entry ${index} requires provider, operation, observedAt, and source`);
     }
     return {
-      content: record4.content,
+      content: record5.content,
       receipt: {
         provider,
         operation,
@@ -2754,6 +3015,146 @@ function governedReadSection(context) {
     }))
   };
 }
+function canonicalJsonValue(value) {
+  if (Array.isArray(value)) return value.map(canonicalJsonValue);
+  const record5 = asRecord(value);
+  if (Object.keys(record5).length === 0) return value;
+  return Object.fromEntries(
+    Object.keys(record5).sort().map((key) => [key, canonicalJsonValue(record5[key])])
+  );
+}
+function resolvedDependencySections(context, input, contextScope, snapshotFreshness) {
+  const wake = asRecord(context.paperclipWake);
+  const hasContextCopy = Object.prototype.hasOwnProperty.call(context, "resolvedBlockerSummaries");
+  const hasWakeCopy = Object.prototype.hasOwnProperty.call(wake, "resolvedBlockerSummaries");
+  if (hasContextCopy && !Array.isArray(context.resolvedBlockerSummaries)) {
+    throw new Error("Resolved dependency context invalid: resolvedBlockerSummaries must be an array");
+  }
+  if (hasWakeCopy && !Array.isArray(wake.resolvedBlockerSummaries)) {
+    throw new Error("Resolved dependency wake context invalid: resolvedBlockerSummaries must be an array");
+  }
+  const contextCopy = hasContextCopy ? context.resolvedBlockerSummaries : null;
+  const wakeCopy = hasWakeCopy ? wake.resolvedBlockerSummaries : null;
+  if (contextCopy && wakeCopy && JSON.stringify(canonicalJsonValue(contextCopy)) !== JSON.stringify(canonicalJsonValue(wakeCopy))) {
+    throw new Error("Resolved dependency snapshots diverge between contextSnapshot and paperclipWake");
+  }
+  const summaries = contextCopy ?? wakeCopy ?? [];
+  const tuples = [];
+  const seenTuples = /* @__PURE__ */ new Set();
+  const detailLines = [];
+  const detailSourceRefs = [];
+  const detailObservedAt = [];
+  for (let blockerIndex = 0; blockerIndex < summaries.length; blockerIndex += 1) {
+    const blocker = asRecord(summaries[blockerIndex]);
+    const blockerId = readString(blocker.id);
+    const blockerIdentifier = readString(blocker.identifier);
+    const blockerSelector = blockerIdentifier ?? blockerId;
+    const documents = Array.isArray(blocker.documents) ? blocker.documents : [];
+    const blockerObservedAt = readString(blocker.completedAt) ?? readString(blocker.updatedAt);
+    if (!blockerSelector && documents.length > 0) {
+      throw new Error(
+        `Resolved dependency context invalid: blocker ${blockerIndex} requires an issue id or identifier`
+      );
+    }
+    if (blockerSelector) {
+      detailLines.push(
+        `- ${blockerSelector}${readString(blocker.title) ? ` ${readString(blocker.title)}` : ""}${readString(blocker.status) ? ` (${readString(blocker.status)})` : ""}`
+      );
+      const summary = readString(blocker.summary);
+      if (summary) detailLines.push(`  Summary: ${summary}`);
+      detailSourceRefs.push(`issue:${blockerId ?? blockerSelector}`);
+      detailObservedAt.push(blockerObservedAt);
+    }
+    for (let documentIndex = 0; documentIndex < documents.length; documentIndex += 1) {
+      const document = asRecord(documents[documentIndex]);
+      const documentId = readString(document.documentId);
+      const key = readString(document.key);
+      const expectedLatestRevisionId = readString(document.latestRevisionId);
+      if (!blockerSelector || !documentId || !key || !expectedLatestRevisionId) {
+        throw new Error(
+          `Resolved dependency context invalid: blocker ${blockerIndex} document ${documentIndex} requires blocker issue selector, documentId, key, and latestRevisionId`
+        );
+      }
+      const latestRevisionNumber = document.latestRevisionNumber;
+      if (latestRevisionNumber != null && (!Number.isInteger(latestRevisionNumber) || latestRevisionNumber < 1)) {
+        throw new Error(
+          `Resolved dependency context invalid: blocker ${blockerIndex} document ${documentIndex} latestRevisionNumber must be a positive integer`
+        );
+      }
+      const tupleKey = JSON.stringify([
+        blockerId,
+        blockerSelector,
+        documentId,
+        key,
+        expectedLatestRevisionId
+      ]);
+      if (seenTuples.has(tupleKey)) continue;
+      seenTuples.add(tupleKey);
+      tuples.push({
+        blockerId,
+        blockerSelector,
+        documentId,
+        key,
+        expectedLatestRevisionId,
+        expectedLatestRevisionNumber: latestRevisionNumber ?? null,
+        observedAt: readString(document.updatedAt) ?? blockerObservedAt
+      });
+      const documentTitle = readString(document.title);
+      detailLines.push(
+        `  Document: ${key}${documentTitle ? ` (${documentTitle})` : ""}${latestRevisionNumber != null ? ` revision ${latestRevisionNumber}` : ""}`
+      );
+    }
+    const workProducts = Array.isArray(blocker.workProducts) ? blocker.workProducts : [];
+    for (const rawWorkProduct of workProducts) {
+      const workProduct = asRecord(rawWorkProduct);
+      const workProductId = readString(workProduct.id);
+      const workProductTitle = readString(workProduct.title);
+      if (!workProductId && !workProductTitle) continue;
+      detailLines.push(
+        `  Work product: ${workProductId ?? workProductTitle}${workProductTitle && workProductId ? ` (${workProductTitle})` : ""}`
+      );
+      const workProductSummary = readString(workProduct.summary);
+      if (workProductSummary) detailLines.push(`    ${workProductSummary}`);
+    }
+  }
+  const requiredLines = tuples.length > 0 ? [
+    "Accepted predecessor outputs are binding inputs unless this issue explicitly requests reconsideration.",
+    "Before any downstream document/artifact write, review request, status mutation, or completion, perform every Required read.",
+    "Current-issue documents, parent-issue documents, summaries, and workspace files are not substitutes for these predecessor documents.",
+    "Compare each returned latestRevisionId with the expected value. On revision mismatch, do not perform downstream writes; report it.",
+    ...tuples.flatMap((tuple, index) => {
+      const readArguments = { issueId: tuple.blockerSelector, key: tuple.key };
+      const call = input.executorKind === "pi" && input.managedMcpToolMode === "proxy_only" ? {
+        server: "amaster",
+        tool: "amaster.read_issue_document",
+        args: JSON.stringify(readArguments)
+      } : readArguments;
+      return [
+        `- Required read ${index + 1}: issue ${JSON.stringify(tuple.blockerSelector)}${tuple.blockerId ? ` (id ${JSON.stringify(tuple.blockerId)})` : ""}; document ${JSON.stringify(tuple.documentId)}; key ${JSON.stringify(tuple.key)}; expected latestRevisionId ${JSON.stringify(tuple.expectedLatestRevisionId)}${tuple.expectedLatestRevisionNumber != null ? `; revisionNumber ${tuple.expectedLatestRevisionNumber}` : ""}.`,
+        input.executorKind === "pi" && input.managedMcpToolMode === "proxy_only" ? `  Exact Pi \`mcp\` arguments: ${JSON.stringify(call)}` : `  Call amaster.read_issue_document with these exact arguments: ${JSON.stringify(call)}`
+      ];
+    })
+  ].join("\n") : "";
+  return {
+    required: {
+      content: requiredLines,
+      sourceRef: tuples.map(
+        (tuple) => `issue:${tuple.blockerId ?? tuple.blockerSelector}/document:${tuple.documentId}@${tuple.expectedLatestRevisionId}`
+      ),
+      observedAt: tuples.map((tuple) => tuple.observedAt),
+      freshness: tuples.map(() => snapshotFreshness),
+      scope: tuples.map(() => contextScope),
+      tupleCount: tuples.length
+    },
+    details: {
+      content: detailLines.join("\n"),
+      sourceRef: detailSourceRefs,
+      observedAt: detailObservedAt,
+      freshness: detailSourceRefs.map(() => snapshotFreshness),
+      scope: detailSourceRefs.map(() => contextScope)
+    }
+  };
+}
 function fixedRules(input, includeIssueLine) {
   return [
     "## AMaster Runtime Connector Task",
@@ -2790,9 +3191,15 @@ function interactionResolutionText(context) {
   const wakeResolution = asRecord(asRecord(context.paperclipWake).interactionResolution);
   const resolution = Object.keys(direct).length > 0 ? direct : wakeResolution;
   if (Object.keys(resolution).length === 0) return "";
+  const target = asRecord(resolution.target);
+  const exactDocumentRevisionDirective = readString(resolution.status) === "changes_requested" && readString(target.type) === "issue_document" && readString(target.issueId) && readString(target.documentId) && readString(target.key) && readString(target.revisionId) ? [
+    "The review target is an exact issue_document revision. Revise that same document with upsert_document_revision: copy target.issueId, target.documentId, and target.key, and use target.revisionId as baseRevisionId.",
+    "Do not copy the reviewed document into the current issue and do not restart its revision lineage at 1."
+  ].join(" ") : "";
   return [
     "Treat this resolved interaction as the authoritative delta for this run.",
     readString(resolution.status) === "changes_requested" ? "Apply every requested change before creating a replacement review." : "",
+    exactDocumentRevisionDirective,
     stringifyBoundedJson(resolution, 8e3)
   ].filter(Boolean).join("\n");
 }
@@ -2928,12 +3335,36 @@ function runtimeDecompositionRequirementText(context) {
     `Requirement source: ${sourceType}:${sourceId}@${sourceRevision}`
   ].join("\n");
 }
+function piMcpProxyExamplesText(input) {
+  if (!input.hasGovernedMcp || input.executorKind !== "pi" || input.managedMcpToolMode !== "proxy_only" || isRecoveryWakeReason(input.wakeReason)) return "";
+  const proxy = (tool, args) => JSON.stringify({
+    server: "amaster",
+    tool,
+    args: JSON.stringify(args)
+  });
+  return [
+    "The Pi native tool is the outer `mcp` proxy. Emit these as actual tool calls; `args` is the stringified inner canonical object:",
+    "Keep review payload strings short. Reference the exact document key and revision in `target`; do not duplicate the reviewed document body in `prompt` or `detailsMarkdown`.",
+    `- describe: ${proxy("runtime_action.describe", { schemaVersion: "runtime-action-v1", actionType: "update_parent" })}`,
+    `- submit: ${proxy("runtime_action.submit", { schemaVersion: "runtime-action-v1", idempotencyKey: "task-123-progress", action: { type: "update_parent", status: "in_progress", comment: "Continue the remaining work." } })}`,
+    `- submit review interaction: ${proxy("runtime_action.submit", { schemaVersion: "runtime-action-v1", idempotencyKey: "task-123-review", action: { type: "create_interaction", kind: "request_confirmation", continuationPolicy: "wake_assignee_on_accept", payload: { version: 1, resolutionMode: "review", prompt: "Review `plan` revision 1.", target: { type: "issue_document", issueId: "11111111-1111-4111-8111-111111111111", documentId: "33333333-3333-4333-8333-333333333333", key: "plan", revisionId: "22222222-2222-4222-8222-222222222222", revisionNumber: 1 } } } })}`,
+    `- plan: ${proxy("runtime_action.plan", { schemaVersion: "runtime-action-v1", idempotencyKey: "task-123-plan", actions: [{ type: "update_parent", status: "in_progress", comment: "Continue the remaining work." }] })}`,
+    `- commit the returned plan revision: ${proxy("runtime_action.commit", { schemaVersion: "runtime-action-v1", planId: "11111111-1111-4111-8111-111111111111", revision: "plan-revision-1" })}`,
+    `- read document: ${proxy("amaster.read_issue_document", { issueId: "AM-123", key: "plan" })}`
+  ].join("\n");
+}
 function sectionText(section) {
   if (!section.content) return "";
   return section.title ? `## ${section.title}
 ${section.content}` : section.content;
 }
 function truncateSection(section, targetChars) {
+  const mandatoryContent = section.mandatoryContent ?? "";
+  if (targetChars <= mandatoryContent.length) {
+    section.content = mandatoryContent;
+    section.truncationReason = "unified_context_budget";
+    return;
+  }
   if (targetChars <= 0) {
     section.content = "";
     section.truncationReason = "unified_context_budget";
@@ -3015,12 +3446,33 @@ function compileCommandPromptWithManifest(input, options = {}) {
     issueId: input.issueId ?? null
   };
   const snapshotFreshness = { kind: "run_snapshot" };
+  const resolvedDependencies = resolvedDependencySections(
+    context,
+    input,
+    contextScope,
+    snapshotFreshness
+  );
+  const resolvedDependencyContent = resolvedDependencies.required.content ? [
+    resolvedDependencies.required.content,
+    resolvedDependencies.details.content ? `Auxiliary predecessor context (may be truncated):
+${resolvedDependencies.details.content}` : ""
+  ].filter(Boolean).join("\n\n") : "";
+  const piMcpProxyExamples = resolvedDependencies.required.content ? "" : piMcpProxyExamplesText(input);
   const rawSections = [
     { name: "runtime_rules", title: "", priority: 100, sourceRef: `command:${input.commandId}`, content: fixedRules(input, !hasTask) },
+    ...resolvedDependencyContent ? [{
+      name: "resolved_dependencies",
+      title: "Resolved Dependency Outputs",
+      priority: 99,
+      ...resolvedDependencies.required,
+      content: resolvedDependencyContent,
+      mandatoryContent: resolvedDependencies.required.content
+    }] : [],
     { name: "recovery_instruction", title: "Recovery Instruction", priority: 100, sourceRef: `run:${input.runId ?? "unknown"}`, content: completeRecoveryInstruction, truncationReason: completeRecoveryInstruction ? null : "mode_selection" },
     { name: "approval_continuation", title: "Approved Runtime Action Continuation", priority: 99, sourceRef: `run:${input.runId ?? "unknown"}`, content: approvalContinuationText(input), truncationReason: mode === "continuation" ? null : "mode_selection" },
     { name: "runtime_authorization", title: "Runtime Action Contract", priority: 98, sourceRef: `run:${input.runId ?? "unknown"}`, content: runtimeAuthorizationText(context, mode, { suppressOrdinaryCompletionContract }) },
     { name: "runtime_decomposition_requirement", title: "Required Task Decomposition", priority: 98, sourceRef: `issue:${input.issueId ?? "unknown"}`, content: runtimeDecompositionRequirementText(context) },
+    ...piMcpProxyExamples ? [{ name: "pi_mcp_proxy_examples", title: "Pi MCP Proxy Examples", priority: 96, sourceRef: "amaster_governed_mcp_proxy_contract", content: piMcpProxyExamples }] : [],
     { name: "continuation_summary", title: "Continuation Summary", priority: 97, sourceRef: readString(asRecord(context.paperclipContinuationSummary).key) ?? `issue:${input.issueId ?? "unknown"}`, observedAt: readString(asRecord(context.paperclipContinuationSummary).updatedAt), originalContent: continuationSummary, content: mode === "cold" ? "" : continuationSummary, truncationReason: mode === "cold" ? "mode_selection" : null },
     { name: "wake_comments", title: wakeDeltaTitle, priority: interactionResolution ? 99 : 95, sourceRef: wakeDeltaSourceRefs, originalContent: wakeDeltaOriginal, content: wakeDeltaContent, truncationReason: commentsSelected ? null : "duplicate_task_context" },
     { name: "task", title: "Task Context", priority: 90, sourceRef: `issue:${input.issueId ?? "unknown"}`, originalContent: taskText, content: includeTask ? taskText : "", truncationReason: includeTask ? null : "mode_selection" },
@@ -3061,7 +3513,9 @@ function compileCommandPromptWithManifest(input, options = {}) {
     }
     if (prompt.length <= maxChars && manifest.budget.usedChars === prompt.length) break;
     const overflow = Math.max(1, prompt.length - maxChars);
-    const candidate = [...sections].filter((section) => section.priority < 100 && section.content.length > 0).sort((left, right) => left.priority - right.priority)[0];
+    const candidate = [...sections].filter(
+      (section) => section.priority < 100 && section.content.length > (section.mandatoryContent?.length ?? 0)
+    ).sort((left, right) => left.priority - right.priority)[0];
     if (!candidate) {
       if (!compactManifest) {
         compactManifest = true;
@@ -3070,6 +3524,11 @@ function compileCommandPromptWithManifest(input, options = {}) {
       }
       const fixedChars = sections.filter((section) => section.priority === 100).map(sectionText).join("\n").length;
       const manifestChars = JSON.stringify(manifest).length;
+      if (resolvedDependencies.required.tupleCount > 0) {
+        throw new Error(
+          `Resolved dependency mandatory read tuples exceed the unified ${maxChars}-character prompt budget: tupleCount=${resolvedDependencies.required.tupleCount} promptChars=${prompt.length} fixedChars=${fixedChars} manifestChars=${manifestChars}`
+        );
+      }
       throw new Error(`Prompt fixed sections exceed the unified ${maxChars}-character budget: promptChars=${prompt.length} fixedChars=${fixedChars} manifestChars=${manifestChars}`);
     }
     truncateSection(candidate, Math.max(0, candidate.content.length - overflow - 32));
@@ -3082,9 +3541,9 @@ function compileCommandPromptWithManifest(input, options = {}) {
 }
 
 // src/amaster-runtime-daemon/config-state.mjs
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync4, renameSync as renameSync2, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync5, renameSync as renameSync3, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir as homedir2, hostname } from "node:os";
-import { dirname as dirname4, join as join5 } from "node:path";
+import { dirname as dirname4, join as join6 } from "node:path";
 
 // src/amaster-runtime-daemon/executor-discovery.mjs
 import { spawnSync as spawnSync3 } from "node:child_process";
@@ -3200,26 +3659,26 @@ function defaultMachineId() {
 }
 function runtimeHome(env) {
   return expandHomePath(String(
-    env.AMASTER_RUNTIME_STATE_HOME || env.AMASTER_RUNTIME_HOME || join5(homedir2(), ".amaster-employee")
+    env.AMASTER_RUNTIME_STATE_HOME || env.AMASTER_RUNTIME_HOME || join6(homedir2(), ".amaster-employee")
   ));
 }
 function stateFilePath(env) {
-  return env.AMASTER_DAEMON_STATE_FILE ? expandHomePath(String(env.AMASTER_DAEMON_STATE_FILE)) : join5(runtimeHome(env), "runtime-connector-state.json");
+  return env.AMASTER_DAEMON_STATE_FILE ? expandHomePath(String(env.AMASTER_DAEMON_STATE_FILE)) : join6(runtimeHome(env), "runtime-connector-state.json");
 }
 function corruptStatePath(path) {
   const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/\D/g, "").slice(0, 14);
   const base = `${path}.corrupt-${timestamp2}Z`;
   let candidate = base;
-  for (let suffix = 1; existsSync4(candidate); suffix += 1) {
+  for (let suffix = 1; existsSync5(candidate); suffix += 1) {
     candidate = `${base}.${suffix}`;
   }
   return candidate;
 }
 function readState(env) {
   const path = stateFilePath(env);
-  if (!existsSync4(path)) return {};
+  if (!existsSync5(path)) return {};
   try {
-    const state = JSON.parse(readFileSync4(path, "utf8"));
+    const state = JSON.parse(readFileSync5(path, "utf8"));
     if (!state || typeof state !== "object" || Array.isArray(state)) {
       throw new TypeError("runtime connector state must be a JSON object");
     }
@@ -3227,7 +3686,7 @@ function readState(env) {
   } catch {
     const quarantinePath = corruptStatePath(path);
     try {
-      renameSync2(path, quarantinePath);
+      renameSync3(path, quarantinePath);
       process.stderr.write(`AMaster runtime state was invalid and quarantined at ${quarantinePath}
 `);
     } catch (error) {
@@ -3241,15 +3700,15 @@ function readState(env) {
 }
 function writeState(env, state) {
   const path = stateFilePath(env);
-  mkdirSync4(dirname4(path), { recursive: true });
+  mkdirSync5(dirname4(path), { recursive: true });
   const temporaryPath = `${path}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
   try {
-    writeFileSync4(temporaryPath, `${JSON.stringify(state, null, 2)}
+    writeFileSync5(temporaryPath, `${JSON.stringify(state, null, 2)}
 `, {
       flag: "wx",
       mode: 384
     });
-    renameSync2(temporaryPath, path);
+    renameSync3(temporaryPath, path);
   } finally {
     rmSync3(temporaryPath, { force: true });
   }
@@ -3263,15 +3722,15 @@ function buildConfig(env = process.env, flags = {}) {
   const authHeader = String(flags.authHeader ?? env.AMASTER_CONNECTOR_AUTH_HEADER ?? "");
   const home = runtimeHome(env);
   const runtimeWorkspacesRoot = expandHomePath(
-    String(flags.runtimeWorkspacesRoot ?? env.AMASTER_RUNTIME_WORKSPACES_ROOT ?? join5(home, "workspaces"))
+    String(flags.runtimeWorkspacesRoot ?? env.AMASTER_RUNTIME_WORKSPACES_ROOT ?? join6(home, "workspaces"))
   );
   const browserSessionStateRoot = expandHomePath(String(
-    flags.browserSessionStateRoot ?? env.AMASTER_BROWSER_SESSION_STATE_ROOT ?? join5(home, "browser-auth")
+    flags.browserSessionStateRoot ?? env.AMASTER_BROWSER_SESSION_STATE_ROOT ?? join6(home, "browser-auth")
   ));
   const browserExecutablePath = String(
     flags.browserExecutablePath ?? env.AMASTER_BROWSER_EXECUTABLE_PATH ?? ""
   ).trim();
-  mkdirSync4(runtimeWorkspacesRoot, { recursive: true });
+  mkdirSync5(runtimeWorkspacesRoot, { recursive: true });
   const workspaceBindings = splitList(
     flags.workspaceAllowlist ?? env.AMASTER_WORKSPACE_ALLOWLIST ?? env.AMASTER_WORKSPACE_BINDINGS ?? runtimeWorkspacesRoot
   ).map(expandHomePath);
@@ -3418,10 +3877,10 @@ function compactExecutorJsonlForTranscript(event) {
     const text = JSON.stringify(compactExecutorJsonValue(event, stringMaxChars));
     if (text.length <= 15e3) return text;
   }
-  const record4 = tcAsRecord(event);
-  const item = tcAsRecord(record4.item);
+  const record5 = tcAsRecord(event);
+  const item = tcAsRecord(record5.item);
   return JSON.stringify({
-    type: tcReadString(record4.type) ?? "executor.event",
+    type: tcReadString(record5.type) ?? "executor.event",
     item: item.type ? {
       id: tcReadString(item.id),
       type: tcReadString(item.type),
@@ -3434,10 +3893,10 @@ function compactExecutorJsonlForTranscript(event) {
   });
 }
 function summarizeTokenUsage(usage) {
-  const record4 = tcAsRecord(usage);
-  const inputTokens = tcReadNumber(record4.input_tokens ?? record4.inputTokens, 0);
-  const cachedInputTokens = tcReadNumber(record4.cached_input_tokens ?? record4.cachedInputTokens, 0);
-  const outputTokens = tcReadNumber(record4.output_tokens ?? record4.outputTokens, 0);
+  const record5 = tcAsRecord(usage);
+  const inputTokens = tcReadNumber(record5.input_tokens ?? record5.inputTokens, 0);
+  const cachedInputTokens = tcReadNumber(record5.cached_input_tokens ?? record5.cachedInputTokens, 0);
+  const outputTokens = tcReadNumber(record5.output_tokens ?? record5.outputTokens, 0);
   const parts = [];
   if (inputTokens > 0) parts.push(`\u8F93\u5165 ${inputTokens}`);
   if (cachedInputTokens > 0) parts.push(`\u7F13\u5B58 ${cachedInputTokens}`);
@@ -3692,8 +4151,8 @@ function summarizeClaudeEvent(event) {
   return null;
 }
 function tcPiMessageText(message) {
-  const record4 = tcAsRecord(message);
-  const content = record4.content;
+  const record5 = tcAsRecord(message);
+  const content = record5.content;
   if (typeof content === "string" && content.trim().length > 0) return content.trim();
   if (!Array.isArray(content)) return "";
   return content.map((entry) => {
@@ -3707,14 +4166,14 @@ function tcPiAssistantMessageEventText(assistantMessageEvent) {
   return tcReadString(event.content) ?? "";
 }
 function tcPiMessageStopReason(message) {
-  const record4 = tcAsRecord(message);
-  return tcReadString(record4.stopReason ?? record4.stop_reason);
+  const record5 = tcAsRecord(message);
+  return tcReadString(record5.stopReason ?? record5.stop_reason);
 }
 function tcPiMessageErrorText(message) {
-  const record4 = tcAsRecord(message);
-  const explicitError = tcReadString(record4.errorMessage ?? record4.error_message)?.trim();
+  const record5 = tcAsRecord(message);
+  const explicitError = tcReadString(record5.errorMessage ?? record5.error_message)?.trim();
   if (explicitError) return explicitError;
-  const stopReason = tcPiMessageStopReason(record4);
+  const stopReason = tcPiMessageStopReason(record5);
   if (stopReason === "error" || stopReason === "failed" || stopReason === "exception") {
     return `Pi Agent message ended with stopReason=${stopReason}`;
   }
@@ -3927,6 +4386,36 @@ function governedMcpToolResult(structuredContent) {
     ...runtimeAction ? { runtimeAction } : {}
   };
 }
+function dedupeGovernedMcpToolResults(results) {
+  const unique = [];
+  const indexByInvocationId = /* @__PURE__ */ new Map();
+  for (const rawResult of Array.isArray(results) ? results : []) {
+    const result3 = asRecord(rawResult);
+    const invocationId = readString(result3.invocationId);
+    if (!invocationId) {
+      unique.push(result3);
+      continue;
+    }
+    const existingIndex = indexByInvocationId.get(invocationId);
+    if (existingIndex === void 0) {
+      indexByInvocationId.set(invocationId, unique.length);
+      unique.push(result3);
+      continue;
+    }
+    const existing = asRecord(unique[existingIndex]);
+    const existingRuntimeAction = asRecord(existing.runtimeAction);
+    const runtimeAction = asRecord(result3.runtimeAction);
+    const existingArtifactIntent = asRecord(existing.artifactIntent);
+    const artifactIntent = asRecord(result3.artifactIntent);
+    unique[existingIndex] = {
+      ...existing,
+      ...result3,
+      ...Object.keys(existingRuntimeAction).length > 0 || Object.keys(runtimeAction).length > 0 ? { runtimeAction: { ...existingRuntimeAction, ...runtimeAction } } : {},
+      ...Object.keys(existingArtifactIntent).length > 0 || Object.keys(artifactIntent).length > 0 ? { artifactIntent: { ...existingArtifactIntent, ...artifactIntent } } : {}
+    };
+  }
+  return unique;
+}
 function durablePiRuntimeActionEvidence(results) {
   const normalizedResults = (Array.isArray(results) ? results : []).map(asRecord);
   const writeCallIds = /* @__PURE__ */ new Set();
@@ -4051,12 +4540,13 @@ function parseCodexJsonl(stdout) {
       errorMessage = readString(error.message) ?? errorMessage;
     }
   }
+  const uniqueMcpToolResults = dedupeGovernedMcpToolResults(mcpToolResults);
   return {
     sessionId,
     summary,
     usage,
     errorMessage: terminalEvent === "completed" ? null : errorMessage,
-    ...mcpToolResults.length > 0 ? { mcpToolResults } : {}
+    ...uniqueMcpToolResults.length > 0 ? { mcpToolResults: uniqueMcpToolResults } : {}
   };
 }
 function buildCodexErrorHaystack(input) {
@@ -4257,13 +4747,13 @@ function parseClaudeStreamJson(stdout) {
 }
 function openCodeErrorText(value) {
   if (typeof value === "string") return value;
-  const record4 = asRecord(value);
-  const message = readString(record4.message);
+  const record5 = asRecord(value);
+  const message = readString(record5.message);
   if (message) return message;
-  const data = asRecord(record4.data);
+  const data = asRecord(record5.data);
   const nestedMessage = readString(data.message);
   if (nestedMessage) return nestedMessage;
-  return readString(record4.name) ?? readString(record4.code) ?? "";
+  return readString(record5.name) ?? readString(record5.code) ?? "";
 }
 function parseOpenCodeJsonl(stdout) {
   let sessionId = null;
@@ -4301,8 +4791,8 @@ function parseOpenCodeJsonl(stdout) {
   return { sessionId, summary, usage, errorMessage };
 }
 function piMessageText(message) {
-  const record4 = asRecord(message);
-  const content = record4.content;
+  const record5 = asRecord(message);
+  const content = record5.content;
   if (typeof content === "string") return content.trim();
   if (!Array.isArray(content)) return "";
   return content.map((entry) => {
@@ -4327,10 +4817,10 @@ function piTextValue(value) {
   return typeof value === "string" && value.length > 0 ? value : "";
 }
 function piAssistantEventText(assistantEvent) {
-  const record4 = asRecord(assistantEvent);
-  const type = readString(record4.type);
-  if (type === "text_delta") return piTextValue(record4.delta);
-  if (type === "text_end") return piTextValue(record4.content);
+  const record5 = asRecord(assistantEvent);
+  const type = readString(record5.type);
+  if (type === "text_delta") return piTextValue(record5.delta);
+  if (type === "text_end") return piTextValue(record5.content);
   return "";
 }
 function piMessageUsage(message) {
@@ -4351,14 +4841,14 @@ function assignPiUsage(target, source) {
   if (source.costUsd > 0) target.costUsd = source.costUsd;
 }
 function piMessageStopReason(message) {
-  const record4 = asRecord(message);
-  return readString(record4.stopReason ?? record4.stop_reason);
+  const record5 = asRecord(message);
+  return readString(record5.stopReason ?? record5.stop_reason);
 }
 function piMessageErrorText(message) {
-  const record4 = asRecord(message);
-  const explicitError = readString(record4.errorMessage ?? record4.error_message)?.trim();
+  const record5 = asRecord(message);
+  const explicitError = readString(record5.errorMessage ?? record5.error_message)?.trim();
   if (explicitError) return explicitError;
-  const stopReason = piMessageStopReason(record4);
+  const stopReason = piMessageStopReason(record5);
   if (stopReason === "error" || stopReason === "failed" || stopReason === "exception") {
     return `Pi Agent message ended with stopReason=${stopReason}`;
   }
@@ -4493,6 +4983,7 @@ function parsePiJsonl(stdout) {
       }
     }
   }
+  const uniqueMcpToolResults = dedupeGovernedMcpToolResults(mcpToolResults);
   return {
     sessionId,
     summary: messages.at(-1) ?? "",
@@ -4504,7 +4995,7 @@ function parsePiJsonl(stdout) {
     errorMessage,
     ...nonCleanupErrorCount > 0 ? { nonCleanupErrorCount } : {},
     ...cleanupDiagnostics.length > 0 ? { cleanupDiagnostics } : {},
-    ...mcpToolResults.length > 0 ? { mcpToolResults } : {}
+    ...uniqueMcpToolResults.length > 0 ? { mcpToolResults: uniqueMcpToolResults } : {}
   };
 }
 function parseGenericOutput(stdout, stderr) {
@@ -4615,6 +5106,12 @@ function parseRuntimeConnectorResponse(res, method, path, text) {
     const error = new Error(`${method} ${path} returned HTTP ${res.status}: ${responseDescription}`);
     error.httpStatus = res.status;
     error.responseContentType = responseContentType;
+    if (responseContentType?.includes("application/json") && text) {
+      try {
+        error.responseBody = JSON.parse(text);
+      } catch {
+      }
+    }
     throw error;
   }
   if (!text) return null;
@@ -4698,7 +5195,7 @@ var bestEffortPostJson = bestEffortPostRuntimeConnectorJson;
 
 // src/amaster-runtime-daemon/runtime-artifact-upload.mjs
 import { createHash as createHash3 } from "node:crypto";
-import { lstatSync as lstatSync3, readFileSync as readFileSync5, realpathSync as realpathSync2 } from "node:fs";
+import { lstatSync as lstatSync3, readFileSync as readFileSync6, realpathSync as realpathSync3 } from "node:fs";
 import { isAbsolute as isAbsolute3, relative as relative3, resolve as resolve3 } from "node:path";
 var SHA256_PATTERN = /^[a-f0-9]{64}$/;
 function requiredString(value, name) {
@@ -4715,7 +5212,7 @@ function pathWithin(candidate, root) {
   return rel === "" || !rel.startsWith("..") && !isAbsolute3(rel);
 }
 function prepareRuntimeArtifactUploads(cwd, mcpToolResults) {
-  const root = realpathSync2(resolve3(cwd));
+  const root = realpathSync3(resolve3(cwd));
   const uploads = /* @__PURE__ */ new Map();
   for (const result3 of Array.isArray(mcpToolResults) ? mcpToolResults : []) {
     const intent = result3 && typeof result3 === "object" && !Array.isArray(result3) ? result3.artifactIntent : null;
@@ -4736,10 +5233,10 @@ function prepareRuntimeArtifactUploads(cwd, mcpToolResults) {
     }
     const sourcePath = resolve3(root, sourceRelativePath);
     const stat = lstatSync3(sourcePath);
-    if (!stat.isFile() || stat.isSymbolicLink() || !pathWithin(realpathSync2(sourcePath), root)) {
+    if (!stat.isFile() || stat.isSymbolicLink() || !pathWithin(realpathSync3(sourcePath), root)) {
       throw new Error(`Runtime Artifact ${intentId} source is not an owned regular file`);
     }
-    const body = readFileSync5(sourcePath);
+    const body = readFileSync6(sourcePath);
     const actualSha256 = createHash3("sha256").update(body).digest("hex");
     if (body.length !== expectedByteSize || actualSha256 !== expectedSha256) {
       throw new Error(`Runtime Artifact ${intentId} bytes do not match the governed ownership manifest`);
@@ -4771,21 +5268,39 @@ var RuntimeArtifactIngestAggregateError = class extends AggregateError {
 };
 function createRuntimeArtifactIngestQueue({ ingest, onError }) {
   const handledIntentIds = /* @__PURE__ */ new Set();
+  const artifactIdentityByIntentId = /* @__PURE__ */ new Map();
+  const finalizedArtifactIdentities = /* @__PURE__ */ new Set();
   const artifacts = [];
   const errors = [];
   let queue = Promise.resolve();
+  const artifactIdentity = (intent) => {
+    const sourceRelativePath = readString(asRecord(intent).sourceRelativePath);
+    const sha2563 = readString(asRecord(intent).sha256);
+    const byteSize = asRecord(intent).byteSize;
+    return sourceRelativePath && sha2563 && Number.isSafeInteger(byteSize) && byteSize > 0 ? `${sourceRelativePath}\0${sha2563}\0${byteSize}` : null;
+  };
+  const retainReceipts = (receipts) => {
+    artifacts.push(...receipts);
+    for (const receipt of receipts) {
+      const intentId = readString(asRecord(receipt).intentId);
+      const identity2 = intentId ? artifactIdentityByIntentId.get(intentId) : null;
+      if (identity2) finalizedArtifactIdentities.add(identity2);
+    }
+  };
   return {
     enqueue(results) {
       const pending = results.filter((result3) => {
         const intentId = readString(asRecord(result3).artifactIntent?.intentId);
         if (!intentId || handledIntentIds.has(intentId)) return false;
         handledIntentIds.add(intentId);
+        const identity2 = artifactIdentity(asRecord(result3).artifactIntent);
+        if (identity2) artifactIdentityByIntentId.set(intentId, identity2);
         return true;
       });
       if (pending.length === 0) return;
-      queue = queue.then(async () => artifacts.push(...await ingest(pending))).catch((caught) => {
+      queue = queue.then(async () => retainReceipts(await ingest(pending))).catch((caught) => {
         const aggregate = caught instanceof RuntimeArtifactIngestAggregateError ? caught : null;
-        artifacts.push(...aggregate?.receipts ?? []);
+        retainReceipts(aggregate?.receipts ?? []);
         for (const error of aggregate?.failures ?? [normalizedError(caught)]) {
           errors.push(error);
           onError?.(error);
@@ -4797,8 +5312,14 @@ function createRuntimeArtifactIngestQueue({ ingest, onError }) {
     },
     async flush() {
       await queue;
-      if (errors.length > 0) {
-        throw new RuntimeArtifactIngestAggregateError(errors, artifacts);
+      const unresolvedErrors = errors.filter((error) => {
+        if (error.code === "runtime_artifact_rejected") return true;
+        const intentId = readString(error.intentId);
+        const identity2 = intentId ? artifactIdentityByIntentId.get(intentId) : null;
+        return !identity2 || !finalizedArtifactIdentities.has(identity2);
+      });
+      if (unresolvedErrors.length > 0) {
+        throw new RuntimeArtifactIngestAggregateError(unresolvedErrors, artifacts);
       }
       return [...artifacts];
     }
@@ -4807,40 +5328,40 @@ function createRuntimeArtifactIngestQueue({ ingest, onError }) {
 
 // src/amaster-runtime-daemon/workspace-guard.mjs
 import { createHash as createHash4 } from "node:crypto";
-import { existsSync as existsSync6, mkdirSync as mkdirSync5, realpathSync as realpathSync3, statSync as statSync3 } from "node:fs";
-import { basename as basename4, join as join7, isAbsolute as isAbsolute4, relative as relative4, resolve as resolve4 } from "node:path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync6, realpathSync as realpathSync4, statSync as statSync3 } from "node:fs";
+import { basename as basename4, join as join8, isAbsolute as isAbsolute4, relative as relative4, resolve as resolve4 } from "node:path";
 
 // src/amaster-runtime-daemon/workspace-manifest.mjs
-import { existsSync as existsSync5, readFileSync as readFileSync6, renameSync as renameSync3, rmSync as rmSync4, writeFileSync as writeFileSync5 } from "node:fs";
-import { basename as basename3, dirname as dirname5, join as join6 } from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync7, renameSync as renameSync4, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "node:fs";
+import { basename as basename3, dirname as dirname5, join as join7 } from "node:path";
 var WORKSPACE_MANIFEST_FILENAME = ".amaster-runtime.json";
 function nowIso() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
 function workspaceManifestPath(workspaceOrCwd) {
   if (!workspaceOrCwd) return null;
-  if (typeof workspaceOrCwd === "string") return join6(workspaceOrCwd, WORKSPACE_MANIFEST_FILENAME);
-  if (typeof workspaceOrCwd.cwd === "string") return join6(workspaceOrCwd.cwd, WORKSPACE_MANIFEST_FILENAME);
+  if (typeof workspaceOrCwd === "string") return join7(workspaceOrCwd, WORKSPACE_MANIFEST_FILENAME);
+  if (typeof workspaceOrCwd.cwd === "string") return join7(workspaceOrCwd.cwd, WORKSPACE_MANIFEST_FILENAME);
   return null;
 }
 function readWorkspaceManifest(manifestPath) {
-  if (!manifestPath || !existsSync5(manifestPath)) return null;
+  if (!manifestPath || !existsSync6(manifestPath)) return null;
   try {
-    const parsed = JSON.parse(readFileSync6(manifestPath, "utf8"));
+    const parsed = JSON.parse(readFileSync7(manifestPath, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
   }
 }
 function writeWorkspaceManifest(manifestPath, manifest) {
-  const tempPath = join6(
+  const tempPath = join7(
     dirname5(manifestPath),
     `.${basename3(manifestPath)}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`
   );
   try {
-    writeFileSync5(tempPath, `${JSON.stringify(manifest, null, 2)}
+    writeFileSync6(tempPath, `${JSON.stringify(manifest, null, 2)}
 `, { mode: 384 });
-    renameSync3(tempPath, manifestPath);
+    renameSync4(tempPath, manifestPath);
   } catch (err) {
     rmSync4(tempPath, { force: true });
     throw err;
@@ -4899,10 +5420,10 @@ function resolveWorkspaceCwd(config, command) {
   const payload = asRecord(command.payload);
   const requested = readString(payload.workspacePath);
   const fallback = config.workspaceBindings[0] ?? process.cwd();
-  const cwd = realpathSync3(resolve4(expandHomePath(requested ?? fallback)));
+  const cwd = realpathSync4(resolve4(expandHomePath(requested ?? fallback)));
   const allowlist = config.workspaceBindings.flatMap((entry) => {
     try {
-      return [realpathSync3(resolve4(expandHomePath(entry)))];
+      return [realpathSync4(resolve4(expandHomePath(entry)))];
     } catch {
       return [];
     }
@@ -4911,7 +5432,7 @@ function resolveWorkspaceCwd(config, command) {
   if (!allowed) {
     throw new Error(`Workspace path is outside AMASTER_WORKSPACE_ALLOWLIST: ${cwd}`);
   }
-  if (!existsSync6(cwd) || !statSync3(cwd).isDirectory()) {
+  if (!existsSync7(cwd) || !statSync3(cwd).isDirectory()) {
     throw new Error(`Workspace path does not exist or is not a directory: ${cwd}`);
   }
   return cwd;
@@ -4942,8 +5463,8 @@ function workspaceLabel(sourceWorkspacePath, payload) {
 }
 function workspacesRoot(config) {
   const root = resolve4(expandHomePath(config.runtimeWorkspacesRoot ?? "~/.amaster-employee/workspaces"));
-  mkdirSync5(root, { recursive: true });
-  return realpathSync3(root);
+  mkdirSync6(root, { recursive: true });
+  return realpathSync4(root);
 }
 function resolveExecutionWorkspace(config, command, opts = {}) {
   const sourceWorkspacePath = resolveWorkspaceCwd(config, command);
@@ -4955,11 +5476,11 @@ function resolveExecutionWorkspace(config, command, opts = {}) {
   const workspaceKey = `${safeSegment(workspaceLabel(sourceWorkspacePath, payload), "workspace")}-${shortHash(sourceWorkspacePath)}`;
   const issueKey = `${safeSegment(issueLabel(command, payload), "issue")}-${shortHash(issueId, 8)}`;
   const runKey = `${safeSegment(runId, "run")}-${shortHash(runId, 8)}`;
-  const runDir = join7(root, workspaceKey, issueKey, runKey);
-  const cwd = join7(runDir, "workdir");
-  const executorHome = join7(runDir, "executors", safeSegment(executorKind, "executor"));
-  mkdirSync5(cwd, { recursive: true });
-  mkdirSync5(executorHome, { recursive: true });
+  const runDir = join8(root, workspaceKey, issueKey, runKey);
+  const cwd = join8(runDir, "workdir");
+  const executorHome = join8(runDir, "executors", safeSegment(executorKind, "executor"));
+  mkdirSync6(cwd, { recursive: true });
+  mkdirSync6(executorHome, { recursive: true });
   const workspace = {
     managed: true,
     cwd,
@@ -4981,8 +5502,8 @@ function resolveExecutionWorkspace(config, command, opts = {}) {
 }
 
 // src/amaster-runtime-daemon/workspace-gc.mjs
-import { existsSync as existsSync7, readdirSync as readdirSync3, statSync as statSync4 } from "node:fs";
-import { join as join8, resolve as resolve5 } from "node:path";
+import { existsSync as existsSync8, readdirSync as readdirSync4, statSync as statSync4 } from "node:fs";
+import { join as join9, resolve as resolve5 } from "node:path";
 function readIsoTime(value) {
   if (typeof value !== "string" || !value.trim()) return null;
   const time = new Date(value).getTime();
@@ -4999,14 +5520,14 @@ function walkWorkdirs(root) {
     if (!current) continue;
     let entries = [];
     try {
-      entries = readdirSync3(current, { withFileTypes: true });
+      entries = readdirSync4(current, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const fullPath = join8(current, entry.name);
-      if (entry.name === "workdir" && existsSync7(workspaceManifestPath(fullPath))) {
+      const fullPath = join9(current, entry.name);
+      if (entry.name === "workdir" && existsSync8(workspaceManifestPath(fullPath))) {
         workdirs.push(fullPath);
         continue;
       }
@@ -5032,12 +5553,12 @@ function directorySizeBytes(path) {
     if (stat.isDirectory()) {
       let entries = [];
       try {
-        entries = readdirSync3(current, { withFileTypes: true });
+        entries = readdirSync4(current, { withFileTypes: true });
       } catch {
         continue;
       }
       for (const entry of entries) {
-        stack.push(join8(current, entry.name));
+        stack.push(join9(current, entry.name));
       }
       continue;
     }
@@ -5081,7 +5602,7 @@ function planManagedWorkspaceGcDryRun(input) {
     candidates: [],
     protected: []
   };
-  if (!root || !existsSync7(root)) return result3;
+  if (!root || !existsSync8(root)) return result3;
   for (const workdir of walkWorkdirs(root)) {
     const manifest = readWorkspaceManifest(workspaceManifestPath(workdir));
     if (!manifest || manifest.managed !== true) continue;
@@ -5109,11 +5630,11 @@ function planManagedWorkspaceGcDryRun(input) {
 }
 
 // src/amaster-runtime-daemon/runtime-status-summary.mjs
-import { existsSync as existsSync8, readdirSync as readdirSync4, statSync as statSync5 } from "node:fs";
-import { dirname as dirname6, join as join9, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync9, readdirSync as readdirSync5, statSync as statSync5 } from "node:fs";
+import { dirname as dirname6, join as join10, resolve as resolve6 } from "node:path";
 function runtimeStatusDirectoryEntries(path) {
   try {
-    return readdirSync4(path, { withFileTypes: true });
+    return readdirSync5(path, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -5133,7 +5654,7 @@ function runtimeStatusDirectorySizeBytes(path) {
     if (!stat || stat.isSymbolicLink()) continue;
     if (stat.isDirectory()) {
       for (const entry of runtimeStatusDirectoryEntries(current)) {
-        stack.push(join9(current, entry.name));
+        stack.push(join10(current, entry.name));
       }
       continue;
     }
@@ -5143,15 +5664,15 @@ function runtimeStatusDirectorySizeBytes(path) {
 }
 function walkRuntimeStatusManagedWorkdirs(root) {
   const workdirs = [];
-  if (!root || !existsSync8(root)) return workdirs;
+  if (!root || !existsSync9(root)) return workdirs;
   const stack = [root];
   while (stack.length > 0) {
     const current = stack.pop();
     if (!current) continue;
     for (const entry of runtimeStatusDirectoryEntries(current)) {
       if (!entry.isDirectory()) continue;
-      const fullPath = join9(current, entry.name);
-      if (entry.name === "workdir" && existsSync8(workspaceManifestPath(fullPath))) {
+      const fullPath = join10(current, entry.name);
+      if (entry.name === "workdir" && existsSync9(workspaceManifestPath(fullPath))) {
         workdirs.push(fullPath);
         continue;
       }
@@ -5192,12 +5713,12 @@ function summarizeRuntimeStatusRecentRun(workdir, manifest) {
 }
 function runtimeStatusOutboxDir(config) {
   const statePath = config.AMASTER_DAEMON_STATE_FILE ?? config.daemonStateFile;
-  return join9(dirname6(stateFilePath({
+  return join10(dirname6(stateFilePath({
     AMASTER_DAEMON_STATE_FILE: statePath
   })), "result-outbox");
 }
 function countRuntimeStatusJsonEntries(dir) {
-  if (!existsSync8(dir)) return 0;
+  if (!existsSync9(dir)) return 0;
   return runtimeStatusDirectoryEntries(dir).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).length;
 }
 function summarizeRuntimeLocalState(input) {
@@ -5229,7 +5750,7 @@ function summarizeRuntimeLocalState(input) {
     }
   }
   const pendingOutboxDir = runtimeStatusOutboxDir(config);
-  const invalidOutboxDir = join9(pendingOutboxDir, "invalid");
+  const invalidOutboxDir = join10(pendingOutboxDir, "invalid");
   return {
     managedWorkspacesRoot: root,
     managedWorkdirCount: workdirs.length,
@@ -5355,10 +5876,10 @@ import {
   chownSync,
   lchownSync,
   lstatSync as lstatSync4,
-  readdirSync as readdirSync5
+  readdirSync as readdirSync6
 } from "node:fs";
 import { resolve as resolve7, sep } from "node:path";
-var defaultFs = { chmodSync: chmodSync3, chownSync, lchownSync, lstatSync: lstatSync4, readdirSync: readdirSync5 };
+var defaultFs = { chmodSync: chmodSync3, chownSync, lchownSync, lstatSync: lstatSync4, readdirSync: readdirSync6 };
 function defaultHashRunId(runId) {
   return Number.parseInt(createHash5("sha256").update(runId).digest("hex").slice(0, 8), 16);
 }
@@ -5488,17 +6009,17 @@ import { createHash as createHash6 } from "node:crypto";
 import {
   chmodSync as chmodSync4,
   chownSync as chownSync2,
-  existsSync as existsSync9,
+  existsSync as existsSync10,
   lchownSync as lchownSync2,
   lstatSync as lstatSync5,
-  mkdirSync as mkdirSync6,
-  readFileSync as readFileSync7,
-  renameSync as renameSync4,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync8,
+  renameSync as renameSync5,
   rmSync as rmSync5,
   symlinkSync as symlinkSync2,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync7
 } from "node:fs";
-import { dirname as dirname7, isAbsolute as isAbsolute5, join as join10, relative as relative5, resolve as resolve8 } from "node:path";
+import { dirname as dirname7, isAbsolute as isAbsolute5, join as join11, relative as relative5, resolve as resolve8 } from "node:path";
 var REGISTRY_FILENAME = ".amaster-company-memory-groups.json";
 var COMPANY_MARKER_FILENAME = ".amaster-company-memory.json";
 var REGISTRY_VERSION = 1;
@@ -5508,15 +6029,15 @@ var DEFAULT_GID_SPAN = 1e6;
 var defaultFs2 = {
   chmodSync: chmodSync4,
   chownSync: chownSync2,
-  existsSync: existsSync9,
+  existsSync: existsSync10,
   lchownSync: lchownSync2,
   lstatSync: lstatSync5,
-  mkdirSync: mkdirSync6,
-  readFileSync: readFileSync7,
-  renameSync: renameSync4,
+  mkdirSync: mkdirSync7,
+  readFileSync: readFileSync8,
+  renameSync: renameSync5,
   rmSync: rmSync5,
   symlinkSync: symlinkSync2,
-  writeFileSync: writeFileSync6
+  writeFileSync: writeFileSync7
 };
 function requiredString2(value, label) {
   if (typeof value !== "string" || value.trim() === "") {
@@ -5580,7 +6101,7 @@ function ensureMemoryRoot(root, fs) {
   fs.chmodSync(root, 457);
 }
 function readGroupRegistry(root, fs) {
-  const path = join10(root, REGISTRY_FILENAME);
+  const path = join11(root, REGISTRY_FILENAME);
   if (!fs.existsSync(path)) {
     return { path, groups: {} };
   }
@@ -5662,11 +6183,11 @@ function prepareCompanyPiMemory(input, fs = defaultFs2) {
   if (input.gid !== void 0 && positiveInteger2(input.gid, "gid") !== gid) {
     throw new Error("pi_company_memory_gid_mismatch");
   }
-  const companyDir = join10(root, safeCompanyPiHomeSegment(companyId));
-  const companyPiHome = join10(companyDir, ".pi");
-  const memoryDir = join10(companyPiHome, "memories");
+  const companyDir = join11(root, safeCompanyPiHomeSegment(companyId));
+  const companyPiHome = join11(companyDir, ".pi");
+  const memoryDir = join11(companyPiHome, "memories");
   ensurePrivateDirectory(companyDir, 456, 0, gid, fs);
-  const markerPath = join10(companyDir, COMPANY_MARKER_FILENAME);
+  const markerPath = join11(companyDir, COMPANY_MARKER_FILENAME);
   if (fs.existsSync(markerPath)) {
     const markerStat = fs.lstatSync(markerPath);
     if (!markerStat.isFile() || markerStat.isSymbolicLink()) {
@@ -5691,7 +6212,7 @@ function prepareCompanyPiMemory(input, fs = defaultFs2) {
   assertDirectory(memoryDir, "memories", fs);
   fs.chownSync(memoryDir, 0, gid);
   fs.chmodSync(memoryDir, 1528);
-  const memoryLink = join10(profileHome, "memories");
+  const memoryLink = join11(profileHome, "memories");
   if (fs.existsSync(memoryLink)) {
     throw new Error("pi_company_memory_profile_link_exists");
   }
@@ -5715,16 +6236,16 @@ import { createHash as createHash7 } from "node:crypto";
 import {
   chmodSync as chmodSync5,
   copyFileSync as copyFileSync2,
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   lstatSync as lstatSync6,
-  mkdirSync as mkdirSync7,
-  readFileSync as readFileSync8,
-  readdirSync as readdirSync6,
+  mkdirSync as mkdirSync8,
+  readFileSync as readFileSync9,
+  readdirSync as readdirSync7,
   rmSync as rmSync6,
   symlinkSync as symlinkSync3,
-  writeFileSync as writeFileSync7
+  writeFileSync as writeFileSync8
 } from "node:fs";
-import { dirname as dirname8, isAbsolute as isAbsolute6, join as join11, relative as relative6, resolve as resolve9 } from "node:path";
+import { dirname as dirname8, isAbsolute as isAbsolute6, join as join12, relative as relative6, resolve as resolve9 } from "node:path";
 var ASSERTION_VERSION = "2026-07-25.v1";
 var SHA256 = /^[a-f0-9]{64}$/;
 var COPY_ENTRIES = ["SYSTEM.md", "policy", "skills", "agents", "bundles", "extensions"];
@@ -5749,7 +6270,7 @@ function sha256File(path, label) {
   if (!stat.isFile() || stat.isSymbolicLink()) {
     throw new Error(`pi_trusted_runtime_source_unsafe:${label}`);
   }
-  return createHash7("sha256").update(readFileSync8(path)).digest("hex");
+  return createHash7("sha256").update(readFileSync9(path)).digest("hex");
 }
 function verifyDeclaredFiles(manifest, root, label, ignoredPaths = [], enforceComplete = true) {
   if (!Array.isArray(manifest.files) || manifest.files.length === 0) {
@@ -5771,8 +6292,8 @@ function verifyDeclaredFiles(manifest, root, label, ignoredPaths = [], enforceCo
   if (!enforceComplete) return;
   const ignored = ignoredPaths.map((path) => path.split("\\").join("/"));
   const visit = (directory) => {
-    for (const entry of readdirSync6(directory)) {
-      const filePath = join11(directory, entry);
+    for (const entry of readdirSync7(directory)) {
+      const filePath = join12(directory, entry);
       const relativePath = relative6(root, filePath).split("\\").join("/");
       const stat = lstatSync6(filePath);
       if (stat.isSymbolicLink()) {
@@ -5790,7 +6311,7 @@ function verifyDeclaredFiles(manifest, root, label, ignoredPaths = [], enforceCo
   };
   visit(root);
 }
-function record3(value) {
+function record4(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 function within3(candidate, root) {
@@ -5798,13 +6319,13 @@ function within3(candidate, root) {
   return rel === "" || !rel.startsWith("..") && !isAbsolute6(rel);
 }
 function readJsonFile2(path, label, fallback = {}) {
-  if (!existsSync10(path)) return fallback;
+  if (!existsSync11(path)) return fallback;
   const stat = lstatSync6(path);
   if (!stat.isFile() || stat.isSymbolicLink()) {
     throw new Error(`pi_trusted_runtime_source_unsafe:${label}`);
   }
   try {
-    return JSON.parse(readFileSync8(path, "utf8"));
+    return JSON.parse(readFileSync9(path, "utf8"));
   } catch {
     throw new Error(`pi_trusted_runtime_source_invalid:${label}`);
   }
@@ -5835,29 +6356,29 @@ function copyTreeNoLinks(source, target) {
   const stat = lstatSync6(source);
   if (stat.isSymbolicLink()) throw new Error("pi_trusted_runtime_source_symlink_blocked");
   if (stat.isDirectory()) {
-    mkdirSync7(target, { recursive: true, mode: 448 });
+    mkdirSync8(target, { recursive: true, mode: 448 });
     chmodSync5(target, 448);
-    for (const entry of readdirSync6(source)) {
-      copyTreeNoLinks(join11(source, entry), join11(target, entry));
+    for (const entry of readdirSync7(source)) {
+      copyTreeNoLinks(join12(source, entry), join12(target, entry));
     }
     return;
   }
   if (!stat.isFile()) throw new Error("pi_trusted_runtime_source_type_blocked");
-  mkdirSync7(dirname8(target), { recursive: true, mode: 448 });
+  mkdirSync8(dirname8(target), { recursive: true, mode: 448 });
   copyFileSync2(source, target);
   chmodSync5(target, 384 | stat.mode & 73);
 }
 function mergeMcp(seedRoot, overlayRoot, governedConfig) {
-  const seed = record3(readJsonFile2(join11(seedRoot, "mcp.json"), "seed_mcp", { mcpServers: {} }));
-  const overlay = record3(readJsonFile2(join11(overlayRoot, "mcp.json"), "overlay_mcp", { mcpServers: {} }));
+  const seed = record4(readJsonFile2(join12(seedRoot, "mcp.json"), "seed_mcp", { mcpServers: {} }));
+  const overlay = record4(readJsonFile2(join12(overlayRoot, "mcp.json"), "overlay_mcp", { mcpServers: {} }));
   assertNoPersistentSecrets(seed, ["seed", "mcp.json"]);
   assertNoPersistentSecrets(overlay, ["overlay", "mcp.json"]);
-  const seedServers = record3(seed.mcpServers);
-  const overlayServers = record3(overlay.mcpServers);
+  const seedServers = record4(seed.mcpServers);
+  const overlayServers = record4(overlay.mcpServers);
   if ("amaster" in seedServers || "amaster" in overlayServers) {
     throw new Error("pi_trusted_runtime_reserved_mcp_override:amaster");
   }
-  const governed = record3(record3(governedConfig).mcpServers).amaster;
+  const governed = record4(record4(governedConfig).mcpServers).amaster;
   if (!governed) throw new Error("pi_trusted_runtime_governed_mcp_missing");
   return {
     ...deepMerge(seed, overlay),
@@ -5877,14 +6398,14 @@ function assertEnabledPackagesAvailable(settings, npmRoot) {
   const requiredNames = new Set(
     (Array.isArray(settings.packages) ? settings.packages : []).map(packageName).filter(Boolean)
   );
-  for (const plugin of Object.values(record3(settings.plugins))) {
-    const config = record3(plugin);
+  for (const plugin of Object.values(record4(settings.plugins))) {
+    const config = record4(plugin);
     if (config.enabled === true && typeof config.package === "string") {
       requiredNames.add(config.package);
     }
   }
   for (const name of requiredNames) {
-    const metadataPath = join11(npmRoot, "node_modules", ...name.split("/"), "package.json");
+    const metadataPath = join12(npmRoot, "node_modules", ...name.split("/"), "package.json");
     const metadata = readJsonFile2(metadataPath, `package:${name}`, null);
     if (!metadata || metadata.name !== name) {
       throw new Error(`pi_trusted_runtime_package_unavailable:${name}`);
@@ -5904,44 +6425,44 @@ function materializeTrustedPiRuntimeProfile(input) {
     }
   }
   for (const entry of COPY_ENTRIES) {
-    const target = join11(agentDir, entry);
+    const target = join12(agentDir, entry);
     rmSync6(target, { recursive: true, force: true });
     for (const sourceRoot of [seedRoot, overlayRoot]) {
-      const source = join11(sourceRoot, entry);
-      if (existsSync10(source)) copyTreeNoLinks(source, target);
+      const source = join12(sourceRoot, entry);
+      if (existsSync11(source)) copyTreeNoLinks(source, target);
     }
   }
   const mergedJson = {};
   for (const entry of JSON_ENTRIES) {
-    const seed = readJsonFile2(join11(seedRoot, entry), `seed_${entry}`, {});
-    const overlay = readJsonFile2(join11(overlayRoot, entry), `overlay_${entry}`, {});
+    const seed = readJsonFile2(join12(seedRoot, entry), `seed_${entry}`, {});
+    const overlay = readJsonFile2(join12(overlayRoot, entry), `overlay_${entry}`, {});
     const merged = deepMerge(seed, overlay);
     if (entry === "settings.json") {
       merged["pi-security"] = {
-        ...record3(merged["pi-security"]),
+        ...record4(merged["pi-security"]),
         enabled: true,
         approvals: {
-          ...record3(record3(merged["pi-security"]).approvals),
+          ...record4(record4(merged["pi-security"]).approvals),
           allowSessionGrants: false
         }
       };
     }
     assertNoPersistentSecrets(merged, [entry]);
-    writeFileSync7(join11(agentDir, entry), `${JSON.stringify(merged, null, 2)}
+    writeFileSync8(join12(agentDir, entry), `${JSON.stringify(merged, null, 2)}
 `, {
       mode: 384
     });
-    chmodSync5(join11(agentDir, entry), 384);
+    chmodSync5(join12(agentDir, entry), 384);
     mergedJson[entry] = merged;
   }
   const governedConfig = readJsonFile2(input.governedMcpConfigPath, "governed_mcp");
   const mcp = mergeMcp(seedRoot, overlayRoot, governedConfig);
-  writeFileSync7(input.governedMcpConfigPath, `${JSON.stringify(mcp, null, 2)}
+  writeFileSync8(input.governedMcpConfigPath, `${JSON.stringify(mcp, null, 2)}
 `, { mode: 384 });
   chmodSync5(input.governedMcpConfigPath, 384);
-  const npmRoot = join11(seedRoot, "npm");
+  const npmRoot = join12(seedRoot, "npm");
   assertEnabledPackagesAvailable(mergedJson["settings.json"], npmRoot);
-  const npmTarget = join11(agentDir, "npm");
+  const npmTarget = join12(agentDir, "npm");
   rmSync6(npmTarget, { recursive: true, force: true });
   const npmStat = lstatSync6(npmRoot);
   if (!npmStat.isDirectory() || npmStat.isSymbolicLink()) {
@@ -5986,13 +6507,13 @@ function readTrustedPiRuntimeAudit(input) {
   const profileRoot = resolve9(requiredString3(input.profileRoot, "profileRoot"));
   const auditFile = resolve9(requiredString3(input.auditFile, "auditFile"));
   if (!within3(auditFile, profileRoot)) throw new Error("pi_trusted_runtime_audit_path_escape");
-  if (!existsSync10(auditFile)) throw new Error("pi_trusted_runtime_audit_startup_missing");
+  if (!existsSync11(auditFile)) throw new Error("pi_trusted_runtime_audit_startup_missing");
   const stat = lstatSync6(auditFile);
   if (!stat.isFile() || stat.isSymbolicLink()) {
     throw new Error("pi_trusted_runtime_audit_unsafe");
   }
   if (stat.size > MAX_AUDIT_BYTES) throw new Error("pi_trusted_runtime_audit_too_large");
-  const lines = readFileSync8(auditFile, "utf8").split("\n").filter(Boolean);
+  const lines = readFileSync9(auditFile, "utf8").split("\n").filter(Boolean);
   if (lines.length === 0 || lines.length > MAX_AUDIT_EVENTS) {
     throw new Error("pi_trusted_runtime_audit_event_count_invalid");
   }
@@ -6049,11 +6570,11 @@ function readTrustedPiRuntimeLocalDigests(input) {
       throw new Error(`pi_trusted_runtime_source_unsafe:${label}`);
     }
   }
-  const seedManifestFile = join11(seedRoot, "seed-manifest.json");
-  const overlayManifestFile = join11(overlayRoot, "runtime-overlay-manifest.json");
-  const seedManifest = JSON.parse(readFileSync8(seedManifestFile, "utf8"));
-  const overlayManifest = JSON.parse(readFileSync8(overlayManifestFile, "utf8"));
-  const policyManifest = JSON.parse(readFileSync8(policyFile, "utf8"));
+  const seedManifestFile = join12(seedRoot, "seed-manifest.json");
+  const overlayManifestFile = join12(overlayRoot, "runtime-overlay-manifest.json");
+  const seedManifest = JSON.parse(readFileSync9(seedManifestFile, "utf8"));
+  const overlayManifest = JSON.parse(readFileSync9(overlayManifestFile, "utf8"));
+  const policyManifest = JSON.parse(readFileSync9(policyFile, "utf8"));
   verifyDeclaredFiles(seedManifest, seedRoot, "seed", [
     "seed-manifest.json",
     "npm/package-lock.json",
@@ -6157,8 +6678,8 @@ function verifyTrustedPiRuntimeAssertion(input) {
 // src/amaster-runtime-daemon/workspace-status.mjs
 import { spawnSync as spawnSync4 } from "node:child_process";
 import { createHash as createHash8 } from "node:crypto";
-import { existsSync as existsSync11, readdirSync as readdirSync7, readFileSync as readFileSync9, statSync as statSync6 } from "node:fs";
-import { basename as basename5, extname, isAbsolute as isAbsolute7, join as join12, relative as relative7, resolve as resolve10 } from "node:path";
+import { existsSync as existsSync12, readdirSync as readdirSync8, readFileSync as readFileSync10, statSync as statSync6 } from "node:fs";
+import { basename as basename5, extname, isAbsolute as isAbsolute7, join as join13, relative as relative7, resolve as resolve10 } from "node:path";
 var WORKSPACE_RUNTIME_SERVICES_FILENAME = ".amaster-runtime-services.json";
 var ARTIFACT_EXTENSIONS = /* @__PURE__ */ new Map([
   [".md", "markdown"],
@@ -6227,7 +6748,7 @@ function sanitizeTrackedChange(line) {
   return isSafeRelativePath(path) ? line : null;
 }
 function sha256File2(filePath) {
-  return createHash8("sha256").update(readFileSync9(filePath)).digest("hex");
+  return createHash8("sha256").update(readFileSync10(filePath)).digest("hex");
 }
 function artifactHashCacheKey(relativePath, stat) {
   return `${relativePath}\0${stat.size}\0${stat.mtimeMs}`;
@@ -6265,7 +6786,7 @@ function scanArtifactCandidates(cwd, opts = {}) {
     const current = stack.pop();
     let entries;
     try {
-      entries = readdirSync7(current, { withFileTypes: true });
+      entries = readdirSync8(current, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -6276,7 +6797,7 @@ function scanArtifactCandidates(cwd, opts = {}) {
       if (entry.name.startsWith(".") && entry.name !== ".amaster-runtime.json") {
         if (entry.name === ".git") continue;
       }
-      const fullPath = join12(current, entry.name);
+      const fullPath = join13(current, entry.name);
       const relativePath = normalizeRelativePath(root, fullPath);
       if (!isSafeRelativePath(relativePath)) continue;
       if (basename5(relativePath) === ".amaster-runtime.json") continue;
@@ -6355,10 +6876,10 @@ function sanitizeRuntimeService(entry) {
   };
 }
 function readRuntimeServicesSnapshot(cwd) {
-  const snapshotPath = join12(resolve10(cwd), WORKSPACE_RUNTIME_SERVICES_FILENAME);
-  if (!existsSync11(snapshotPath)) return [];
+  const snapshotPath = join13(resolve10(cwd), WORKSPACE_RUNTIME_SERVICES_FILENAME);
+  if (!existsSync12(snapshotPath)) return [];
   try {
-    const parsed = JSON.parse(readFileSync9(snapshotPath, "utf8"));
+    const parsed = JSON.parse(readFileSync10(snapshotPath, "utf8"));
     const rawServices = Array.isArray(parsed) ? parsed : Array.isArray(parsed?.services) ? parsed.services : [];
     return rawServices.map((entry) => sanitizeRuntimeService(entry)).filter((entry) => entry !== null).slice(0, 50);
   } catch {
@@ -7199,7 +7720,7 @@ async function executeSourceReadCommand(commandInput, dependencies = {}) {
 // src/amaster-runtime-daemon/browser-session-broker.mjs
 import { createHash as createHash11 } from "node:crypto";
 import { spawnSync as spawnSync5 } from "node:child_process";
-import { existsSync as existsSync12 } from "node:fs";
+import { existsSync as existsSync13 } from "node:fs";
 import {
   chmod,
   lstat,
@@ -7211,7 +7732,7 @@ import {
   rm,
   writeFile
 } from "node:fs/promises";
-import { join as join13, relative as relative8, resolve as resolve11, sep as sep2 } from "node:path";
+import { join as join14, relative as relative8, resolve as resolve11, sep as sep2 } from "node:path";
 
 // src/amaster-runtime-daemon/playwright-source-browser.mjs
 var LOGIN_CONTROL_SELECTORS = Object.freeze([
@@ -7403,7 +7924,7 @@ function sha2562(value) {
   return createHash11("sha256").update(value, "utf8").digest("hex");
 }
 function configuredBrowserExecutableReady(executablePath) {
-  if (!executablePath || !existsSync12(executablePath)) return false;
+  if (!executablePath || !existsSync13(executablePath)) return false;
   const probe = spawnSync5(executablePath, ["--version"], {
     encoding: "utf8",
     env: { PATH: process.env.PATH ?? "" },
@@ -7462,7 +7983,7 @@ function assertWithinRoot(root, target) {
   }
 }
 async function readMarker(profilePath) {
-  const markerPath = join13(profilePath, MARKER_NAME);
+  const markerPath = join14(profilePath, MARKER_NAME);
   const metadata = await pathStat(markerPath, true);
   if (!metadata || !metadata.isFile() || metadata.isSymbolicLink()) {
     fail3("browser_session_profile_owner_mismatch");
@@ -7489,7 +8010,7 @@ async function verifyOwnedProfile(root, profilePath, identity2) {
   return true;
 }
 async function writeMarker(profilePath, identity2) {
-  const markerPath = join13(profilePath, MARKER_NAME);
+  const markerPath = join14(profilePath, MARKER_NAME);
   const temporaryPath = `${markerPath}.tmp-${process.pid}-${Date.now()}`;
   try {
     await writeFile(temporaryPath, `${JSON.stringify(expectedMarker(identity2))}
@@ -7503,7 +8024,7 @@ async function writeMarker(profilePath, identity2) {
   }
 }
 async function ensureOwnedProfile(root, identity2) {
-  const profilePath = join13(root, profileName(identity2));
+  const profilePath = join14(root, profileName(identity2));
   const exists = await verifyOwnedProfile(root, profilePath, identity2);
   if (exists) return { profilePath, reusedProfile: true };
   await mkdir(profilePath, { mode: 448 });
@@ -7514,13 +8035,13 @@ async function ensureOwnedProfile(root, identity2) {
 }
 async function assertNoSymlinks(path) {
   for (const entry of await readdir(path, { withFileTypes: true })) {
-    const entryPath = join13(path, entry.name);
+    const entryPath = join14(path, entry.name);
     if (entry.isSymbolicLink()) fail3("browser_session_profile_symlink_forbidden");
     if (entry.isDirectory()) await assertNoSymlinks(entryPath);
   }
 }
 async function removeOwnedProfile(root, identity2) {
-  const profilePath = join13(root, profileName(identity2));
+  const profilePath = join14(root, profileName(identity2));
   if (!await verifyOwnedProfile(root, profilePath, identity2)) return false;
   await assertNoSymlinks(profilePath);
   await rm(profilePath, { recursive: true });
@@ -7569,7 +8090,7 @@ function createBrowserSessionBroker(options) {
   const cancelTimeout = typeof options.clearTimeout === "function" ? options.clearTimeout : clearTimeout;
   const rootPromise = (async () => {
     const stateRoot = await ensureProtectedDirectory(resolve11(options.stateRoot));
-    return ensureProtectedDirectory(join13(stateRoot, "browser-sessions"));
+    return ensureProtectedDirectory(join14(stateRoot, "browser-sessions"));
   })();
   const sessions = /* @__PURE__ */ new Map();
   async function closeBinding(bindingId) {
@@ -7793,7 +8314,7 @@ function createBrowserSessionBroker(options) {
       }
     } else {
       const root = await rootPromise;
-      const profilePath = join13(root, profileName(input));
+      const profilePath = join14(root, profileName(input));
       if (!await verifyOwnedProfile(root, profilePath, input)) {
         fail3("browser_session_profile_missing");
       }
@@ -7862,7 +8383,7 @@ function createBrowserSessionBroker(options) {
       }
       if (!browserExecutablePath && typeof playwright.chromium.executablePath === "function") {
         const executablePath = playwright.chromium.executablePath();
-        if (!executablePath || !existsSync12(executablePath)) {
+        if (!executablePath || !existsSync13(executablePath)) {
           return { ready: false, reason: "chrome_unavailable" };
         }
       }
@@ -8145,7 +8666,7 @@ function createPublicNetworkScope(options = {}) {
 }
 
 // src/amaster-runtime-daemon.mjs
-var CONNECTOR_VERSION = "0.1.0-beta.49";
+var CONNECTOR_VERSION = "0.1.0-beta.50";
 var CONNECTOR_CONTRACT_VERSION = "2026-06-04.v1";
 var MAX_CHECKPOINT_BYTES = 20 * 1024 * 1024;
 var CHECKPOINT_TTL_MS = 24 * 60 * 60 * 1e3;
@@ -8160,6 +8681,8 @@ var PI_COMPLETION_OUTPUT_TYPES = /* @__PURE__ */ new Set(["agent_end", "approval
 var PROCESS_GROUP_RSS_SAMPLE_MIN_INTERVAL_MS = 5e3;
 var activeRunCommands = /* @__PURE__ */ new Map();
 var pendingResultOutboxRunCommands = /* @__PURE__ */ new Map();
+var pendingRunCompletionCommands = /* @__PURE__ */ new Map();
+var runCompletionFlights = /* @__PURE__ */ new Map();
 var localDispatchCommandIds = /* @__PURE__ */ new Set();
 var workspaceStatusHashCache = /* @__PURE__ */ new Map();
 var processGroupRssSampleCache = null;
@@ -8194,9 +8717,9 @@ function configuredBrowserExecutablePath(config) {
     process.platform === "linux" ? "/usr/bin/google-chrome" : null,
     process.platform === "linux" ? "/usr/bin/chromium" : null,
     process.platform === "linux" ? "/usr/bin/chromium-browser" : null,
-    process.platform === "win32" && process.env.PROGRAMFILES ? join14(process.env.PROGRAMFILES, "Google", "Chrome", "Application", "chrome.exe") : null
+    process.platform === "win32" && process.env.PROGRAMFILES ? join15(process.env.PROGRAMFILES, "Google", "Chrome", "Application", "chrome.exe") : null
   ].filter(Boolean);
-  return candidates.find((candidate) => existsSync13(candidate)) ?? explicit ?? null;
+  return candidates.find((candidate) => existsSync14(candidate)) ?? explicit ?? null;
 }
 function runtimeBrowserSessionBroker(config) {
   const executablePath = configuredBrowserExecutablePath(config);
@@ -8243,11 +8766,11 @@ function updateActiveRunWorkspaceManifest(commandId, manifestPath, patch = {}) {
 }
 function resultOutboxPendingCount(config) {
   const dir = resultOutboxDir(config);
-  if (!existsSync13(dir)) return 0;
+  if (!existsSync14(dir)) return 0;
   try {
     let pending = 0;
-    for (const file of readdirSync8(dir).filter((name) => name.endsWith(".json"))) {
-      if (readValidResultOutboxEntryOrQuarantine(config, file, join14(dir, file))) {
+    for (const file of readdirSync9(dir).filter((name) => name.endsWith(".json"))) {
+      if (readValidResultOutboxEntryOrQuarantine(config, file, join15(dir, file))) {
         pending += 1;
       }
     }
@@ -8256,6 +8779,63 @@ function resultOutboxPendingCount(config) {
     return 0;
   }
 }
+function runCompletionStateDir(config) {
+  const explicit = readString(process.env.AMASTER_RUN_COMPLETION_STATE_DIR);
+  if (explicit) return resolve12(expandHomePath(explicit));
+  return join15(dirname9(stateFilePath(process.env)), "run-completion-state");
+}
+function runCompletionStateInvalidDir(config) {
+  return join15(runCompletionStateDir(config), "invalid");
+}
+function quarantineInvalidRunCompletionState(config, filePath, reason) {
+  const invalidDir = runCompletionStateInvalidDir(config);
+  mkdirSync9(invalidDir, { recursive: true, mode: 448 });
+  const destination = join15(invalidDir, basename6(filePath));
+  try {
+    renameSync6(filePath, destination);
+  } catch {
+    copyFileSync3(filePath, destination);
+    unlinkSync2(filePath);
+  }
+  process.stderr.write(`AMaster daemon quarantined invalid run completion state ${basename6(filePath)}: ${reason}
+`);
+}
+function readValidRunCompletionStateOrQuarantine(config, filePath) {
+  try {
+    return readRunCompletionState(filePath);
+  } catch (error) {
+    quarantineInvalidRunCompletionState(
+      config,
+      filePath,
+      error instanceof Error ? error.message : String(error)
+    );
+    return null;
+  }
+}
+function runCompletionStateEntries(config) {
+  return listRunCompletionStateFiles(runCompletionStateDir(config)).map((filePath) => ({ filePath, state: readValidRunCompletionStateOrQuarantine(config, filePath) })).filter((entry) => entry.state !== null);
+}
+function runCompletionStatePendingCount(config) {
+  return runCompletionStateEntries(config).length;
+}
+function runCompletionStateActiveRunCommands(config) {
+  const pending = runCompletionStatePendingCount(config);
+  return runCompletionStateEntries(config).map(({ state }) => {
+    const executor = asRecord(state.executor);
+    const execution = asRecord(executor.closureExecution);
+    const command = asRecord(state.command);
+    return {
+      commandId: state.commandId,
+      ...readString(commandRunId(command)) ? { runId: readString(commandRunId(command)) } : {},
+      ...readString(commandIssueId(command)) ? { issueId: readString(commandIssueId(command)) } : {},
+      ...readString(executor.kind) ? { executorKind: readString(executor.kind) } : {},
+      ...readString(execution.cwd) ? { workspacePath: readString(execution.cwd) } : {},
+      phase: state.phase,
+      outboxPending: pending,
+      ...readString(state.updatedAt) ? { executorCompletedAt: readString(state.updatedAt) } : {}
+    };
+  });
+}
 function piCompletionOutputType(event) {
   const type = readString(asRecord(event).type);
   if (PI_COMPLETION_OUTPUT_TYPES.has(type ?? "")) return type;
@@ -8263,11 +8843,11 @@ function piCompletionOutputType(event) {
 }
 function resultOutboxActiveRunCommands(config) {
   const dir = resultOutboxDir(config);
-  if (!existsSync13(dir)) return [];
+  if (!existsSync14(dir)) return [];
   const outboxPending = resultOutboxPendingCount(config);
   const entries = [];
-  for (const file of readdirSync8(dir).filter((name) => name.endsWith(".json")).sort()) {
-    const entry = readValidResultOutboxEntryOrQuarantine(config, file, join14(dir, file));
+  for (const file of readdirSync9(dir).filter((name) => name.endsWith(".json")).sort()) {
+    const entry = readValidResultOutboxEntryOrQuarantine(config, file, join15(dir, file));
     if (!entry) continue;
     const activeRun = asRecord(entry.activeRun);
     const commandId = readString(activeRun.commandId) ?? readString(entry.commandId);
@@ -8297,12 +8877,12 @@ function resultOutboxActiveRunCommands(config) {
 }
 function resultOutboxFailedRunCommands(config) {
   const dir = resultOutboxInvalidDir(config);
-  if (!existsSync13(dir)) return [];
+  if (!existsSync14(dir)) return [];
   const entries = [];
-  for (const file of readdirSync8(dir).filter((name) => name.endsWith(".json")).sort().slice(-100)) {
+  for (const file of readdirSync9(dir).filter((name) => name.endsWith(".json")).sort().slice(-100)) {
     let entry;
     try {
-      entry = asRecord(JSON.parse(readFileSync10(join14(dir, file), "utf8")));
+      entry = asRecord(JSON.parse(readFileSync11(join15(dir, file), "utf8")));
     } catch {
       continue;
     }
@@ -8366,7 +8946,7 @@ function safeExpandPath(value) {
 }
 function safeJsonObjectFromFile(filePath) {
   try {
-    const parsed = JSON.parse(readFileSync10(filePath, "utf8"));
+    const parsed = JSON.parse(readFileSync11(filePath, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
@@ -8383,7 +8963,7 @@ function safeDirectorySummary(pathValue) {
     }
     let entryCount = 0;
     let truncated = false;
-    for (const name of readdirSync8(pathValue)) {
+    for (const name of readdirSync9(pathValue)) {
       if (name.startsWith(".")) continue;
       entryCount += 1;
       if (entryCount >= MAX_PI_CAPABILITY_SOURCE_ENTRIES) {
@@ -8407,12 +8987,12 @@ function safeSkillRootSummary(kind, source, pathValue) {
   let truncated = false;
   if (directory.available && pathValue) {
     try {
-      for (const name of readdirSync8(pathValue)) {
+      for (const name of readdirSync9(pathValue)) {
         if (name.startsWith(".")) continue;
-        const skillDir = join14(pathValue, name);
+        const skillDir = join15(pathValue, name);
         try {
           if (!statSync7(skillDir).isDirectory()) continue;
-          if (!existsSync13(join14(skillDir, "SKILL.md"))) continue;
+          if (!existsSync14(join15(skillDir, "SKILL.md"))) continue;
           skillCount += 1;
           if (skillCount >= MAX_PI_CAPABILITY_SOURCE_ENTRIES) {
             truncated = true;
@@ -8463,7 +9043,7 @@ function objectKeyCount(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? Object.keys(value).length : 0;
 }
 function defaultPiCodingAgentDir() {
-  return join14(homedir3(), ".pi", "agent");
+  return join15(homedir3(), ".pi", "agent");
 }
 function piCapabilitySourcesDiagnostics() {
   const configuredPiCodingAgentDir = safeExpandPath(process.env.PI_CODING_AGENT_DIR);
@@ -8472,14 +9052,14 @@ function piCapabilitySourcesDiagnostics() {
   const configuredPiAgentHome = safeExpandPath(process.env.PI_AGENT_HOME);
   const piAgentHome = configuredPiAgentHome ?? piCodingAgentDir;
   const piAgentHomeSource = configuredPiAgentHome ? "PI_AGENT_HOME" : piCodingAgentDirSource;
-  const userSkillsPath = piAgentHome ? join14(piAgentHome, "skills") : null;
+  const userSkillsPath = piAgentHome ? join15(piAgentHome, "skills") : null;
   const configuredMarketplaceSkillsPath = safeExpandPath(
     process.env.PI_AGENT_MARKETPLACE_SKILLS_DIR
   );
-  const marketplaceSkillsPath = configuredMarketplaceSkillsPath ?? (piAgentHome ? join14(piAgentHome, "marketplace", "skills") : null);
+  const marketplaceSkillsPath = configuredMarketplaceSkillsPath ?? (piAgentHome ? join15(piAgentHome, "marketplace", "skills") : null);
   const builtinSkillsPath = safeExpandPath(process.env.PI_AGENT_BUILTIN_SKILLS_DIR) ?? safeExpandPath(process.env.AMASTER_BUILTIN_SKILLS);
-  const mcpConfigPath = safeExpandPath(process.env.PI_AGENT_MCP_SERVERS_FILE) ?? (piAgentHome ? join14(piAgentHome, "mcp.json") : null);
-  const settingsConfigPath = piCodingAgentDir ? join14(piCodingAgentDir, "settings.json") : null;
+  const mcpConfigPath = safeExpandPath(process.env.PI_AGENT_MCP_SERVERS_FILE) ?? (piAgentHome ? join15(piAgentHome, "mcp.json") : null);
+  const settingsConfigPath = piCodingAgentDir ? join15(piCodingAgentDir, "settings.json") : null;
   const skillRoots = [
     safeSkillRootSummary("user", `${piAgentHomeSource}/skills`, userSkillsPath),
     safeSkillRootSummary(
@@ -8664,6 +9244,8 @@ function buildHeartbeatPayload(config, options = {}) {
     ...Array.from(localDispatchCommandIds, (commandId) => ({ commandId, phase: "preparing" })),
     ...Array.from(activeRunCommands.values()),
     ...Array.from(pendingResultOutboxRunCommands.values()),
+    ...Array.from(pendingRunCompletionCommands.values()),
+    ...runCompletionStateActiveRunCommands(config),
     ...resultOutboxFailedRunCommands(config),
     ...resultOutboxActiveRunCommands(config)
   ]) {
@@ -8725,10 +9307,10 @@ function piAgentSystemDataDir(config) {
   return configured ? resolve12(expandHomePath(configured)) : null;
 }
 function readPiAgentLocalPlatformCredential(credentialsDir) {
-  const pointer = readJsonFile3(join14(credentialsDir, "latest.json"));
+  const pointer = readJsonFile3(join15(credentialsDir, "latest.json"));
   const credentialRef = readString(pointer.credentialRef);
   if (!credentialRef || !/^[a-f0-9]{64}$/i.test(credentialRef)) return null;
-  const credential = readJsonFile3(join14(credentialsDir, `${credentialRef}.json`));
+  const credential = readJsonFile3(join15(credentialsDir, `${credentialRef}.json`));
   const organizationId = readString(credential.organizationId);
   const apiKey = readString(credential.apiKey);
   if (credential.version !== 1 || !organizationId || !apiKey) return null;
@@ -8744,17 +9326,17 @@ function piAgentLocalPlatformCredentials(config) {
   if (!piAgentLocalPlatformRunnerEnabled(config)) return [];
   const systemDataDir = piAgentSystemDataDir(config);
   if (!systemDataDir) return [];
-  const companiesDir = join14(systemDataDir, "companies");
+  const companiesDir = join15(systemDataDir, "companies");
   let entries = [];
   try {
-    entries = readdirSync8(companiesDir, { withFileTypes: true });
+    entries = readdirSync9(companiesDir, { withFileTypes: true });
   } catch {
     return [];
   }
   const credentialsByOrganizationId = /* @__PURE__ */ new Map();
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const credential = readPiAgentLocalPlatformCredential(join14(companiesDir, entry.name, "model-credentials"));
+    const credential = readPiAgentLocalPlatformCredential(join15(companiesDir, entry.name, "model-credentials"));
     if (credential) credentialsByOrganizationId.set(credential.organizationId, credential);
   }
   return [...credentialsByOrganizationId.values()];
@@ -8928,7 +9510,7 @@ AMASTER_WORKSPACE_ALLOWLIST=${quoteShell(config.workspaceBindings.join(","))}
 AMASTER_EXECUTORS=${quoteShell(executorEnv)}
 AMASTER_CAPABILITIES=${quoteShell(config.capabilities.join(","))}
 AMASTER_NETWORK_DOMAINS=${quoteShell(config.networkDomains.join(","))}
-AMASTER_DAEMON_STATE_FILE=${quoteShell(join14(homedir3(), ".amaster-employee", "runtime-connector-state.json"))}
+AMASTER_DAEMON_STATE_FILE=${quoteShell(join15(homedir3(), ".amaster-employee", "runtime-connector-state.json"))}
 EOF
 
 set -a
@@ -8982,17 +9564,19 @@ function maxConcurrentCommands(config) {
   const configured = Number(config.maxConcurrentCommands);
   return Number.isInteger(configured) && configured > 0 ? Math.min(configured, 50) : 1;
 }
-function activeRunCommandCount(options = {}) {
+function activeRunCommandCount(config, options = {}) {
   const excludeCommandIds = new Set(readStringArray(options.excludeCommandIds));
   const commandIds = new Set([
     ...activeRunCommands.keys(),
     ...pendingResultOutboxRunCommands.keys(),
+    ...pendingRunCompletionCommands.keys(),
+    ...runCompletionStateEntries(config).map(({ state }) => state.commandId),
     ...localDispatchCommandIds
   ].filter((commandId) => !excludeCommandIds.has(commandId)));
   return commandIds.size;
 }
 function availableCommandSlots(config) {
-  return Math.max(0, maxConcurrentCommands(config) - activeRunCommandCount());
+  return Math.max(0, maxConcurrentCommands(config) - activeRunCommandCount(config));
 }
 function rememberActiveRunCommand(command, metadata) {
   const commandId = readString(command.commandId) ?? readString(command.id);
@@ -9116,10 +9700,10 @@ function buildActiveRunCommandStatus(config, entry) {
   const base = {
     ...entry,
     phase: readString(entry.phase) ?? "executing",
-    managedWorkdirPresent: entry.workspacePath ? existsSync13(entry.workspacePath) : false,
+    managedWorkdirPresent: entry.workspacePath ? existsSync14(entry.workspacePath) : false,
     outboxPending: resultOutboxPendingCount(config)
   };
-  if (!entry.workspacePath || !existsSync13(entry.workspacePath)) return base;
+  if (!entry.workspacePath || !existsSync14(entry.workspacePath)) return base;
   const manifestPath = entry.manifestPath ?? workspaceManifestPath(entry.workspacePath);
   const status = readWorkspaceStatus(entry.workspacePath, { hashCache: workspaceStatusHashCache });
   const artifactCandidates = status.artifacts.slice(0, 20);
@@ -9300,7 +9884,7 @@ function trustedPiRuntimeSources(config) {
 }
 function readJsonFile3(filePath) {
   try {
-    const parsed = JSON.parse(readFileSync10(filePath, "utf8"));
+    const parsed = JSON.parse(readFileSync11(filePath, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
   } catch {
     return {};
@@ -9387,8 +9971,8 @@ async function materializeAgentInstructionsBundle(config, command, workspace) {
     if (!content) continue;
     const target = safeAgentInstructionMaterializationTarget(workspace, filePath);
     if (!target) continue;
-    mkdirSync8(dirname9(target.targetPath), { recursive: true });
-    writeFileSync8(target.targetPath, content, "utf8");
+    mkdirSync9(dirname9(target.targetPath), { recursive: true });
+    writeFileSync9(target.targetPath, content, "utf8");
     materialized.push({
       path: target.relativePath,
       byteSize: Buffer.byteLength(content, "utf8")
@@ -9459,14 +10043,14 @@ function companyPiHomeRoot(baseEnv) {
   const explicitRoot = readString(baseEnv.AMASTER_COMPANY_PI_HOME_ROOT);
   if (explicitRoot) return resolve12(expandHomePath(explicitRoot));
   const configuredPiHome = readString(baseEnv.PI_AGENT_HOME) ?? readString(baseEnv.PI_CODING_AGENT_DIR);
-  if (configuredPiHome) return join14(dirname9(resolve12(expandHomePath(configuredPiHome))), "companies");
-  return join14(homedir3(), ".amaster-employee", "companies");
+  if (configuredPiHome) return join15(dirname9(resolve12(expandHomePath(configuredPiHome))), "companies");
+  return join15(homedir3(), ".amaster-employee", "companies");
 }
 function companyPiAgentHome(baseEnv, companyId) {
   const rawCompanyId = readString(companyId);
   if (!rawCompanyId) return null;
   const segment = safeCompanyPiHomeSegment(rawCompanyId);
-  return join14(companyPiHomeRoot(baseEnv), segment, ".pi");
+  return join15(companyPiHomeRoot(baseEnv), segment, ".pi");
 }
 function commandUsesPiExecutor(command) {
   return readString(asRecord(command.payload).executorKind) === "pi";
@@ -9534,7 +10118,7 @@ function resolveNativeSessionRequest(command, workspace) {
   let cwdMatched = false;
   if (requestedCwd && sourceWorkspacePath) {
     try {
-      cwdMatched = realpathSync4(requestedCwd) === realpathSync4(sourceWorkspacePath);
+      cwdMatched = realpathSync5(requestedCwd) === realpathSync5(sourceWorkspacePath);
     } catch {
       cwdMatched = resolve12(requestedCwd) === resolve12(sourceWorkspacePath);
     }
@@ -9979,16 +10563,16 @@ function sampleProcessGroupRssBytes(processGroupId) {
 }
 function realOrResolvedPath(value) {
   try {
-    return realpathSync4(value);
+    return realpathSync5(value);
   } catch {
     return resolve12(value);
   }
 }
-var LSOF_COMMAND = process.platform === "darwin" && existsSync13("/usr/sbin/lsof") ? "/usr/sbin/lsof" : "lsof";
+var LSOF_COMMAND = process.platform === "darwin" && existsSync14("/usr/sbin/lsof") ? "/usr/sbin/lsof" : "lsof";
 function processCwdForPid(pid) {
   if (process.platform === "linux") {
     try {
-      return realpathSync4(`/proc/${pid}/cwd`);
+      return realpathSync5(`/proc/${pid}/cwd`);
     } catch {
       return null;
     }
@@ -10010,7 +10594,7 @@ function allProcessCwdsByPid() {
   if (process.platform === "linux") {
     const procEntries = (() => {
       try {
-        return readdirSync8("/proc", { withFileTypes: true });
+        return readdirSync9("/proc", { withFileTypes: true });
       } catch {
         return [];
       }
@@ -10106,21 +10690,21 @@ function killWorkspaceResidentProcesses(cwd, processGroupId, options = {}) {
 }
 function walkManagedWorkdirs(root) {
   const workdirs = [];
-  if (!root || !existsSync13(root)) return workdirs;
+  if (!root || !existsSync14(root)) return workdirs;
   const stack = [root];
   while (stack.length > 0) {
     const current = stack.pop();
     if (!current) continue;
     let entries = [];
     try {
-      entries = readdirSync8(current, { withFileTypes: true });
+      entries = readdirSync9(current, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const fullPath = join14(current, entry.name);
-      if (entry.name === "workdir" && existsSync13(workspaceManifestPath(fullPath))) {
+      const fullPath = join15(current, entry.name);
+      if (entry.name === "workdir" && existsSync14(workspaceManifestPath(fullPath))) {
         workdirs.push(fullPath);
         continue;
       }
@@ -10525,6 +11109,874 @@ async function ingestCost(config, command, executor, parsed) {
     costCents: parsedUsageCostCents(parsed.usage)
   });
 }
+function pendingRunCompletionSnapshot(config, state) {
+  const command = asRecord(state.command);
+  const executor = asRecord(state.executor);
+  const execution = asRecord(executor.closureExecution);
+  return {
+    commandId: state.commandId,
+    ...readString(commandRunId(command)) ? { runId: readString(commandRunId(command)) } : {},
+    ...readString(commandIssueId(command)) ? { issueId: readString(commandIssueId(command)) } : {},
+    ...readString(executor.kind) ? { executorKind: readString(executor.kind) } : {},
+    ...readString(execution.cwd) ? { workspacePath: readString(execution.cwd) } : {},
+    phase: state.phase,
+    outboxPending: runCompletionStatePendingCount(config),
+    ...readString(state.updatedAt) ? { executorCompletedAt: readString(state.updatedAt) } : {}
+  };
+}
+function persistPendingRunCompletion(config, state) {
+  writeRunCompletionState(runCompletionStateDir(config), state);
+  pendingRunCompletionCommands.set(state.commandId, pendingRunCompletionSnapshot(config, state));
+  return state;
+}
+function clearPendingRunCompletion(config, commandId) {
+  removeRunCompletionState(runCompletionStateDir(config), commandId);
+  pendingRunCompletionCommands.delete(commandId);
+}
+function completionCheckRetryable(error) {
+  const status = Number(error?.httpStatus);
+  const code = runtimeConnectorErrorCode(error) ?? readString(error?.code);
+  if (code === "runtime_completion_check_response_invalid") return false;
+  if (!Number.isInteger(status)) return true;
+  if (status === 401 || status === 408 || status === 429 || status >= 500) return true;
+  if (status !== 409) return false;
+  return !code || [
+    "runtime_completion_check_command_race",
+    "runtime_completion_check_command_not_acknowledged"
+  ].includes(code);
+}
+function runtimeConnectorErrorCode(error) {
+  const body = asRecord(error?.responseBody);
+  const details = asRecord(body.details);
+  return readString(details.code) ?? readString(body.code);
+}
+function terminalCommandStatusFromCompletionCheckError(error) {
+  if (runtimeConnectorErrorCode(error) !== "runtime_completion_check_command_not_acknowledged") {
+    return null;
+  }
+  const details = asRecord(asRecord(error?.responseBody).details);
+  const status = readString(details.status);
+  return ["succeeded", "failed", "cancelled"].includes(status ?? "") ? status : null;
+}
+function managedMcpCleanupOwnerMismatch(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /^(?:pi|codex)_managed_mcp_cleanup_owner_mismatch:/.test(message);
+}
+async function probeTerminalCommandAfterUnsafeCleanup(config, state) {
+  const path = `/api/amaster/runtime-connectors/${state.connectorId}/commands/${state.commandId}/completion-check`;
+  try {
+    await postJson(config, path, runCompletionCheckRequest(state));
+    return null;
+  } catch (error) {
+    const terminalStatus = terminalCommandStatusFromCompletionCheckError(error);
+    if (terminalStatus) return terminalStatus;
+    throw error;
+  }
+}
+function runCompletionCheckRequest(state) {
+  const prior = asRecord(state.completionRequest);
+  return {
+    contractVersion: "amaster.runtime-connector.completion-check.v1",
+    ...readString(asRecord(state.command).leaseId) ? { leaseId: readString(asRecord(state.command).leaseId) } : {},
+    proposedStatus: state.candidateStatus,
+    resultSignals: {
+      productiveSuccessfulRun: prior.resultSignals?.productiveSuccessfulRun === true,
+      executorTurnCount: state.closureAttempt === 1 ? 2 : 1,
+      closureAttempt: state.closureAttempt === 1 ? 1 : 0
+    }
+  };
+}
+function runCompletionCheckMaxAttempts() {
+  return Math.max(1, Math.min(5, parsePositiveInteger(
+    process.env.AMASTER_COMPLETION_CHECK_MAX_ATTEMPTS,
+    3
+  )));
+}
+function runCompletionCheckRetryDelayMs() {
+  return Math.max(0, Math.min(5e3, parseNonNegativeInteger(
+    process.env.AMASTER_COMPLETION_CHECK_RETRY_DELAY_MS,
+    100
+  )));
+}
+function runCompletionPhaseMaxAttempts() {
+  return Math.max(1, Math.min(100, parsePositiveInteger(
+    process.env.AMASTER_RUN_COMPLETION_PHASE_MAX_ATTEMPTS,
+    10
+  )));
+}
+function runCompletionMaxAgeMs() {
+  return parsePositiveInteger(
+    process.env.AMASTER_RUN_COMPLETION_MAX_AGE_SECONDS,
+    7 * 24 * 60 * 60
+  ) * 1e3;
+}
+function runCompletionStateAgeExceeded(state, nowMs = Date.now()) {
+  const createdAtMs = Date.parse(readString(state.createdAt) ?? "");
+  return Number.isFinite(createdAtMs) && nowMs - createdAtMs > runCompletionMaxAgeMs();
+}
+function runCompletionPhaseExhausted(state, nextAttemptCount) {
+  return nextAttemptCount >= runCompletionPhaseMaxAttempts() || runCompletionStateAgeExceeded(state);
+}
+function failedRunCompletionCandidate(state, errorCode, message, evidence = {}) {
+  return {
+    candidateStatus: "failed",
+    candidateError: message,
+    candidateResult: {
+      ...asRecord(state.candidateResult),
+      errorCode,
+      completionDeliveryFailure: {
+        phase: state.phase,
+        failedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        ...evidence
+      }
+    }
+  };
+}
+async function requestRunCompletionCheck(config, inputState) {
+  let state = inputState;
+  if (state.phase === "usage_snapshot_persisted") {
+    state = persistPendingRunCompletion(config, transitionRunCompletionState(
+      state,
+      "completion_check_requested",
+      { completionRequest: runCompletionCheckRequest(state) }
+    ));
+  } else if (state.phase === "completion_check_outbox" || state.phase === "check_failed_retry") {
+    state = persistPendingRunCompletion(config, transitionRunCompletionState(
+      state,
+      "completion_retry_scheduled",
+      { completionRequest: runCompletionCheckRequest(state) }
+    ));
+  } else if (state.phase === "closure_executing") {
+    state = persistPendingRunCompletion(config, {
+      ...state,
+      completionRequest: runCompletionCheckRequest(state),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  if (state.phase !== "completion_check_pending" && state.phase !== "closure_executing") {
+    throw new Error(`run_completion_check_phase_invalid:${state.phase}`);
+  }
+  const path = `/api/amaster/runtime-connectors/${state.connectorId}/commands/${state.commandId}/completion-check`;
+  const maxAttempts = runCompletionCheckMaxAttempts();
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    try {
+      const response = asRecord(await postJson(config, path, runCompletionCheckRequest(state)));
+      if (response.contractVersion !== "amaster.runtime-connector.completion-check.v1" || !["ready_to_terminalize", "disposition_required"].includes(response.outcome) || !["observe", "enforce"].includes(response.enforcementMode)) {
+        const error = new Error("runtime_completion_check_response_invalid");
+        error.code = "runtime_completion_check_response_invalid";
+        throw error;
+      }
+      const event = response.outcome === "disposition_required" && response.enforcementMode === "enforce" ? "completion_disposition_required" : "completion_ready";
+      state = transitionRunCompletionState(state, event, {
+        completionResponse: response,
+        candidateResult: {
+          ...asRecord(state.candidateResult),
+          completionObservation: {
+            outcome: response.outcome,
+            enforcementMode: response.enforcementMode,
+            snapshotHash: readString(response.snapshotHash),
+            ...readString(response.reasonCode) ? { reasonCode: readString(response.reasonCode) } : {}
+          }
+        }
+      });
+      return { pending: false, state: persistPendingRunCompletion(config, state) };
+    } catch (error) {
+      const terminalStatus = terminalCommandStatusFromCompletionCheckError(error);
+      if (terminalStatus) {
+        clearPendingRunCompletion(config, state.commandId);
+        return { pending: false, state, serverTerminalStatus: terminalStatus };
+      }
+      if (!completionCheckRetryable(error)) {
+        const message2 = error instanceof Error ? error.message : String(error);
+        state = transitionRunCompletionState(state, "completion_authority_rejected", {
+          candidateStatus: "failed",
+          candidateError: message2,
+          candidateResult: {
+            ...asRecord(state.candidateResult),
+            errorCode: runtimeConnectorErrorCode(error) ?? readString(error?.code) ?? "runtime_completion_check_authority_rejected",
+            completionCheckAbort: {
+              httpStatus: Number(error?.httpStatus) || null,
+              reasonCode: runtimeConnectorErrorCode(error)
+            }
+          }
+        });
+        return { pending: false, state: persistPendingRunCompletion(config, state) };
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      const completionCheckAttemptCount = readNumber(state.completionCheckAttemptCount, 0) + 1;
+      state = persistPendingRunCompletion(config, transitionRunCompletionState(
+        state,
+        "completion_check_failed",
+        {
+          lastCompletionCheckError: truncateText(message, 1e3),
+          completionCheckAttemptCount
+        }
+      ));
+      if (runCompletionPhaseExhausted(state, completionCheckAttemptCount)) {
+        state = persistPendingRunCompletion(config, transitionRunCompletionState(
+          state,
+          "completion_retry_abandoned",
+          {
+            ...failedRunCompletionCandidate(
+              state,
+              "runtime_completion_check_retry_exhausted",
+              `Completion check retry boundary exhausted: ${message}`,
+              { attemptCount: completionCheckAttemptCount }
+            ),
+            completionCheckAbandonedAt: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        ));
+        process.stderr.write(`AMaster daemon abandoned completion check ${state.commandId} after ${completionCheckAttemptCount} durable attempt(s); terminalizing failed.
+`);
+        return { pending: false, state };
+      }
+      if (attempt >= maxAttempts) {
+        state = persistPendingRunCompletion(config, transitionRunCompletionState(
+          state,
+          "completion_retry_exhausted",
+          { completionCheckOutboxQueuedAt: (/* @__PURE__ */ new Date()).toISOString() }
+        ));
+        process.stderr.write(`AMaster daemon queued completion check ${state.commandId} for durable retry after ${attempt} attempt(s): ${message}
+`);
+        return { pending: true, state };
+      }
+      state = persistPendingRunCompletion(config, transitionRunCompletionState(
+        state,
+        "completion_retry_scheduled"
+      ));
+      const delayMs = runCompletionCheckRetryDelayMs();
+      if (delayMs > 0) await new Promise((resolveDelay) => setTimeout(resolveDelay, delayMs));
+    }
+  }
+  return { pending: true, state };
+}
+function runExitClosurePrompt(state) {
+  const command = asRecord(state.command);
+  const response = asRecord(state.completionResponse);
+  const summary = truncateText(readString(asRecord(state.candidateResult).summary) ?? "", 1200);
+  const issueId = commandIssueId(command) ?? "unknown";
+  return [
+    "# AMaster Run-Exit Disposition Closure",
+    "This is a bounded status-only closure turn for the same command and heartbeat run.",
+    `Issue: ${issueId}`,
+    `Completion reason: ${readString(response.reasonCode) ?? "successful_run_missing_state"}`,
+    summary ? `Primary turn summary: ${summary}` : null,
+    "Do not perform more business work, edit files, create artifacts/documents/children/plans, or mutate company/profile/milestone state.",
+    "Use exactly one runtime_action.submit mutation. Choose update_parent, create_interaction (not suggest_tasks), or add_comment only when a comment is truly the intended exit path.",
+    "A comment alone does not establish completion. Prefer update_parent with the truthful done, blocked, review/input, or todo-continuation state.",
+    `The idempotencyKey must be runtime-command-closure:${state.commandId}.`,
+    "Do not call runtime_action.plan or runtime_action.commit. Stop immediately after the one allowed mutation returns."
+  ].filter(Boolean).join("\n\n");
+}
+function parseExecutorTurnOutput(executorKind, execution, liveOutputLogger, hasOutputFlood) {
+  const parsed = hasOutputFlood ? {
+    sessionId: null,
+    summary: "",
+    usage: { inputTokens: 0, cachedInputTokens: 0, outputTokens: 0 },
+    errorMessage: null
+  } : executorKind === "codex" ? parseCodexJsonl(execution.stdout) : executorKind === "claude" ? parseClaudeStreamJson(execution.stdout) : executorKind === "opencode" ? parseOpenCodeJsonl(execution.stdout) : executorKind === "pi" ? parsePiJsonl(execution.stdout) : parseGenericOutput(execution.stdout, execution.stderr);
+  parsed.sessionId ??= liveOutputLogger.sessionId();
+  const liveTerminalOutput = executorKind === "pi" && !hasOutputFlood ? liveOutputLogger.terminalOutput() : null;
+  if (liveTerminalOutput) {
+    const parsedUsage = asRecord(parsed.usage);
+    const liveUsage = asRecord(liveTerminalOutput.usage);
+    parsed.summary = liveTerminalOutput.summary;
+    parsed.hasAssistantOutput = true;
+    parsed.usage = {
+      inputTokens: readNumber(liveUsage.inputTokens, 0) || readNumber(parsedUsage.inputTokens, 0),
+      cachedInputTokens: readNumber(liveUsage.cachedInputTokens, 0) || readNumber(parsedUsage.cachedInputTokens, 0),
+      outputTokens: readNumber(liveUsage.outputTokens, 0) || readNumber(parsedUsage.outputTokens, 0),
+      ...readNumber(liveUsage.costUsd, 0) > 0 || readNumber(parsedUsage.costUsd, 0) > 0 ? { costUsd: readNumber(liveUsage.costUsd, 0) || readNumber(parsedUsage.costUsd, 0) } : {}
+    };
+  }
+  return parsed;
+}
+async function executeRunExitClosureTurn(config, inputState, options = {}) {
+  const state = inputState;
+  const command = asRecord(state.command);
+  const executor = asRecord(state.executor);
+  const executionConfig = asRecord(executor.closureExecution);
+  const executorKind = readString(executor.kind);
+  const executable = readString(executionConfig.command);
+  const cwd = readString(executionConfig.cwd);
+  if (!executorKind || !executable || !cwd) {
+    throw new Error("run_exit_closure_execution_context_missing");
+  }
+  const args = Array.isArray(executionConfig.args) ? executionConfig.args.map(String) : [];
+  const env = Object.fromEntries(Object.entries(asRecord(executionConfig.env)).map(([key, value]) => [key, String(value)]));
+  const protectedValues = Array.isArray(executionConfig.protectedValues) ? executionConfig.protectedValues.filter((value) => typeof value === "string" && value) : [];
+  const storedSpawnIdentity = asRecord(executionConfig.spawnIdentity);
+  let reservedPiAssignment = false;
+  const piAllocator = executorKind === "pi" && readNumber(storedSpawnIdentity.uid, 0) > 0 ? configuredPiChildIdentityAllocator(config) : null;
+  if (piAllocator) {
+    const assignment = piAllocator.acquire(commandRunId(command), {
+      ...readNumber(storedSpawnIdentity.gid, 0) > 0 ? { gid: readNumber(storedSpawnIdentity.gid, 0) } : {}
+    });
+    if (assignment.uid !== readNumber(storedSpawnIdentity.uid, 0)) {
+      piAllocator.release(commandRunId(command));
+      throw new Error("run_exit_closure_pi_identity_changed");
+    }
+    reservedPiAssignment = true;
+  }
+  let forgetTrackedRun = () => {
+  };
+  let stopTrackedHeartbeats = () => {
+  };
+  let signal = options.signal;
+  if (!signal) {
+    forgetTrackedRun = rememberActiveRunCommand(command, {
+      executorKind,
+      workspacePath: cwd,
+      sourceWorkspacePath: readString(executionConfig.sourceWorkspacePath),
+      managedWorkdir: executionConfig.managedWorkdir === true,
+      manifestPath: readString(executionConfig.manifestPath)
+    });
+    const controller = new AbortController();
+    signal = controller.signal;
+    stopTrackedHeartbeats = startActiveRunHeartbeats(config, command, controller);
+  }
+  const liveOutputLogger = createLiveOutputLogger(
+    config,
+    command,
+    executorKind,
+    protectedValues
+  );
+  try {
+    await ingestLog(config, command, "system", "info", "Starting bounded run-exit disposition closure turn", {
+      presentationKind: "run_exit_disposition_closure",
+      commandId: state.commandId,
+      closureAttempt: 1
+    });
+    let execution;
+    try {
+      execution = await runExecutor(executable, args, {
+        cwd,
+        env,
+        stdin: runExitClosurePrompt(state),
+        timeoutSeconds: Math.max(1, readNumber(executionConfig.timeoutSeconds, config.executorTimeoutSeconds)),
+        maxOutputBytes: Math.max(1, readNumber(executionConfig.maxOutputBytes, config.executorMaxOutputBytes)),
+        maxRssMb: Math.max(0, readNumber(executionConfig.maxRssMb, config.executorMaxRssMb)),
+        signal,
+        executorKind,
+        ...readNumber(storedSpawnIdentity.uid, 0) > 0 ? { spawnIdentity: storedSpawnIdentity } : {},
+        ...readString(executionConfig.managedInput) ? { managedInput: readString(executionConfig.managedInput) } : {},
+        onOutput: (stream, chunk, rawBytes) => {
+          noteActiveRunOutput(command, stream, chunk, rawBytes);
+          liveOutputLogger.write(stream, chunk);
+        }
+      });
+    } finally {
+      await liveOutputLogger.flush();
+    }
+    execution.stdout = redactProtectedText(execution.stdout, protectedValues);
+    execution.stderr = redactProtectedText(execution.stderr, protectedValues);
+    const outputFlood = asRecord(execution.outputFlood);
+    const hasOutputFlood = Boolean(readString(outputFlood.stream) && readNumber(outputFlood.bytes, 0) > 0);
+    const memoryLimit = asRecord(execution.memoryLimit);
+    const hasMemoryLimit = readNumber(memoryLimit.rssBytes, 0) > 0;
+    const parsed = parseExecutorTurnOutput(executorKind, execution, liveOutputLogger, hasOutputFlood);
+    const outputTelemetry = liveOutputLogger.snapshot({
+      outputBytes: execution.outputBytes,
+      floodLimitBytes: Math.max(1, readNumber(executionConfig.maxOutputBytes, config.executorMaxOutputBytes)),
+      outputTokens: readNumber(parsed.usage?.outputTokens, 0)
+    });
+    const completionOutputStopped = executorKind === "pi" && piCompletionOutputStopped(parsed, execution);
+    const cleanupDisposition = executorKind === "pi" && execution.cancelled !== true && !hasOutputFlood && !hasMemoryLimit && execution.timedOut !== true && !execution.spawnError && execution.signal === null ? classifyPiTerminalCleanupDisposition(parsed, []) : null;
+    const parsedForValidation = cleanupDisposition ? { ...parsed, errorMessage: null } : parsed;
+    const piInvalidOutputError = executorKind === "pi" ? piOutputValidationError(parsedForValidation, {
+      allowMissingTurnEnd: completionOutputStopped || Boolean(cleanupDisposition),
+      allowMissingAssistantOutput: false
+    }) : null;
+    const parsedError = hasOutputFlood ? "Run-exit closure output exceeded the configured limit" : hasMemoryLimit ? "Run-exit closure exceeded the configured memory limit" : execution.timedOut ? "Run-exit closure timed out" : execution.spawnError ?? piInvalidOutputError ?? parsedForValidation.errorMessage ?? ((execution.exitCode ?? 0) === 0 ? null : `Run-exit closure exited with code ${execution.exitCode ?? "unknown"}`);
+    const succeeded = execution.cancelled !== true && !hasOutputFlood && !hasMemoryLimit && (execution.exitCode === 0 || completionOutputStopped || Boolean(cleanupDisposition)) && !execution.timedOut && !execution.spawnError && !parsedError;
+    const mcpToolResults = dedupeGovernedMcpToolResults([
+      ...Array.isArray(parsed.mcpToolResults) ? parsed.mcpToolResults.map(asRecord) : [],
+      ...liveOutputLogger.mcpToolResults().map(asRecord)
+    ]);
+    await ingestLog(config, command, "system", succeeded ? "info" : "error", succeeded ? "Run-exit disposition closure turn completed" : `Run-exit disposition closure turn failed: ${parsedError}`, {
+      presentationKind: "run_exit_disposition_closure",
+      closureAttempt: 1,
+      succeeded,
+      outputTelemetry,
+      toolResultCount: mcpToolResults.length
+    });
+    return {
+      succeeded,
+      error: parsedError,
+      usage: asRecord(parsed.usage),
+      audit: {
+        schemaVersion: "run-exit-disposition-closure-v1",
+        attempt: 1,
+        succeeded,
+        exitCode: execution.exitCode,
+        signal: execution.signal,
+        timedOut: execution.timedOut,
+        summary: truncateText(readString(parsed.summary) ?? "", 2e3),
+        outputTelemetry,
+        toolResults: mcpToolResults.slice(0, 10).map((result3) => ({
+          status: readString(result3.status),
+          toolName: readString(result3.toolName) ?? readString(result3.name) ?? readString(asRecord(result3.runtimeAction).toolName),
+          invocationId: readString(result3.invocationId)
+        })),
+        ...parsedError ? { error: truncateText(parsedError, 1e3) } : {}
+      }
+    };
+  } finally {
+    stopTrackedHeartbeats();
+    forgetTrackedRun();
+    if (reservedPiAssignment) piAllocator.release(commandRunId(command));
+  }
+}
+function runCompletionUsageResult(state) {
+  const aggregate = asRecord(asRecord(state.usageRecord).aggregate);
+  const costUsd = readNumber(aggregate.costUsd, 0);
+  return {
+    inputTokens: readNumber(aggregate.inputTokens, 0),
+    cachedInputTokens: readNumber(aggregate.cachedInputTokens, 0),
+    outputTokens: readNumber(aggregate.outputTokens, 0),
+    ...costUsd > 0 ? { costUsd } : {}
+  };
+}
+async function ingestRunCompletionAggregateCost(config, state) {
+  const command = asRecord(state.command);
+  const payload = asRecord(command.payload);
+  const companyId = readString(payload.companyId);
+  const agentId = readString(payload.agentId);
+  if (!companyId || !agentId) {
+    return { accepted: true, skipped: true, reason: "cost_attribution_missing" };
+  }
+  const executor = asRecord(state.executor);
+  const aggregate = asRecord(asRecord(state.usageRecord).aggregate);
+  const response = asRecord(await postJson(
+    config,
+    `/api/amaster/runtime-connectors/${state.connectorId}/ingest/cost`,
+    {
+      commandId: state.commandId,
+      idempotencyKey: readString(asRecord(state.usageRecord).idempotencyKey),
+      companyId,
+      agentId,
+      issueId: commandIssueId(command) ?? void 0,
+      runId: commandRunId(command) ?? void 0,
+      provider: readString(executor.kind) ?? "runtime_connector",
+      biller: readString(executor.kind) === "codex" ? "chatgpt" : "runtime_connector",
+      billingType: "unknown",
+      model: readString(executor.model) ?? readString(executor.kind) ?? "runtime_connector",
+      inputTokens: readNumber(aggregate.inputTokens, 0),
+      cachedInputTokens: readNumber(aggregate.cachedInputTokens, 0),
+      outputTokens: readNumber(aggregate.outputTokens, 0),
+      costCents: readNumber(aggregate.costCents, 0),
+      occurredAt: readString(state.createdAt) ?? (/* @__PURE__ */ new Date()).toISOString()
+    }
+  ));
+  if (response.accepted !== true || !readString(response.costEventId)) {
+    throw new Error("runtime_completion_cost_receipt_invalid");
+  }
+  return response;
+}
+async function cleanupRunCompletionProfile(config, state) {
+  const command = asRecord(state.command);
+  const executor = asRecord(state.executor);
+  const managedMcp = asRecord(executor.managedMcp);
+  const profileRoot = readString(managedMcp.profileRoot);
+  if (!profileRoot) return { status: "not_configured" };
+  const cleanup = readString(executor.kind) === "pi" ? cleanupManagedPiMcpProfile : cleanupManagedCodexMcpProfile;
+  const result3 = cleanup({ profileRoot }, {
+    commandId: state.commandId,
+    runId: commandRunId(command)
+  });
+  await ingestLog(config, command, "system", "info", "Cleaned managed MCP profile after run completion gate", {
+    presentationKind: "managed_mcp_cleanup",
+    status: readString(result3?.status) ?? "removed"
+  });
+  return result3;
+}
+function queueRunCompletionResultOutbox(config, state, payload, error) {
+  const path = `/api/amaster/runtime-connectors/${state.connectorId}/commands/${state.commandId}/result`;
+  writeResultOutboxEntry(config, {
+    connectorId: state.connectorId,
+    commandId: state.commandId,
+    path,
+    payload,
+    activeRun: pendingRunCompletionSnapshot(config, state)
+  });
+  pendingResultOutboxRunCommands.set(state.commandId, {
+    ...pendingRunCompletionSnapshot(config, state),
+    phase: "result_outbox",
+    outboxQueuedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  clearPendingRunCompletion(config, state.commandId);
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`AMaster daemon queued terminal result ${state.commandId} after result POST failed: ${message}
+`);
+}
+async function finalizeRunCompletionState(config, inputState) {
+  let state = inputState;
+  if (state.phase === "ready_to_terminalize") {
+    state = persistPendingRunCompletion(config, transitionRunCompletionState(
+      state,
+      "cost_ingest_started"
+    ));
+  }
+  if (state.phase === "cost_ingest_pending") {
+    try {
+      const receipt = await ingestRunCompletionAggregateCost(config, state);
+      const aggregateUsage = runCompletionUsageResult(state);
+      const aggregate = asRecord(asRecord(state.usageRecord).aggregate);
+      state = markRunCompletionCostDelivered({
+        ...state,
+        candidateResult: {
+          ...asRecord(state.candidateResult),
+          usage: aggregateUsage,
+          usageBreakdown: Array.isArray(asRecord(state.usageRecord).turns) ? asRecord(state.usageRecord).turns : [],
+          costUsage: {
+            idempotencyKey: readString(asRecord(state.usageRecord).idempotencyKey),
+            ...readString(receipt.costEventId) ? { costEventId: readString(receipt.costEventId) } : {},
+            ...aggregateUsage,
+            costCents: readNumber(aggregate.costCents, 0)
+          }
+        }
+      }, receipt);
+      state = persistPendingRunCompletion(config, state);
+    } catch (error) {
+      const message = truncateText(error instanceof Error ? error.message : String(error), 1e3);
+      const costIngestAttemptCount = readNumber(state.costIngestAttemptCount, 0) + 1;
+      if (!runCompletionPhaseExhausted(state, costIngestAttemptCount)) {
+        state = persistPendingRunCompletion(config, {
+          ...state,
+          costIngestAttemptCount,
+          lastCostIngestError: message,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        process.stderr.write(`AMaster daemon retained cost_ingest_pending state for ${state.commandId}: ${state.lastCostIngestError}
+`);
+        return { pending: true, resultDelivered: false, state };
+      }
+      const usageRecord = asRecord(state.usageRecord);
+      state = persistPendingRunCompletion(config, transitionRunCompletionState(
+        {
+          ...state,
+          usageRecord: {
+            ...usageRecord,
+            ingestStatus: "failed",
+            failedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            failure: { message, attemptCount: costIngestAttemptCount }
+          }
+        },
+        "cost_ingest_abandoned",
+        {
+          ...failedRunCompletionCandidate(
+            state,
+            "runtime_completion_cost_retry_exhausted",
+            `Cost ingestion retry boundary exhausted: ${message}`,
+            { attemptCount: costIngestAttemptCount }
+          ),
+          costIngestAttemptCount,
+          lastCostIngestError: message
+        }
+      ));
+      process.stderr.write(`AMaster daemon abandoned cost ingestion ${state.commandId} after ${costIngestAttemptCount} attempt(s); continuing failed terminalization.
+`);
+    }
+  }
+  if (state.phase === "profile_cleanup") {
+    try {
+      const cleanup = await cleanupRunCompletionProfile(config, state);
+      state = transitionRunCompletionState(state, "profile_cleaned", {
+        managedMcpCleanup: cleanup,
+        candidateResult: {
+          ...asRecord(state.candidateResult),
+          ...Object.keys(asRecord(asRecord(state.candidateResult).managedMcp)).length > 0 ? {
+            managedMcp: {
+              ...asRecord(asRecord(state.candidateResult).managedMcp),
+              cleanup
+            }
+          } : {}
+        }
+      });
+      state = persistPendingRunCompletion(config, state);
+    } catch (error) {
+      const cleanupError = truncateText(error instanceof Error ? error.message : String(error), 1e3);
+      if (managedMcpCleanupOwnerMismatch(error)) {
+        try {
+          const terminalStatus = await probeTerminalCommandAfterUnsafeCleanup(config, state);
+          if (terminalStatus) {
+            const cleanup2 = {
+              status: "unsafe_residual_preserved",
+              reason: "server_command_already_terminal",
+              serverCommandStatus: terminalStatus
+            };
+            await ingestLog(
+              config,
+              asRecord(state.command),
+              "system",
+              "warn",
+              "Preserved unsafe managed MCP residual after server terminalization",
+              {
+                presentationKind: "managed_mcp_cleanup",
+                status: cleanup2.status,
+                serverCommandStatus: terminalStatus,
+                cleanupError
+              }
+            );
+            process.stderr.write(`AMaster daemon preserved unsafe managed MCP residual after server terminalization for ${state.commandId}; durable completion state was released without deleting the unowned path.
+`);
+            clearPendingRunCompletion(config, state.commandId);
+            return {
+              pending: false,
+              resultDelivered: true,
+              state: {
+                ...state,
+                lastProfileCleanupError: cleanupError,
+                managedMcpCleanup: cleanup2
+              },
+              managedMcpCleanup: cleanup2
+            };
+          }
+        } catch (probeError) {
+          state = {
+            ...state,
+            lastProfileCleanupProbeError: truncateText(
+              probeError instanceof Error ? probeError.message : String(probeError),
+              1e3
+            )
+          };
+        }
+      }
+      const profileCleanupAttemptCount = readNumber(state.profileCleanupAttemptCount, 0) + 1;
+      if (!runCompletionPhaseExhausted(state, profileCleanupAttemptCount)) {
+        state = persistPendingRunCompletion(config, {
+          ...state,
+          profileCleanupAttemptCount,
+          lastProfileCleanupError: cleanupError,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        process.stderr.write(`AMaster daemon retained profile_cleanup state for ${state.commandId}: ${state.lastProfileCleanupError}
+`);
+        return { pending: true, resultDelivered: false, state };
+      }
+      const cleanup = {
+        status: "unsafe_residual_preserved",
+        reason: "cleanup_retry_exhausted",
+        attemptCount: profileCleanupAttemptCount,
+        error: cleanupError
+      };
+      state = persistPendingRunCompletion(config, transitionRunCompletionState(
+        state,
+        "profile_cleanup_abandoned",
+        {
+          ...failedRunCompletionCandidate(
+            state,
+            "runtime_completion_profile_cleanup_retry_exhausted",
+            `Managed MCP cleanup retry boundary exhausted: ${cleanupError}`,
+            { attemptCount: profileCleanupAttemptCount, residualPreserved: true }
+          ),
+          profileCleanupAttemptCount,
+          lastProfileCleanupError: cleanupError,
+          managedMcpCleanup: cleanup
+        }
+      ));
+      process.stderr.write(`AMaster daemon preserved managed MCP residual for ${state.commandId} after ${profileCleanupAttemptCount} failed cleanup attempt(s); continuing failed terminalization.
+`);
+    }
+  }
+  if (state.phase !== "result_post_pending") {
+    throw new Error(`run_completion_finalize_phase_invalid:${state.phase}`);
+  }
+  const path = `/api/amaster/runtime-connectors/${state.connectorId}/commands/${state.commandId}/result`;
+  const leaseId = readString(asRecord(state.command).leaseId);
+  let payload = {
+    ...leaseId ? { leaseId } : {},
+    status: state.candidateStatus,
+    result: asRecord(state.candidateResult),
+    ...readString(state.candidateError) ? { error: truncateText(state.candidateError, 4e3) } : {}
+  };
+  try {
+    await postJson(config, path, payload);
+  } catch (error) {
+    if (runtimeConnectorErrorCode(error) === "runtime_completion_disposition_required") {
+      const raceMessage = "Run-exit disposition changed after profile cleanup; command failed closed";
+      payload = {
+        ...payload,
+        status: "failed",
+        error: raceMessage,
+        result: {
+          ...payload.result,
+          errorCode: "runtime_completion_terminalization_race",
+          completionGateRace: {
+            failedClosed: true,
+            detectedAt: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        }
+      };
+      try {
+        await postJson(config, path, payload);
+      } catch (abortError) {
+        queueRunCompletionResultOutbox(config, state, payload, abortError);
+        return { pending: false, resultDelivered: false, outboxed: true, state };
+      }
+    } else {
+      queueRunCompletionResultOutbox(config, state, payload, error);
+      return { pending: false, resultDelivered: false, outboxed: true, state };
+    }
+  }
+  state = transitionRunCompletionState(state, "result_post_delivered");
+  clearPendingRunCompletion(config, state.commandId);
+  return {
+    pending: false,
+    resultDelivered: true,
+    state,
+    managedMcpCleanup: asRecord(state.managedMcpCleanup)
+  };
+}
+async function coordinateRunCompletion(config, inputState, options = {}) {
+  let state = inputState;
+  if (["ready_to_terminalize", "cost_ingest_pending", "profile_cleanup", "result_post_pending"].includes(state.phase)) {
+    return finalizeRunCompletionState(config, state);
+  }
+  const recoveringClosure = state.phase === "closure_executing";
+  let checked = state.phase === "disposition_required" ? { pending: false, state } : await requestRunCompletionCheck(config, state);
+  state = checked.state;
+  if (checked.serverTerminalStatus) {
+    return {
+      pending: false,
+      resultDelivered: true,
+      state,
+      serverTerminalStatus: checked.serverTerminalStatus
+    };
+  }
+  if (checked.pending) return { pending: true, resultDelivered: false, state };
+  if (state.phase === "disposition_required") {
+    const closureAlreadyRecorded = state.closureTurnRecorded === true;
+    const recoveryCount = readNumber(state.closureRecoveryCount, 0);
+    const mayResumeUncertainClosure = recoveringClosure && !closureAlreadyRecorded && recoveryCount < 1;
+    if (state.closureAttempt === 0 || mayResumeUncertainClosure) {
+      state = persistPendingRunCompletion(config, transitionRunCompletionState(
+        state,
+        "closure_started",
+        {
+          closureAttempt: 1,
+          ...mayResumeUncertainClosure ? { closureRecoveryCount: recoveryCount + 1 } : {}
+        }
+      ));
+      let closure;
+      try {
+        closure = await executeRunExitClosureTurn(config, state, options);
+      } catch (error) {
+        closure = {
+          succeeded: false,
+          error: error instanceof Error ? error.message : String(error),
+          usage: {},
+          audit: {
+            schemaVersion: "run-exit-disposition-closure-v1",
+            attempt: 1,
+            succeeded: false,
+            error: truncateText(error instanceof Error ? error.message : String(error), 1e3)
+          }
+        };
+      }
+      state = appendRunCompletionUsageTurn({
+        ...state,
+        closureTurnRecorded: true,
+        candidateResult: {
+          ...asRecord(state.candidateResult),
+          closureTurn: closure.audit
+        }
+      }, {
+        turn: "closure",
+        usage: closure.usage,
+        recordedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      state = persistPendingRunCompletion(config, {
+        ...state,
+        completionRequest: {
+          ...asRecord(state.completionRequest),
+          resultSignals: {
+            productiveSuccessfulRun: asRecord(asRecord(state.completionRequest).resultSignals).productiveSuccessfulRun === true,
+            executorTurnCount: 2,
+            closureAttempt: 1
+          }
+        }
+      });
+      checked = await requestRunCompletionCheck(config, state);
+      state = checked.state;
+      if (checked.serverTerminalStatus) {
+        return {
+          pending: false,
+          resultDelivered: true,
+          state,
+          serverTerminalStatus: checked.serverTerminalStatus
+        };
+      }
+      if (checked.pending) return { pending: true, resultDelivered: false, state };
+    }
+  }
+  if (state.phase === "disposition_required") {
+    const command = asRecord(state.command);
+    const candidateResult = asRecord(state.candidateResult);
+    const closureTurn = asRecord(candidateResult.closureTurn);
+    state = persistPendingRunCompletion(config, transitionRunCompletionState(
+      state,
+      "closure_exhausted",
+      {
+        candidateResult: {
+          ...candidateResult,
+          ...Object.keys(closureTurn).length > 0 ? {} : {
+            closureTurn: {
+              schemaVersion: "run-exit-disposition-closure-v1",
+              attempt: 1,
+              succeeded: false,
+              error: "closure_recovery_exhausted"
+            }
+          },
+          closureAttemptExhausted: true,
+          closureFallback: {
+            schemaVersion: "run-exit-disposition-closure-fallback-v1",
+            attempt: 1,
+            reasonCode: readString(asRecord(state.completionResponse).reasonCode) ?? "disposition_still_required",
+            commandId: state.commandId,
+            runId: commandRunId(command)
+          }
+        }
+      }
+    ));
+  }
+  return finalizeRunCompletionState(config, state);
+}
+function coordinateRunCompletionSingleFlight(config, inputState, options = {}) {
+  const commandId = readString(inputState?.commandId);
+  if (!commandId) return Promise.reject(new Error("run_completion_command_id_missing"));
+  const activeFlight = runCompletionFlights.get(commandId);
+  if (activeFlight) return activeFlight;
+  const flight = coordinateRunCompletion(config, inputState, options);
+  runCompletionFlights.set(commandId, flight);
+  const release = () => {
+    if (runCompletionFlights.get(commandId) === flight) runCompletionFlights.delete(commandId);
+  };
+  void flight.then(release, release);
+  return flight;
+}
+async function flushRunCompletionStates(config) {
+  let completed = 0;
+  for (const { filePath, state: listedState } of runCompletionStateEntries(config)) {
+    try {
+      if (runCompletionFlights.has(listedState.commandId)) continue;
+      if (!existsSync14(filePath)) continue;
+      const state = readValidRunCompletionStateOrQuarantine(config, filePath);
+      if (!state) continue;
+      const outcome = await coordinateRunCompletionSingleFlight(config, state);
+      if (!outcome.pending) completed += 1;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`AMaster daemon run completion recovery failed for ${listedState.commandId}: ${message}
+`);
+    }
+  }
+  if (completed > 0) {
+    process.stderr.write(`AMaster daemon resumed ${completed} durable run completion state(s).
+`);
+  }
+  return completed;
+}
 async function ingestWorkspaceStatus(config, command, cwd) {
   const connectorId = requireConnectorId(config);
   const status = readWorkspaceStatus(cwd, { hashCache: workspaceStatusHashCache });
@@ -10587,6 +12039,7 @@ async function ingestRuntimeArtifacts(config, command, cwd, mcpToolResults) {
     } catch (err) {
       const message = `Runtime Artifact ${upload.intentId} ingest failed: ${err instanceof Error ? err.message : String(err)}`;
       const failure = new Error(message, err instanceof Error ? { cause: err } : void 0);
+      failure.intentId = upload.intentId;
       if (err instanceof Error && err.code === "runtime_artifact_rejected") {
         failure.code = "runtime_artifact_rejected";
       }
@@ -10659,14 +12112,14 @@ async function completeCommand(config, command, status, result3, error) {
 function resultOutboxDir(config) {
   const explicit = readString(process.env.AMASTER_RESULT_OUTBOX_DIR);
   if (explicit) return resolve12(expandHomePath(explicit));
-  return join14(dirname9(stateFilePath(process.env)), "result-outbox");
+  return join15(dirname9(stateFilePath(process.env)), "result-outbox");
 }
 function resultOutboxInvalidDir(config) {
-  return join14(resultOutboxDir(config), "invalid");
+  return join15(resultOutboxDir(config), "invalid");
 }
 function writeResultOutboxEntry(config, entry) {
   const dir = resultOutboxDir(config);
-  mkdirSync8(dir, { recursive: true });
+  mkdirSync9(dir, { recursive: true });
   const body = {
     version: 1,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -10674,19 +12127,19 @@ function writeResultOutboxEntry(config, entry) {
     lastAttemptAt: null,
     ...entry
   };
-  writeFileSync8(join14(dir, resultOutboxFileName(entry.commandId)), `${JSON.stringify(body, null, 2)}
+  writeFileSync9(join15(dir, resultOutboxFileName(entry.commandId)), `${JSON.stringify(body, null, 2)}
 `, { mode: 384 });
 }
 function moveResultOutboxEntryToInvalid(config, file, fullPath, reason, detail, original) {
   const invalidDir = resultOutboxInvalidDir(config);
-  mkdirSync8(invalidDir, { recursive: true });
-  const invalidPath = join14(invalidDir, file);
+  mkdirSync9(invalidDir, { recursive: true });
+  const invalidPath = join15(invalidDir, file);
   if (original === void 0) {
     try {
-      renameSync5(fullPath, invalidPath);
+      renameSync6(fullPath, invalidPath);
     } catch {
       copyFileSync3(fullPath, invalidPath);
-      unlinkSync(fullPath);
+      unlinkSync2(fullPath);
     }
     return;
   }
@@ -10696,14 +12149,14 @@ function moveResultOutboxEntryToInvalid(config, file, fullPath, reason, detail,
     ...detail ? { detail: truncateText(detail, 1e3) } : {},
     original
   };
-  writeFileSync8(invalidPath, `${JSON.stringify(evidence, null, 2)}
+  writeFileSync9(invalidPath, `${JSON.stringify(evidence, null, 2)}
 `, { mode: 384 });
-  unlinkSync(fullPath);
+  unlinkSync2(fullPath);
 }
 function readValidResultOutboxEntryOrQuarantine(config, file, fullPath) {
   let entry;
   try {
-    entry = JSON.parse(readFileSync10(fullPath, "utf8"));
+    entry = JSON.parse(readFileSync11(fullPath, "utf8"));
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     moveResultOutboxEntryToInvalid(config, file, fullPath, "malformed_result_outbox_json", message);
@@ -10733,13 +12186,13 @@ function updateResultOutboxAttempt(fullPath, entry, err) {
     ...typeof err?.httpStatus === "number" ? { httpStatus: err.httpStatus } : {},
     lastError: truncateText(err instanceof Error ? err.message : String(err), 1e3)
   };
-  writeFileSync8(fullPath, `${JSON.stringify(next, null, 2)}
+  writeFileSync9(fullPath, `${JSON.stringify(next, null, 2)}
 `, { mode: 384 });
   return next;
 }
 function quarantineResultOutboxEntry(config, fullPath, file, entry, reason, err) {
   const invalidDir = resultOutboxInvalidDir(config);
-  mkdirSync8(invalidDir, { recursive: true });
+  mkdirSync9(invalidDir, { recursive: true });
   const body = {
     ...entry,
     invalidReason: reason,
@@ -10747,30 +12200,31 @@ function quarantineResultOutboxEntry(config, fullPath, file, entry, reason, err)
     ...typeof err?.httpStatus === "number" ? { httpStatus: err.httpStatus } : {},
     lastError: truncateText(err instanceof Error ? err.message : String(err), 1e3)
   };
-  const invalidPath = join14(invalidDir, file);
-  writeFileSync8(invalidPath, `${JSON.stringify(body, null, 2)}
+  const invalidPath = join15(invalidDir, file);
+  writeFileSync9(invalidPath, `${JSON.stringify(body, null, 2)}
 `, { mode: 384 });
   try {
-    unlinkSync(fullPath);
+    unlinkSync2(fullPath);
   } catch (unlinkErr) {
     const message = unlinkErr instanceof Error ? unlinkErr.message : String(unlinkErr);
     process.stderr.write(`AMaster daemon could not remove quarantined result outbox entry ${file}: ${message}
 `);
   }
+  clearDeliveredResultOutboxCommand(config, entry);
   return invalidPath;
 }
 async function flushResultOutbox(config) {
   const dir = resultOutboxDir(config);
-  if (!existsSync13(dir)) return { attempted: 0, completed: 0 };
-  const files = readdirSync8(dir).filter((name) => name.endsWith(".json")).sort();
+  if (!existsSync14(dir)) return { attempted: 0, completed: 0 };
+  const files = readdirSync9(dir).filter((name) => name.endsWith(".json")).sort();
   let completed = 0;
   for (const file of files) {
-    const fullPath = join14(dir, file);
+    const fullPath = join15(dir, file);
     const entry = readValidResultOutboxEntryOrQuarantine(config, file, fullPath);
     if (!entry) continue;
     try {
       await postJson(config, String(entry.path), entry.payload);
-      unlinkSync(fullPath);
+      unlinkSync2(fullPath);
       clearDeliveredResultOutboxCommand(config, entry);
       completed += 1;
     } catch (err) {
@@ -10962,8 +12416,8 @@ async function materializeIssueAttachments(config, command, workspace) {
     runtimeAuth,
     issueId
   );
-  const targetDir = join14(workspace.cwd, "input-attachments");
-  mkdirSync8(targetDir, { recursive: true });
+  const targetDir = join15(workspace.cwd, "input-attachments");
+  mkdirSync9(targetDir, { recursive: true });
   const usedFilenames = /* @__PURE__ */ new Set();
   const materialized = [];
   for (const [index, rawAttachment] of attachments.entries()) {
@@ -10977,9 +12431,9 @@ async function materializeIssueAttachments(config, command, workspace) {
       filename = `${stem}-${index + 1}${ext}`;
     }
     usedFilenames.add(filename);
-    const targetPath = join14(targetDir, filename);
+    const targetPath = join15(targetDir, filename);
     const body = await runtimeApiBuffer(runtimeAuth, contentPath);
-    writeFileSync8(targetPath, body);
+    writeFileSync9(targetPath, body);
     const attachmentId = readString(attachment.id);
     const actualSha256 = createHash12("sha256").update(body).digest("hex");
     const lineageCandidates = lineageCandidatesByAttachmentId.get(attachmentId) ?? [];
@@ -11053,9 +12507,9 @@ async function materializeRequiredArtifactInputs(config, command, workspace) {
   if (manifest.version !== 1 || !Array.isArray(manifest.entries)) {
     throw new Error("artifact_input_manifest_invalid: expected version 1 entries array");
   }
-  const targetRoot = join14(workspace.cwd, "input-artifacts");
+  const targetRoot = join15(workspace.cwd, "input-artifacts");
   rmSync7(targetRoot, { recursive: true, force: true });
-  mkdirSync8(targetRoot, { recursive: true });
+  mkdirSync9(targetRoot, { recursive: true });
   const usedPaths = /* @__PURE__ */ new Set();
   const materialized = [];
   for (const [index, rawEntry] of manifest.entries.entries()) {
@@ -11084,17 +12538,17 @@ async function materializeRequiredArtifactInputs(config, command, workspace) {
       id: attachmentId,
       originalFilename: readString(entry.originalFilename)
     }, index);
-    let relativePath = join14("input-artifacts", sourceDir, filename).split(/[\\/]+/).join("/");
+    let relativePath = join15("input-artifacts", sourceDir, filename).split(/[\\/]+/).join("/");
     if (usedPaths.has(relativePath)) {
       const ext = extname2(filename);
       const stem = ext ? filename.slice(0, -ext.length) : filename;
       filename = `${stem}-${index + 1}${ext}`;
-      relativePath = join14("input-artifacts", sourceDir, filename).split(/[\\/]+/).join("/");
+      relativePath = join15("input-artifacts", sourceDir, filename).split(/[\\/]+/).join("/");
     }
     usedPaths.add(relativePath);
-    const targetPath = join14(workspace.cwd, relativePath);
-    mkdirSync8(dirname9(targetPath), { recursive: true });
-    writeFileSync8(targetPath, body);
+    const targetPath = join15(workspace.cwd, relativePath);
+    mkdirSync9(dirname9(targetPath), { recursive: true });
+    writeFileSync9(targetPath, body);
     chmodSync6(targetPath, 292);
     materialized.push({
       id: attachmentId,
@@ -11114,8 +12568,8 @@ async function materializeRequiredArtifactInputs(config, command, workspace) {
     version: 1,
     entries: materialized.map(({ path: _path, relativePath, ...entry }) => ({ ...entry, path: relativePath }))
   };
-  const manifestPath = join14(targetRoot, "artifact-input-manifest.json");
-  writeFileSync8(manifestPath, JSON.stringify(localManifest, null, 2) + "\n");
+  const manifestPath = join15(targetRoot, "artifact-input-manifest.json");
+  writeFileSync9(manifestPath, JSON.stringify(localManifest, null, 2) + "\n");
   chmodSync6(manifestPath, 292);
   updateWorkspaceManifest(workspaceManifestPath(workspace), { artifactInputManifest: localManifest });
   await ingestLog(config, command, "system", "info", `Materialized ${materialized.length} required artifact input(s) into the execution workspace`, {
@@ -11125,11 +12579,11 @@ async function materializeRequiredArtifactInputs(config, command, workspace) {
   return materialized;
 }
 function issueCheckpointDir(workspace) {
-  return join14(dirname9(workspace.runDir), "checkpoint");
+  return join15(dirname9(workspace.runDir), "checkpoint");
 }
 async function clearIssueCheckpoint(config, command, workspace, reason) {
   const checkpointDir = issueCheckpointDir(workspace);
-  if (!existsSync13(checkpointDir)) return false;
+  if (!existsSync14(checkpointDir)) return false;
   rmSync7(checkpointDir, { recursive: true, force: true });
   await ingestLog(config, command, "system", "info", "Cleared issue continuation checkpoint", { reason });
   return true;
@@ -11143,15 +12597,15 @@ function safeCheckpointRelativePath(rawPath) {
   return normalized;
 }
 function hashFileSha256(filePath) {
-  return createHash12("sha256").update(readFileSync10(filePath)).digest("hex");
+  return createHash12("sha256").update(readFileSync11(filePath)).digest("hex");
 }
 async function materializeIssueCheckpoint(config, command, workspace) {
   const checkpointDir = issueCheckpointDir(workspace);
-  const manifestPath = join14(checkpointDir, "manifest.json");
-  if (!existsSync13(manifestPath)) return [];
+  const manifestPath = join15(checkpointDir, "manifest.json");
+  if (!existsSync14(manifestPath)) return [];
   let manifest;
   try {
-    manifest = asRecord(JSON.parse(readFileSync10(manifestPath, "utf8")));
+    manifest = asRecord(JSON.parse(readFileSync11(manifestPath, "utf8")));
   } catch (err) {
     rmSync7(checkpointDir, { recursive: true, force: true });
     throw new Error(`invalid issue checkpoint manifest: ${err instanceof Error ? err.message : String(err)}`);
@@ -11164,8 +12618,8 @@ async function materializeIssueCheckpoint(config, command, workspace) {
   try {
     const files = Array.isArray(manifest.files) ? manifest.files : [];
     if (files.length > 20) throw new Error("issue checkpoint manifest exceeds the limit of 20 files");
-    const filesRoot = realpathSync4(join14(checkpointDir, "files"));
-    const workspaceRoot = realpathSync4(workspace.cwd);
+    const filesRoot = realpathSync5(join15(checkpointDir, "files"));
+    const workspaceRoot = realpathSync5(workspace.cwd);
     const validated = [];
     let totalBytes = 0;
     for (const rawFile of files) {
@@ -11177,8 +12631,8 @@ async function materializeIssueCheckpoint(config, command, workspace) {
       if (!pathWithin2(sourceCandidate, filesRoot) || !pathWithin2(target, workspaceRoot)) {
         throw new Error(`issue checkpoint path escapes its workspace: ${relativePath}`);
       }
-      if (!existsSync13(sourceCandidate)) throw new Error(`issue checkpoint file is missing: ${relativePath}`);
-      const source = realpathSync4(sourceCandidate);
+      if (!existsSync14(sourceCandidate)) throw new Error(`issue checkpoint file is missing: ${relativePath}`);
+      const source = realpathSync5(sourceCandidate);
       if (!pathWithin2(source, filesRoot) || !statSync7(source).isFile()) {
         throw new Error(`issue checkpoint source escapes its storage root: ${relativePath}`);
       }
@@ -11202,8 +12656,8 @@ async function materializeIssueCheckpoint(config, command, workspace) {
       } catch (err) {
         if (err?.code !== "ENOENT") throw err;
       }
-      mkdirSync8(dirname9(target), { recursive: true });
-      const targetParent = realpathSync4(dirname9(target));
+      mkdirSync9(dirname9(target), { recursive: true });
+      const targetParent = realpathSync5(dirname9(target));
       if (!pathWithin2(targetParent, workspaceRoot)) {
         throw new Error(`issue checkpoint target escapes its workspace: ${relativePath}`);
       }
@@ -11231,17 +12685,17 @@ async function materializeIssueCheckpoint(config, command, workspace) {
 }
 async function saveIssueCheckpoint(config, command, workspace, candidates) {
   const checkpointDir = issueCheckpointDir(workspace);
-  const filesDir = join14(checkpointDir, "files");
+  const filesDir = join15(checkpointDir, "files");
   rmSync7(checkpointDir, { recursive: true, force: true });
-  mkdirSync8(filesDir, { recursive: true });
+  mkdirSync9(filesDir, { recursive: true });
   const files = [];
   let totalBytes = 0;
-  const workspaceRoot = realpathSync4(workspace.cwd);
+  const workspaceRoot = realpathSync5(workspace.cwd);
   for (const candidate of candidates.slice(0, 20)) {
     const relativePath = safeCheckpointRelativePath(candidate.rawPath);
     const source = readString(candidate.filePath);
-    if (!relativePath || !source || !existsSync13(source) || !statSync7(source).isFile()) continue;
-    const ownedSource = realpathSync4(source);
+    if (!relativePath || !source || !existsSync14(source) || !statSync7(source).isFile()) continue;
+    const ownedSource = realpathSync5(source);
     if (!pathWithin2(ownedSource, workspaceRoot)) {
       throw new Error(`issue checkpoint source escapes its execution workspace: ${relativePath}`);
     }
@@ -11249,7 +12703,7 @@ async function saveIssueCheckpoint(config, command, workspace, candidates) {
     if (byteSize <= 0 || totalBytes + byteSize > MAX_CHECKPOINT_BYTES) continue;
     const target = resolve12(filesDir, relativePath);
     if (!pathWithin2(target, filesDir)) continue;
-    mkdirSync8(dirname9(target), { recursive: true });
+    mkdirSync9(dirname9(target), { recursive: true });
     copyFileSync3(ownedSource, target);
     totalBytes += byteSize;
     files.push({ path: relativePath, byteSize, sha256: hashFileSha256(ownedSource) });
@@ -11267,7 +12721,7 @@ async function saveIssueCheckpoint(config, command, workspace, candidates) {
     totalBytes,
     files
   };
-  writeFileSync8(join14(checkpointDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+  writeFileSync9(join15(checkpointDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `);
   await ingestLog(config, command, "system", "warn", `Saved ${files.length} required deliverable(s) for continuation recovery`, manifest);
   return manifest;
@@ -11353,6 +12807,7 @@ async function executeRunCommand(config, command) {
   };
   let stopActiveRunHeartbeats = () => {
   };
+  let completionOwnsManagedMcpProfile = false;
   try {
     if (executor.kind === "codex" && Object.keys(governedMcp).length > 0) {
       managedMcpProfile = prepareManagedCodexMcpProfile({
@@ -11447,7 +12902,7 @@ async function executeRunCommand(config, command) {
         executorEnv = {
           ...executorEnv,
           AMASTER_MANAGED_RUNTIME_ASSERTION_FD: "3",
-          AMASTER_MANAGED_RUNTIME_AUDIT_FILE: join14(
+          AMASTER_MANAGED_RUNTIME_AUDIT_FILE: join15(
             managedMcpProfile.env.HOME,
             ".amaster-managed-runtime-audit.jsonl"
           ),
@@ -11683,16 +13138,15 @@ async function executeRunCommand(config, command) {
         outputTelemetry
       }
     );
-    await ingestCost(config, command, executor, parsed);
     const workspaceStatus = await ingestWorkspaceStatus(config, command, cwd);
     let nativeSessionRollout = null;
     let nativeSessionRolloutError = null;
     let nativeSessionRolloutCleanup = null;
     let nativeSessionRolloutCleanupError = null;
-    const mcpToolResults = [
+    const mcpToolResults = dedupeGovernedMcpToolResults([
       ...Array.isArray(parsed.mcpToolResults) ? parsed.mcpToolResults.map(asRecord) : [],
       ...liveOutputLogger.mcpToolResults().map(asRecord)
-    ];
+    ]);
     runtimeArtifacts.push(...await ingestRuntimeArtifacts(
       config,
       command,
@@ -11795,23 +13249,7 @@ async function executeRunCommand(config, command) {
     const resultStderr = filterExecutionStderrForResult(executor.kind, execution.stderr);
     const error = execution.timedOut ? `Executor timed out after ${config.executorTimeoutSeconds}s` : cancelled ? "Executor cancelled by AMaster control plane" : execution.spawnError ?? parsedErrorMessage ?? (succeeded ? null : `Executor exited with code ${execution.exitCode ?? "unknown"}`);
     const costUsage = parsedCostUsage(parsed.usage);
-    if (managedMcpProfile) {
-      managedMcpCleanup = cleanupManagedMcpProfile(managedMcpProfile, {
-        commandId: command.commandId,
-        runId: commandRunId(command)
-      });
-      patchActiveRunCommand(command, {
-        managedMcpCleanup: managedMcpCleanup.status,
-        managedMcpCleanedAt: (/* @__PURE__ */ new Date()).toISOString()
-      });
-      await ingestLog(config, command, "system", "info", `Cleaned isolated ${executor.kind} managed MCP profile`, {
-        presentationKind: "managed_mcp_cleanup",
-        attestationId: managedMcpProfile.attestation.attestationId,
-        sessionId: governedMcp.sessionId,
-        status: managedMcpCleanup.status
-      });
-    }
-    const result3 = {
+    let result3 = {
       evidenceContract: { version: 1 },
       executorKind: executor.kind,
       command: invocation.command,
@@ -11900,6 +13338,90 @@ async function executeRunCommand(config, command) {
         }
       } : {}
     };
+    if (succeeded && managedMcpProfile && Array.isArray(command.requiredCapabilities) && command.requiredCapabilities.includes("runtime_actions_v2")) {
+      const productiveSuccessfulRun = outputTelemetry.meaningfulProgressEventCount > 0 || runtimeArtifacts.length > 0 || mcpToolResults.some((toolResult) => ["succeeded", "approval_required"].includes(readString(toolResult.status)));
+      let completionState = createRunCompletionState({
+        connectorId: requireConnectorId(config),
+        command,
+        executor: {
+          kind: executor.kind,
+          model: process.env.AMASTER_CODEX_MODEL || executor.kind,
+          ...managedMcpProfile ? {
+            managedMcp: {
+              profileRoot: managedMcpProfile.profileRoot,
+              attestation: managedMcpProfile.attestation
+            }
+          } : {},
+          closureExecution: {
+            command: invocation.command,
+            args: invocation.args,
+            cwd,
+            sourceWorkspacePath: workspace.sourceWorkspacePath,
+            managedWorkdir: workspace.managed,
+            manifestPath: workspaceManifestPath(workspace),
+            env: executorEnv,
+            protectedValues: protectedExecutorValues,
+            timeoutSeconds: config.executorTimeoutSeconds,
+            maxOutputBytes: config.executorMaxOutputBytes,
+            maxRssMb: config.executorMaxRssMb,
+            ...piChildIsolation ? { spawnIdentity: piChildIsolation.spawn } : {},
+            ...trustedPiRuntime ? { managedInput: `${JSON.stringify(trustedPiRuntimeAssertion)}
+` } : {}
+          }
+        },
+        completionRequest: {
+          contractVersion: "amaster.runtime-connector.completion-check.v1",
+          leaseId: command.leaseId,
+          proposedStatus: "succeeded",
+          resultSignals: {
+            productiveSuccessfulRun,
+            executorTurnCount: 1,
+            closureAttempt: 0
+          }
+        },
+        candidateStatus: "succeeded",
+        candidateResult: result3,
+        turn: { usage: parsed.usage }
+      });
+      completionState = persistPendingRunCompletion(config, completionState);
+      completionOwnsManagedMcpProfile = true;
+      const completionOutcome = await coordinateRunCompletionSingleFlight(config, completionState, {
+        signal: abortController.signal
+      });
+      managedMcpCleanup = Object.keys(asRecord(completionOutcome.managedMcpCleanup)).length > 0 ? completionOutcome.managedMcpCleanup : managedMcpCleanup;
+      if (completionOutcome.pending) {
+        await heartbeat(config, { logMode: "compact" }).catch((heartbeatError) => {
+          const message = heartbeatError instanceof Error ? heartbeatError.message : String(heartbeatError);
+          process.stderr.write(`AMaster daemon completion-state heartbeat failed; durable state will retry: ${message}
+`);
+        });
+      }
+      return { resultDelivered: Boolean(completionOutcome.resultDelivered) };
+    }
+    await ingestCost(config, command, executor, parsed);
+    if (managedMcpProfile) {
+      managedMcpCleanup = cleanupManagedMcpProfile(managedMcpProfile, {
+        commandId: command.commandId,
+        runId: commandRunId(command)
+      });
+      patchActiveRunCommand(command, {
+        managedMcpCleanup: managedMcpCleanup.status,
+        managedMcpCleanedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      await ingestLog(config, command, "system", "info", `Cleaned isolated ${executor.kind} managed MCP profile`, {
+        presentationKind: "managed_mcp_cleanup",
+        attestationId: managedMcpProfile.attestation.attestationId,
+        sessionId: governedMcp.sessionId,
+        status: managedMcpCleanup.status
+      });
+      result3 = {
+        ...result3,
+        managedMcp: {
+          ...asRecord(result3.managedMcp),
+          cleanup: managedMcpCleanup
+        }
+      };
+    }
     const completion = await completeCommand(config, command, cancelled ? "cancelled" : succeeded ? "succeeded" : "failed", result3, error ?? void 0);
     if (!completion) {
       rememberPendingResultOutboxRunCommand(command, {
@@ -11914,7 +13436,7 @@ async function executeRunCommand(config, command) {
     }
     return { resultDelivered: Boolean(completion) };
   } finally {
-    if (managedMcpProfile && !managedMcpCleanup) {
+    if (managedMcpProfile && !managedMcpCleanup && !completionOwnsManagedMcpProfile) {
       managedMcpCleanup = cleanupManagedMcpProfile(managedMcpProfile, {
         commandId: command.commandId,
         runId: commandRunId(command)
@@ -12024,13 +13546,15 @@ function isConnectorAuthFailure(err) {
   return err && (err.httpStatus === 401 || err.httpStatus === 403);
 }
 function reconcileStaleManagedMcpProfiles(config) {
+  const protectedCommandIds = runCompletionStateEntries(config).map(({ state }) => state.commandId);
   for (const [executorKind, reconcile] of [
     ["Codex", reconcileManagedCodexMcpProfiles],
     ["Pi", reconcileManagedPiMcpProfiles]
   ]) {
-    const result3 = reconcile(config.runtimeWorkspacesRoot);
+    const result3 = reconcile(config.runtimeWorkspacesRoot, { protectedCommandIds });
     if (result3.failed > 0) {
-      throw new Error(`${executorKind.toLowerCase()}_managed_mcp_restart_cleanup_failed: ${result3.failed}/${result3.scanned} owned profile(s) could not be reconciled`);
+      const reasons = Array.isArray(result3.failures) ? result3.failures.slice(0, 3).map((failure) => readString(failure?.error) ?? "unknown").join("; ") : "unknown";
+      throw new Error(`${executorKind.toLowerCase()}_managed_mcp_restart_cleanup_failed: ${result3.failed}/${result3.scanned} owned profile(s) could not be reconciled: ${reasons}`);
     }
     if (result3.removed > 0) {
       process.stderr.write(`AMaster daemon removed ${result3.removed} stale marker-owned ${executorKind} managed MCP artifact(s) during startup reconciliation.
@@ -12054,6 +13578,7 @@ async function runOnce(config) {
     }
   }
   await flushResultOutbox(config);
+  await flushRunCompletionStates(config);
   const availableSlots = availableCommandSlots(config);
   if (availableSlots <= 0) return 0;
   const leaseId = `amaster-${Date.now()}`;
@@ -12085,6 +13610,7 @@ async function dispatchAvailableCommands(config, options = {}) {
     }
   }
   await flushResultOutbox(config);
+  await flushRunCompletionStates(config);
   const availableSlots = availableCommandSlots(config);
   if (availableSlots <= 0) return 0;
   const leaseId = `amaster-${Date.now()}`;