@amaster.ai/employee-runtime-connector 0.1.1-beta.65 → 0.1.1-beta.67

package/dist/amaster-runtime-daemon.mjs

@@ -761,7 +761,7 @@ function skipVoid(str, ptr, banNewLines, banComments) {
   }
   return ptr;
 }
-function skipUntil(str, ptr, sep2, end, banNewLines = false) {
+function skipUntil(str, ptr, sep3, end, banNewLines = false) {
   if (!end) {
     ptr = indexOfNewline(str, ptr);
     return ptr < 0 ? str.length : ptr;
@@ -770,7 +770,7 @@ function skipUntil(str, ptr, sep2, end, banNewLines = false) {
     let c = str[i];
     if (c === "#") {
       i = indexOfNewline(str, i);
-    } else if (c === sep2) {
+    } else if (c === sep3) {
       return i + 1;
     } else if (c === end || banNewLines && (c === "\n" || c === "\r" && str[i + 1] === "\n")) {
       return i;
@@ -1952,7 +1952,7 @@ import {
   writeFileSync as writeFileSync3
 } from "node:fs";
 import { arch as arch2, platform as platform2 } from "node:os";
-import { basename as basename2, delimiter, dirname as dirname3, isAbsolute as isAbsolute2, join as join4, relative as relative2, resolve as resolve3 } from "node:path";
+import { basename as basename2, delimiter, dirname as dirname3, isAbsolute as isAbsolute2, join as join4, relative as relative2, resolve as resolve3, sep as sep2 } from "node:path";
 import { spawnSync as spawnSync2 } from "node:child_process";
 
 // src/amaster-runtime-daemon/pi-provider-config.mjs
@@ -2568,7 +2568,7 @@ function stablePiManagedMcpCacheSemanticHash(value) {
 }
 function managedPiEffectiveToolsAttestorExtensionSource() {
   return String.raw`import { createHash } from "node:crypto";
-import { readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { Value } from "typebox/value";
 
@@ -2623,6 +2623,27 @@ function safeWriteReceipt(receiptPath, receipt) {
   writeFileSync(receiptPath, JSON.stringify(receipt) + "\n", { encoding: "utf8", mode: 0o600 });
 }
 
+function safeWritePhase(phasePath, phase) {
+  if (!phasePath) return;
+  let history = [];
+  if (existsSync(phasePath)) {
+    try {
+      const previous = JSON.parse(readFileSync(phasePath, "utf8"));
+      history = Array.isArray(previous.history) ? previous.history.slice(0, 16) : [];
+    } catch {
+      history = [];
+    }
+  }
+  const attemptValue = Number(process.env.AMASTER_PI_EFFECTIVE_TOOLS_ATTEMPT);
+  const attempt = Number.isSafeInteger(attemptValue) && attemptValue > 0 ? attemptValue : 1;
+  const atMs = Date.now();
+  history.push({ phase, attempt, atMs });
+  writeFileSync(phasePath, JSON.stringify({ phase, attempt, atMs, history }) + "\n", {
+    encoding: "utf8",
+    mode: 0o600,
+  });
+}
+
 function validationErrorPath(error) {
   if (typeof error.path === "string" && error.path) return error.path;
   const base = typeof error.instancePath === "string" ? error.instancePath : "";
@@ -2645,10 +2666,13 @@ export default function amasterEffectiveToolsAttestor(pi) {
   if (mode !== "probe" && mode !== "enforce") return;
   const manifestPath = requiredPath("AMASTER_PI_EFFECTIVE_TOOLS_MANIFEST");
   const receiptPath = requiredPath("AMASTER_PI_EFFECTIVE_TOOLS_RECEIPT");
+  const phasePath = process.env.AMASTER_PI_EFFECTIVE_TOOLS_PHASE?.trim() || null;
   const cachePath = requiredPath("AMASTER_PI_EFFECTIVE_TOOLS_CACHE");
   const configPath = requiredPath("AMASTER_PI_EFFECTIVE_TOOLS_CONFIG");
+  safeWritePhase(phasePath, "loader_ready");
 
   pi.on("session_start", async () => {
+    safeWritePhase(phasePath, "session_start");
     let receipt;
     try {
       const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
@@ -2747,6 +2771,7 @@ export default function amasterEffectiveToolsAttestor(pi) {
         attestedAt: new Date().toISOString(),
       };
       safeWriteReceipt(receiptPath, receipt);
+      safeWritePhase(phasePath, "attested");
       if (mode === "probe") process.exit(0);
     } catch (error) {
       receipt = {
@@ -2758,6 +2783,7 @@ export default function amasterEffectiveToolsAttestor(pi) {
         attestedAt: new Date().toISOString(),
       };
       safeWriteReceipt(receiptPath, receipt);
+      safeWritePhase(phasePath, "rejected");
       process.exit(78);
     }
   });
@@ -3058,9 +3084,16 @@ function createManagedPiMcpProfileApi(options = {}) {
   const DEFAULT_SESSION_ROLLOUT_TTL_MS2 = 24 * 60 * 60 * 1e3;
   const PI_VERSION_ATTESTATION_TIMEOUT_MS = 1e4;
   const PI_EFFECTIVE_TOOLS_ATTESTATION_TIMEOUT_MS = 6e4;
+  const PI_EFFECTIVE_TOOLS_RETRY_TIMEOUT_MS = 3e4;
+  const PI_EFFECTIVE_TOOLS_TOTAL_TIMEOUT_MS = PI_EFFECTIVE_TOOLS_ATTESTATION_TIMEOUT_MS + PI_EFFECTIVE_TOOLS_RETRY_TIMEOUT_MS;
+  const PI_EFFECTIVE_TOOLS_SOFT_SLOW_MS = 3e4;
+  const PI_EFFECTIVE_TOOLS_BOOTSTRAP_SCHEMA_VERSION = 1;
+  const PI_EFFECTIVE_TOOLS_CIRCUIT_FAILURE_THRESHOLD = Number.isInteger(options.probeCircuitFailureThreshold) && options.probeCircuitFailureThreshold > 0 ? options.probeCircuitFailureThreshold : 3;
+  const PI_EFFECTIVE_TOOLS_CIRCUIT_COOLDOWN_MS = Number.isFinite(options.probeCircuitCooldownMs) && options.probeCircuitCooldownMs > 0 ? Math.floor(options.probeCircuitCooldownMs) : 6e4;
   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();
+  const effectiveToolsProbeCircuits = /* @__PURE__ */ new Map();
   function record6(value) {
     return value && typeof value === "object" && !Array.isArray(value) ? value : {};
   }
@@ -3180,6 +3213,216 @@ function createManagedPiMcpProfileApi(options = {}) {
   function sha2562(value) {
     return createHash3("sha256").update(value).digest("hex");
   }
+  function trustedTreeDigest(rootPath, options2 = {}) {
+    const root = resolve3(rootPath);
+    const ignoredRootEntries = new Set(Array.isArray(options2.ignoredRootEntries) ? options2.ignoredRootEntries : []);
+    const hash = createHash3("sha256");
+    hash.update(`ignored-root:${[...ignoredRootEntries].sort().join(",")}
+`);
+    const pending = [root];
+    while (pending.length > 0) {
+      const current = pending.pop();
+      const currentStat = lstatSync3(current);
+      if (currentStat.isSymbolicLink()) throw new Error(`pi_managed_mcp_bootstrap_cache_unsafe: ${current}`);
+      const relativePath = relative2(root, current).split(sep2).join("/");
+      if (currentStat.isDirectory()) {
+        hash.update(`d:${relativePath}
+`);
+        const children = readdirSync3(current).filter((child) => current !== root || !ignoredRootEntries.has(child)).sort().reverse();
+        for (const child of children) pending.push(join4(current, child));
+        continue;
+      }
+      if (!currentStat.isFile()) throw new Error(`pi_managed_mcp_bootstrap_cache_unsafe: ${current}`);
+      hash.update(`f:${relativePath}:${currentStat.mode & 73 ? "x" : "-"}:`);
+      hash.update(readFileSync3(current));
+      hash.update("\n");
+    }
+    return hash.digest("hex");
+  }
+  function copyTrustedTree(sourcePath, targetPath) {
+    const source = resolve3(sourcePath);
+    const sourceStat = lstatSync3(source);
+    if (!sourceStat.isDirectory() || sourceStat.isSymbolicLink()) {
+      throw new Error(`pi_managed_mcp_bootstrap_cache_unsafe: ${source}`);
+    }
+    mkdirSync3(targetPath, { recursive: true, mode: 448 });
+    chmodSync3(targetPath, 448);
+    for (const entry of readdirSync3(source, { withFileTypes: true })) {
+      const from = join4(source, entry.name);
+      const to = join4(targetPath, entry.name);
+      if (entry.isSymbolicLink()) throw new Error(`pi_managed_mcp_bootstrap_cache_unsafe: ${from}`);
+      if (entry.isDirectory()) {
+        copyTrustedTree(from, to);
+        continue;
+      }
+      if (!entry.isFile()) throw new Error(`pi_managed_mcp_bootstrap_cache_unsafe: ${from}`);
+      copyFileSync(from, to, 0);
+      chmodSync3(to, 384 | lstatSync3(from).mode & 73);
+    }
+  }
+  function makeTrustedTreeReadOnly(rootPath) {
+    const root = resolve3(rootPath);
+    const pending = [root];
+    const directories = [];
+    while (pending.length > 0) {
+      const current = pending.pop();
+      const currentStat = lstatSync3(current);
+      if (currentStat.isSymbolicLink()) throw new Error(`pi_managed_mcp_bootstrap_cache_unsafe: ${current}`);
+      if (currentStat.isDirectory()) {
+        directories.push(current);
+        for (const entry of readdirSync3(current)) pending.push(join4(current, entry));
+        continue;
+      }
+      if (!currentStat.isFile()) throw new Error(`pi_managed_mcp_bootstrap_cache_unsafe: ${current}`);
+      chmodSync3(current, 256 | currentStat.mode & 73);
+    }
+    for (const directory of directories.reverse()) chmodSync3(directory, 320);
+  }
+  function makeTrustedTreeWritable(rootPath) {
+    const pending = [resolve3(rootPath)];
+    while (pending.length > 0) {
+      const current = pending.pop();
+      const currentStat = lstatSync3(current);
+      if (currentStat.isSymbolicLink()) throw new Error(`pi_managed_mcp_bootstrap_cache_unsafe: ${current}`);
+      if (currentStat.isDirectory()) {
+        chmodSync3(current, 448);
+        for (const entry of readdirSync3(current)) pending.push(join4(current, entry));
+        continue;
+      }
+      if (!currentStat.isFile()) throw new Error(`pi_managed_mcp_bootstrap_cache_unsafe: ${current}`);
+      chmodSync3(current, 384 | currentStat.mode & 73);
+    }
+  }
+  function piLoaderIdentity(executorPath) {
+    let cursor = dirname3(realpathSync2(executorPath));
+    for (let depth = 0; depth < 4; depth += 1) {
+      const packagePath = join4(cursor, "package.json");
+      const loaderPath = join4(cursor, "dist", "core", "extensions", "loader.js");
+      if (existsSync3(packagePath) && existsSync3(loaderPath)) {
+        const packageJson = JSON.parse(readFileSync3(packagePath, "utf8"));
+        return sha2562(stablePiJson({
+          name: packageJson.name,
+          version: packageJson.version,
+          loaderSha256: sha2562(readFileSync3(loaderPath))
+        }));
+      }
+      cursor = dirname3(cursor);
+    }
+    return sha2562(readFileSync3(realpathSync2(executorPath)));
+  }
+  function effectiveToolsBootstrapKey(input, sharedRuntime, executorCommand) {
+    const adapterRoot = join4(sharedRuntime.home, "npm", "node_modules", "pi-mcp-adapter");
+    const resolvedExecutorCommand = resolvePiExecutablePath(executorCommand, input.baseEnv);
+    return sha2562(stablePiJson({
+      schemaVersion: PI_EFFECTIVE_TOOLS_BOOTSTRAP_SCHEMA_VERSION,
+      connectorVersion: nonEmpty2(input.connectorVersion, "connectorVersion"),
+      executorIdentity: piExecutableIdentity(resolvedExecutorCommand),
+      loaderIdentity: piLoaderIdentity(resolvedExecutorCommand),
+      nodeVersion: process.version,
+      nodeModulesAbi: process.versions.modules,
+      platform: platform2(),
+      arch: arch2(),
+      // npm may install dependency symlinks under the adapter's nested
+      // node_modules. They resolve at runtime and are not Jiti-owned compiled
+      // source; hash every package-owned adapter file while excluding that
+      // dependency graph so ordinary npm links do not make the cache unusable.
+      adapterTreeSha256: trustedTreeDigest(adapterRoot, { ignoredRootEntries: ["node_modules"] }),
+      attestorSourceSha256: sha2562(managedPiEffectiveToolsAttestorExtensionSource()),
+      argsNormalizerSourceSha256: sha2562(managedPiMcpArgsNormalizerExtensionSource())
+    }));
+  }
+  function prepareEffectiveToolsBootstrapCache(input, sharedRuntime, executorCommand, tmpPath) {
+    const cacheRoot = resolve3(nonEmpty2(input.runtimeCacheRoot ?? join4(dirname3(input.runDir), ".runtime-cache"), "runtimeCacheRoot"));
+    const bootstrapRoot = join4(cacheRoot, "pi-effective-tools-jiti-v1");
+    mkdirSync3(bootstrapRoot, { recursive: true, mode: 448 });
+    const bootstrapRootStat = lstatSync3(bootstrapRoot);
+    if (!bootstrapRootStat.isDirectory() || bootstrapRootStat.isSymbolicLink()) {
+      throw new Error("pi_managed_mcp_bootstrap_cache_unsafe: root");
+    }
+    const key = effectiveToolsBootstrapKey(input, sharedRuntime, executorCommand);
+    const entryPath = join4(bootstrapRoot, key);
+    const markerPath = join4(entryPath, "manifest.json");
+    const sourceCachePath = join4(entryPath, "jiti");
+    const runCachePath = join4(tmpPath, "jiti");
+    let status = "miss";
+    if (existsSync3(entryPath)) {
+      try {
+        const entryStat = lstatSync3(entryPath);
+        const markerStat = lstatSync3(markerPath);
+        const marker = JSON.parse(readFileSync3(markerPath, "utf8"));
+        if (!entryStat.isDirectory() || entryStat.isSymbolicLink() || !markerStat.isFile() || markerStat.isSymbolicLink() || marker.schemaVersion !== PI_EFFECTIVE_TOOLS_BOOTSTRAP_SCHEMA_VERSION || marker.key !== key || marker.treeSha256 !== trustedTreeDigest(sourceCachePath)) throw new Error("bootstrap marker mismatch");
+        copyTrustedTree(sourceCachePath, runCachePath);
+        status = "hit";
+      } catch {
+        const resolvedEntry = resolve3(entryPath);
+        if (!within2(resolvedEntry, bootstrapRoot) || resolvedEntry === bootstrapRoot) {
+          throw new Error("pi_managed_mcp_bootstrap_cache_unsafe: entry");
+        }
+        makeTrustedTreeWritable(resolvedEntry);
+        rmSync2(resolvedEntry, { recursive: true, force: true });
+        status = "invalidated";
+      }
+    }
+    return { bootstrapRoot, entryPath, key, runCachePath, status };
+  }
+  function publishEffectiveToolsBootstrapCache(cache) {
+    if (cache.status === "hit") return "hit";
+    if (!existsSync3(cache.runCachePath)) return `${cache.status}_unavailable`;
+    const runCacheStat = lstatSync3(cache.runCachePath);
+    if (!runCacheStat.isDirectory() || runCacheStat.isSymbolicLink()) {
+      throw new Error("pi_managed_mcp_bootstrap_cache_unsafe: run cache");
+    }
+    if (existsSync3(cache.entryPath)) return "hit_raced";
+    const stagingPath = `${cache.entryPath}.tmp-${process.pid}-${currentTimeMs()}`;
+    try {
+      mkdirSync3(stagingPath, { mode: 448 });
+      const stagingCachePath = join4(stagingPath, "jiti");
+      copyTrustedTree(cache.runCachePath, stagingCachePath);
+      writePrivateFile2(join4(stagingPath, "manifest.json"), `${JSON.stringify({
+        schemaVersion: PI_EFFECTIVE_TOOLS_BOOTSTRAP_SCHEMA_VERSION,
+        key: cache.key,
+        treeSha256: trustedTreeDigest(stagingCachePath)
+      })}
+`);
+      try {
+        renameSync2(stagingPath, cache.entryPath);
+        makeTrustedTreeReadOnly(cache.entryPath);
+      } catch (error) {
+        if (error?.code !== "EEXIST" && error?.code !== "ENOTEMPTY") throw error;
+      }
+    } finally {
+      if (existsSync3(stagingPath)) {
+        makeTrustedTreeWritable(stagingPath);
+        rmSync2(stagingPath, { recursive: true, force: true });
+      }
+    }
+    return existsSync3(cache.entryPath) ? `${cache.status}_published` : `${cache.status}_unavailable`;
+  }
+  function writeEffectiveToolsProbePhase(phasePath, phase, attempt) {
+    let history = [];
+    if (existsSync3(phasePath)) {
+      try {
+        const parsed = JSON.parse(readFileSync3(phasePath, "utf8"));
+        history = Array.isArray(parsed.history) ? parsed.history.slice(0, 16) : [];
+      } catch {
+        history = [];
+      }
+    }
+    const atMs = currentTimeMs();
+    history.push({ phase, attempt, atMs });
+    const contents = `${JSON.stringify({ phase, attempt, atMs, history })}
+`;
+    if (existsSync3(phasePath)) {
+      const phaseStat = lstatSync3(phasePath);
+      if (!phaseStat.isFile() || phaseStat.isSymbolicLink()) {
+        throw new Error("pi_managed_mcp_probe_phase_unsafe");
+      }
+      writeFileSync3(phasePath, contents, { encoding: "utf8", mode: 384 });
+      chmodSync3(phasePath, 384);
+      return;
+    }
+    writeOwnedFileAtomic(phasePath, contents);
+  }
   function piMcpAdapterVersion(piHome) {
     const packagePath = join4(piHome, "npm", "node_modules", "pi-mcp-adapter", "package.json");
     let packageJson;
@@ -3708,58 +3951,131 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
       liveProbeAgeMs
     };
   }
-  function inspectEffectiveToolsProbeReceipt(receiptPath) {
-    if (!existsSync3(receiptPath)) return { phase: "missing", receipt: null };
+  function inspectEffectiveToolsProbeReceipt(receiptPath, phasePath) {
+    let phase = "missing";
+    let history = [];
+    if (existsSync3(phasePath)) {
+      try {
+        const phaseState = JSON.parse(readFileSync3(phasePath, "utf8"));
+        phase = typeof phaseState.phase === "string" ? phaseState.phase : "present";
+        history = Array.isArray(phaseState.history) ? phaseState.history : [];
+      } catch {
+        phase = "invalid";
+      }
+    }
+    if (!existsSync3(receiptPath)) return { phase, history, receipt: null };
     try {
       const receipt = JSON.parse(readFileSync3(receiptPath, "utf8"));
-      const phase = receipt?.status === "attested" || receipt?.status === "rejected" ? receipt.status : "present";
-      return { phase, receipt };
+      const receiptPhase = receipt?.status === "attested" || receipt?.status === "rejected" ? receipt.status : phase === "missing" ? "present" : phase;
+      return { phase: receiptPhase, history, receipt };
     } catch {
-      return { phase: "invalid", receipt: null };
+      return { phase: "invalid", history, receipt: null };
     }
   }
-  function attestDirectPiTools(executorCommand, env, input, spawnIdentity = null) {
+  function effectiveToolsProbePhaseDurations(history, attempt) {
+    const entries = history.filter((entry) => entry?.attempt === attempt && typeof entry.phase === "string" && Number.isFinite(entry.atMs)).sort((left, right) => left.atMs - right.atMs);
+    const at = (phase) => entries.find((entry) => entry.phase === phase)?.atMs;
+    const terminalAt = at("attested") ?? at("rejected");
+    const spawnedAt = at("spawned");
+    const loaderReadyAt = at("loader_ready");
+    const sessionStartAt = at("session_start");
+    return {
+      ...Number.isFinite(spawnedAt) && Number.isFinite(loaderReadyAt) ? { spawnedToLoaderReadyMs: Math.max(0, loaderReadyAt - spawnedAt) } : {},
+      ...Number.isFinite(loaderReadyAt) && Number.isFinite(sessionStartAt) ? { loaderReadyToSessionStartMs: Math.max(0, sessionStartAt - loaderReadyAt) } : {},
+      ...Number.isFinite(sessionStartAt) && Number.isFinite(terminalAt) ? { sessionStartToTerminalMs: Math.max(0, terminalAt - sessionStartAt) } : {}
+    };
+  }
+  function attestDirectPiTools(executorCommand, env, input, spawnIdentity = null, circuitKey = null) {
+    const circuit = circuitKey ? effectiveToolsProbeCircuits.get(circuitKey) : null;
+    if (circuit?.open === true) {
+      const retryAfterMs = Math.max(0, circuit.retryAtMs - currentTimeMs());
+      if (retryAfterMs > 0) {
+        const error = new Error(
+          `pi_managed_mcp_probe_circuit_open: connector generation probe circuit is open failures=${circuit.failures} lastPhase=${circuit.lastPhase} retryAfterMs=${retryAfterMs}`
+        );
+        error.code = "pi_managed_mcp_probe_circuit_open";
+        error.retryAfterMs = retryAfterMs;
+        throw error;
+      }
+      effectiveToolsProbeCircuits.set(circuitKey, { ...circuit, open: false, halfOpen: true });
+    }
     const startedAtMs = currentTimeMs();
-    const result3 = spawnSyncImpl(executorCommand, [
-      "--no-session",
-      "--no-approve",
-      "--no-skills",
-      "--no-context-files",
-      "--no-builtin-tools",
-      // The enforcement extensions live in the run profile, not an agent dir,
-      // so the probe must load them explicitly to measure the real run surface.
-      ...Array.isArray(input.extensionArgs) ? input.extensionArgs : [],
-      "--print",
-      "probe effective tools"
-    ], {
-      cwd: env.AMASTER_RUNTIME_EXECUTION_WORKDIR,
-      env: { ...env, AMASTER_PI_EFFECTIVE_TOOLS_MODE: "probe" },
-      encoding: "utf8",
-      timeout: PI_EFFECTIVE_TOOLS_ATTESTATION_TIMEOUT_MS,
-      killSignal: "SIGKILL",
-      maxBuffer: 1024 * 1024,
-      ...spawnIdentity ?? {}
-    });
+    const attempts = [PI_EFFECTIVE_TOOLS_ATTESTATION_TIMEOUT_MS, PI_EFFECTIVE_TOOLS_RETRY_TIMEOUT_MS];
+    let result3;
+    let completedAttempts = 0;
+    for (let index = 0; index < attempts.length; index += 1) {
+      const attempt = index + 1;
+      const timeout = attempts[index];
+      completedAttempts = attempt;
+      writeEffectiveToolsProbePhase(input.phasePath, "spawned", attempt);
+      result3 = spawnSyncImpl(executorCommand, [
+        "--no-session",
+        "--no-approve",
+        "--no-skills",
+        "--no-context-files",
+        "--no-builtin-tools",
+        // The enforcement extensions live in the run profile, not an agent dir,
+        // so the probe must load them explicitly to measure the real run surface.
+        ...Array.isArray(input.extensionArgs) ? input.extensionArgs : [],
+        "--print",
+        "probe effective tools"
+      ], {
+        cwd: env.AMASTER_RUNTIME_EXECUTION_WORKDIR,
+        env: {
+          ...env,
+          AMASTER_PI_EFFECTIVE_TOOLS_MODE: "probe",
+          AMASTER_PI_EFFECTIVE_TOOLS_ATTEMPT: String(attempt)
+        },
+        encoding: "utf8",
+        timeout,
+        killSignal: "SIGKILL",
+        maxBuffer: 1024 * 1024,
+        ...spawnIdentity ?? {}
+      });
+      if (result3.error?.code === "ETIMEDOUT" && attempt < attempts.length) continue;
+      break;
+    }
     const elapsedMs = Math.max(0, currentTimeMs() - startedAtMs);
     if (result3.error) {
       const code = typeof result3.error.code === "string" ? result3.error.code : "UNKNOWN";
-      const receiptDiagnostic = inspectEffectiveToolsProbeReceipt(input.receiptPath);
+      const receiptDiagnostic = inspectEffectiveToolsProbeReceipt(input.receiptPath, input.phasePath);
+      if (code === "ETIMEDOUT" && circuitKey) {
+        if (receiptDiagnostic.phase === "missing" || receiptDiagnostic.phase === "spawned") {
+          const previous = effectiveToolsProbeCircuits.get(circuitKey);
+          const failures = (previous?.failures ?? 0) + 1;
+          const shouldOpen = previous?.halfOpen === true || failures >= PI_EFFECTIVE_TOOLS_CIRCUIT_FAILURE_THRESHOLD;
+          const observedAtMs = currentTimeMs();
+          effectiveToolsProbeCircuits.set(circuitKey, {
+            failures,
+            lastPhase: receiptDiagnostic.phase,
+            open: shouldOpen,
+            halfOpen: false,
+            retryAtMs: shouldOpen ? observedAtMs + PI_EFFECTIVE_TOOLS_CIRCUIT_COOLDOWN_MS : null
+          });
+        } else {
+          effectiveToolsProbeCircuits.delete(circuitKey);
+        }
+      } else if (circuitKey) {
+        effectiveToolsProbeCircuits.delete(circuitKey);
+      }
       const error = new Error(
-        `pi_managed_mcp_effective_tools_failed: probe error=${code} elapsedMs=${elapsedMs} timeoutMs=${PI_EFFECTIVE_TOOLS_ATTESTATION_TIMEOUT_MS} receiptPhase=${receiptDiagnostic.phase}`
+        `pi_managed_mcp_effective_tools_failed: probe error=${code} elapsedMs=${elapsedMs} timeoutMs=${PI_EFFECTIVE_TOOLS_ATTESTATION_TIMEOUT_MS} retryTimeoutMs=${PI_EFFECTIVE_TOOLS_RETRY_TIMEOUT_MS} totalBudgetMs=${PI_EFFECTIVE_TOOLS_TOTAL_TIMEOUT_MS} attempts=${completedAttempts} receiptPhase=${receiptDiagnostic.phase}`
       );
       if (code === "ETIMEDOUT") error.code = "pi_managed_mcp_probe_timeout";
       throw error;
     }
     if (result3.status !== 0) {
-      const receiptDiagnostic = inspectEffectiveToolsProbeReceipt(input.receiptPath);
+      if (circuitKey) effectiveToolsProbeCircuits.delete(circuitKey);
+      const receiptDiagnostic = inspectEffectiveToolsProbeReceipt(input.receiptPath, input.phasePath);
       let receiptError = "receipt unavailable";
       if (typeof receiptDiagnostic.receipt?.error === "string" && receiptDiagnostic.receipt.error.length > 0) {
         receiptError = receiptDiagnostic.receipt.error.slice(0, 512);
       }
       throw new Error(
-        `pi_managed_mcp_effective_tools_failed: probe exit=${result3.status ?? "unknown"} elapsedMs=${elapsedMs} timeoutMs=${PI_EFFECTIVE_TOOLS_ATTESTATION_TIMEOUT_MS} receiptPhase=${receiptDiagnostic.phase} reason=${receiptError}`
+        `pi_managed_mcp_effective_tools_failed: probe exit=${result3.status ?? "unknown"} elapsedMs=${elapsedMs} timeoutMs=${PI_EFFECTIVE_TOOLS_ATTESTATION_TIMEOUT_MS} retryTimeoutMs=${PI_EFFECTIVE_TOOLS_RETRY_TIMEOUT_MS} totalBudgetMs=${PI_EFFECTIVE_TOOLS_TOTAL_TIMEOUT_MS} attempts=${completedAttempts} receiptPhase=${receiptDiagnostic.phase} reason=${receiptError}`
       );
     }
+    if (circuitKey) effectiveToolsProbeCircuits.delete(circuitKey);
     let receipt;
     try {
       receipt = JSON.parse(readFileSync3(input.receiptPath, "utf8"));
@@ -3776,6 +4092,8 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
     if (sha2562(readFileSync3(input.cachePath)) !== input.cacheSha256) {
       throw new Error("pi_managed_mcp_effective_tools_failed: cache drifted during probe");
     }
+    if (circuitKey) effectiveToolsProbeCircuits.delete(circuitKey);
+    const phaseDiagnostic = inspectEffectiveToolsProbeReceipt(input.receiptPath, input.phasePath);
     return {
       effectiveToolProxyMode: receipt.proxyMode,
       effectiveToolProxyPresent: receipt.proxyPresent,
@@ -3784,6 +4102,16 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
       effectiveToolProbeAt: receipt.attestedAt,
       effectiveToolProbeElapsedMs: elapsedMs,
       effectiveToolProbeTimeoutMs: PI_EFFECTIVE_TOOLS_ATTESTATION_TIMEOUT_MS,
+      effectiveToolProbeTotalBudgetMs: PI_EFFECTIVE_TOOLS_TOTAL_TIMEOUT_MS,
+      effectiveToolProbeCircuitCooldownMs: PI_EFFECTIVE_TOOLS_CIRCUIT_COOLDOWN_MS,
+      effectiveToolProbeAttempts: completedAttempts,
+      effectiveToolProbeSoftSlow: elapsedMs >= PI_EFFECTIVE_TOOLS_SOFT_SLOW_MS,
+      effectiveToolProbePhase: phaseDiagnostic.phase,
+      effectiveToolProbePhaseHistory: phaseDiagnostic.history,
+      effectiveToolProbePhaseDurationsMs: effectiveToolsProbePhaseDurations(
+        phaseDiagnostic.history,
+        completedAttempts
+      ),
       effectiveToolBindings: receipt.effectiveToolBindings
     };
   }
@@ -3902,6 +4230,7 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         const attestorSourceSha256 = sha2562(managedPiEffectiveToolsAttestorExtensionSource());
         const manifestPath = join4(profileRoot, "effective-tools-manifest.json");
         const receiptPath = join4(tmp, "effective-tools-receipt.json");
+        const phasePath = join4(tmp, "effective-tools-phase.json");
         const manifest = {
           schemaVersion: MANAGED_PI_EFFECTIVE_TOOLS_SCHEMA_VERSION,
           serverName: SUPPORTED_SERVER_NAME2,
@@ -3927,6 +4256,7 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
           cachePath,
           manifestPath,
           receiptPath,
+          phasePath,
           cacheSha256,
           cacheContentsBase64: Buffer.from(readFileSync3(cachePath)).toString("base64"),
           configPath,
@@ -3961,11 +4291,21 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
           AMASTER_PI_EFFECTIVE_TOOLS_MODE: "enforce",
           AMASTER_PI_EFFECTIVE_TOOLS_MANIFEST: directAttestationInput.manifestPath,
           AMASTER_PI_EFFECTIVE_TOOLS_RECEIPT: directAttestationInput.receiptPath,
+          AMASTER_PI_EFFECTIVE_TOOLS_PHASE: directAttestationInput.phasePath,
           AMASTER_PI_EFFECTIVE_TOOLS_CACHE: directAttestationInput.cachePath,
           AMASTER_PI_EFFECTIVE_TOOLS_CONFIG: directAttestationInput.configPath
         } : {},
         ...input.sourceAcquisition ? sourceAcquisitionBrowserEnvironment(input.sourceAcquisition, input.baseEnv) : {}
       };
+      if (directAttestationInput) {
+        writeEffectiveToolsProbePhase(directAttestationInput.phasePath, "prepared", 0);
+      }
+      const effectiveToolsBootstrapCache = directAttestationInput ? prepareEffectiveToolsBootstrapCache(
+        input,
+        sharedRuntime,
+        nonEmpty2(input.executorCommand, "executorCommand"),
+        tmp
+      ) : null;
       const spawnIdentity = typeof input.prepareExecutorAccess === "function" ? input.prepareExecutorAccess({ profileRoot, workspaceRoot: cwd }) : null;
       const executorAttestation = attestPi(
         nonEmpty2(input.executorCommand, "executorCommand"),
@@ -3978,8 +4318,10 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         nonEmpty2(input.executorCommand, "executorCommand"),
         env,
         directAttestationInput,
-        spawnIdentity
+        spawnIdentity,
+        effectiveToolsBootstrapCache?.key ?? null
       ) : {};
+      const effectiveToolProbeBootstrapCache = effectiveToolsBootstrapCache ? publishEffectiveToolsBootstrapCache(effectiveToolsBootstrapCache) : null;
       const runExitClosureCacheOwnership = directAttestationInput ? ownershipStatSyncImpl(directAttestationInput.cachePath) : null;
       const attestationFacts = {
         connectorVersion: nonEmpty2(input.connectorVersion, "connectorVersion"),
@@ -3990,7 +4332,9 @@ ${result3.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         mcpArgsNormalization: mcpToolMode === MANAGED_PI_DIRECT_TYPED_MCP_TOOL_MODE ? "none" : MANAGED_PI_MCP_ARGS_NORMALIZATION,
         ...directCatalog ? {
           catalogSetHash: directCatalog.setHash,
-          ...effectiveToolsAttestation
+          ...effectiveToolsAttestation,
+          effectiveToolProbeBootstrapKey: effectiveToolsBootstrapCache?.key ?? null,
+          effectiveToolProbeBootstrapCache
         } : {},
         configMode: MANAGED_PI_CONFIG_MODE_SHARED,
         namespace: SUPPORTED_SERVER_NAME2,
@@ -10535,7 +10879,7 @@ var source_acquisition_compatibility_default = {
 };
 
 // src/amaster-runtime-daemon.mjs
-var CONNECTOR_VERSION = "0.1.1-beta.65";
+var CONNECTOR_VERSION = "0.1.1-beta.67";
 var CONNECTOR_CONTRACT_VERSION = "2026-06-04.v1";
 var SOURCE_ACQUISITION_CAPABILITY = source_acquisition_compatibility_default.profileVersion;
 var SOURCE_ACQUISITION_PROFILE_VERSION = source_acquisition_compatibility_default.profileVersion;
@@ -15240,6 +15584,7 @@ async function executeRunCommand(config, command) {
           executorCommand: invocation.command,
           executorHome: workspace.executorHome,
           runDir: workspace.runDir,
+          runtimeCacheRoot: join12(dirname7(config.daemonStateFile), "cache"),
           cwd,
           runtimeAuth: commandRuntimeAuth(command),
           nativeSession: asRecord(asRecord(command.payload).nativeSession),

package/dist/amaster-runtime.mjs

@@ -6,7 +6,7 @@ import { basename, dirname, join, resolve } from "node:path";
 import { homedir, hostname } from "node:os";
 import { fileURLToPath } from "node:url";
 
-const CONNECTOR_VERSION = "0.1.1-beta.65";
+const CONNECTOR_VERSION = "0.1.1-beta.67";
 
 const CAPABILITIES = [
   "remote_registration",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amaster.ai/employee-runtime-connector",
-  "version": "0.1.1-beta.65",
+  "version": "0.1.1-beta.67",
   "description": "MirrorX runtime connector CLI and daemon",
   "license": "MIT",
   "type": "module",