@amaster.ai/employee-runtime-connector 0.1.1-beta.272 → 0.1.1-beta.274

package/dist/amaster-runtime-daemon.mjs

@@ -17758,6 +17758,7 @@ function managedPiProviderToolContract(tools) {
   }
   const entries = definitions.map(({ name, schemaHash }) => ({ name, schemaHash }));
   return {
+    definitions,
     entries,
     effectiveToolSchemaBytes: definitions.reduce((total, entry) => total + entry.schemaBytes, 0),
     effectiveToolSetSha256: sha256(stableJson(entries)),
@@ -18353,8 +18354,8 @@ function observedPiFinalContextToolContract(input) {
   const expectedNames = Array.isArray(input?.toolNames) ? [...input.toolNames] : [];
   if (expectedNames.length === 0 || expectedNames.some((name) => typeof name !== "string" || !name) || new Set(expectedNames).size !== expectedNames.length) fail2("observed_tool_contract_invalid");
   expectedNames.sort();
-  const finalEffectiveTools = input?.profileAttestation?.finalEffectiveTools;
-  const observed = Array.isArray(finalEffectiveTools) ? finalEffectiveTools.filter((entry) => expectedNames.includes(entry?.name)).map((entry) => ({
+  const finalRequiredTools = input?.profileAttestation?.finalRequiredTools;
+  const observed = Array.isArray(finalRequiredTools) ? finalRequiredTools.filter((entry) => expectedNames.includes(entry?.name)).map((entry) => ({
     name: entry.name,
     schemaHash: entry.schemaHash,
     schemaBytes: entry.schemaBytes
@@ -21867,7 +21868,7 @@ function piMcpAdapterServerConfigIdentity(definition, adapterVersion) {
 import { createHash as createHash6 } from "node:crypto";
 var MANAGED_PI_EFFECTIVE_TOOLS_ATTESTOR_FILENAME = "amaster-effective-tools-attestor.js";
 var MANAGED_PI_EFFECTIVE_TOOLS_SCHEMA_VERSION = "amaster.pi-effective-tools.v1";
-function normalizedSchema(value, adapterNormalized) {
+function normalizedPiToolSchema(value, adapterNormalized) {
   const schema = value && typeof value === "object" && !Array.isArray(value) ? value : {};
   if (!adapterNormalized) return schema;
   const { $schema: _schema, additionalProperties: _additionalProperties, ...normalized } = schema;
@@ -21883,7 +21884,7 @@ function stablePiJson(value) {
   return `{${keys.map((key) => `${JSON.stringify(key)}:${stablePiJson(value[key])}`).join(",")}}`;
 }
 function stablePiToolSchemaHash(schema, options = {}) {
-  return createHash6("sha256").update(stablePiJson(normalizedSchema(schema, options.adapterNormalized === true))).digest("hex");
+  return createHash6("sha256").update(stablePiJson(normalizedPiToolSchema(schema, options.adapterNormalized === true))).digest("hex");
 }
 function stablePiEffectiveToolSetHash(entries) {
   const normalized = entries.map((entry) => ({ name: entry.name, schemaHash: entry.schemaHash ?? entry.effectiveSchemaHash })).sort((left, right) => left.name.localeCompare(right.name));
@@ -22749,17 +22750,9 @@ function createManagedPiMcpProfileApi(options = {}) {
   const SESSION_ROLLOUT_MARKER3 = ".amaster-pi-session-rollout.json";
   const DEFAULT_SESSION_ROLLOUT_TTL_MS3 = 24 * 60 * 60 * 1e3;
   const PI_VERSION_ATTESTATION_TIMEOUT_MS = 3e4;
-  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 record8(value) {
     return value && typeof value === "object" && !Array.isArray(value) ? value : {};
   }
@@ -22931,165 +22924,7 @@ function createManagedPiMcpProfileApi(options = {}) {
     }
     return hash.digest("hex");
   }
-  function copyTrustedTree(sourcePath, targetPath) {
-    const source = resolve8(sourcePath);
-    const sourceStat = lstatSync8(source);
-    if (!sourceStat.isDirectory() || sourceStat.isSymbolicLink()) {
-      throw new Error(`pi_managed_mcp_bootstrap_cache_unsafe: ${source}`);
-    }
-    mkdirSync4(targetPath, { recursive: true, mode: 448 });
-    chmodSync6(targetPath, 448);
-    for (const entry of readdirSync4(source, { withFileTypes: true })) {
-      const from = join9(source, entry.name);
-      const to = join9(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);
-      chmodSync6(to, 384 | lstatSync8(from).mode & 73);
-    }
-  }
-  function makeTrustedTreeReadOnly(rootPath) {
-    const root = resolve8(rootPath);
-    const pending = [root];
-    const directories = [];
-    while (pending.length > 0) {
-      const current = pending.pop();
-      const currentStat = lstatSync8(current);
-      if (currentStat.isSymbolicLink()) throw new Error(`pi_managed_mcp_bootstrap_cache_unsafe: ${current}`);
-      if (currentStat.isDirectory()) {
-        directories.push(current);
-        for (const entry of readdirSync4(current)) pending.push(join9(current, entry));
-        continue;
-      }
-      if (!currentStat.isFile()) throw new Error(`pi_managed_mcp_bootstrap_cache_unsafe: ${current}`);
-      chmodSync6(current, 256 | currentStat.mode & 73);
-    }
-    for (const directory of directories.reverse()) chmodSync6(directory, 320);
-  }
-  function makeTrustedTreeWritable(rootPath) {
-    const pending = [resolve8(rootPath)];
-    while (pending.length > 0) {
-      const current = pending.pop();
-      const currentStat = lstatSync8(current);
-      if (currentStat.isSymbolicLink()) throw new Error(`pi_managed_mcp_bootstrap_cache_unsafe: ${current}`);
-      if (currentStat.isDirectory()) {
-        chmodSync6(current, 448);
-        for (const entry of readdirSync4(current)) pending.push(join9(current, entry));
-        continue;
-      }
-      if (!currentStat.isFile()) throw new Error(`pi_managed_mcp_bootstrap_cache_unsafe: ${current}`);
-      chmodSync6(current, 384 | currentStat.mode & 73);
-    }
-  }
-  function piLoaderIdentity(executorPath) {
-    let cursor = dirname6(realpathSync6(executorPath));
-    for (let depth = 0; depth < 4; depth += 1) {
-      const packagePath = join9(cursor, "package.json");
-      const loaderPath = join9(cursor, "dist", "core", "extensions", "loader.js");
-      if (existsSync8(packagePath) && existsSync8(loaderPath)) {
-        const packageJson = JSON.parse(readFileSync9(packagePath, "utf8"));
-        return sha2565(stablePiJson({
-          name: packageJson.name,
-          version: packageJson.version,
-          loaderSha256: sha2565(readFileSync9(loaderPath))
-        }));
-      }
-      cursor = dirname6(cursor);
-    }
-    return sha2565(readFileSync9(realpathSync6(executorPath)));
-  }
-  function effectiveToolsBootstrapKey(input, sharedRuntime, executorCommand) {
-    const adapterRoot = sharedRuntime.adapterRoot ? resolve8(nonEmpty3(sharedRuntime.adapterRoot, "sharedRuntime.adapterRoot")) : join9(sharedRuntime.home, "npm", "node_modules", "pi-mcp-adapter");
-    const resolvedExecutorCommand = resolvePiExecutablePath(executorCommand, input.baseEnv);
-    return sha2565(stablePiJson({
-      schemaVersion: PI_EFFECTIVE_TOOLS_BOOTSTRAP_SCHEMA_VERSION,
-      connectorVersion: nonEmpty3(input.connectorVersion, "connectorVersion"),
-      executorIdentity: piExecutableIdentity(resolvedExecutorCommand),
-      loaderIdentity: piLoaderIdentity(resolvedExecutorCommand),
-      nodeVersion: process.version,
-      nodeModulesAbi: process.versions.modules,
-      platform: platform3(),
-      arch: arch3(),
-      // 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: sha2565(managedPiEffectiveToolsAttestorExtensionSource())
-    }));
-  }
-  function prepareEffectiveToolsBootstrapCache(input, sharedRuntime, executorCommand, tmpPath) {
-    const cacheRoot = resolve8(nonEmpty3(input.runtimeCacheRoot ?? join9(dirname6(input.runDir), ".runtime-cache"), "runtimeCacheRoot"));
-    const bootstrapRoot = join9(cacheRoot, "pi-effective-tools-jiti-v1");
-    mkdirSync4(bootstrapRoot, { recursive: true, mode: 448 });
-    const bootstrapRootStat = lstatSync8(bootstrapRoot);
-    if (!bootstrapRootStat.isDirectory() || bootstrapRootStat.isSymbolicLink()) {
-      throw new Error("pi_managed_mcp_bootstrap_cache_unsafe: root");
-    }
-    const key = effectiveToolsBootstrapKey(input, sharedRuntime, executorCommand);
-    const entryPath = join9(bootstrapRoot, key);
-    const markerPath = join9(entryPath, "manifest.json");
-    const sourceCachePath = join9(entryPath, "jiti");
-    const runCachePath = join9(tmpPath, "jiti");
-    let status = "miss";
-    if (existsSync8(entryPath)) {
-      try {
-        const entryStat = lstatSync8(entryPath);
-        const markerStat = lstatSync8(markerPath);
-        const marker = JSON.parse(readFileSync9(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 = resolve8(entryPath);
-        if (!within4(resolvedEntry, bootstrapRoot) || resolvedEntry === bootstrapRoot) {
-          throw new Error("pi_managed_mcp_bootstrap_cache_unsafe: entry");
-        }
-        makeTrustedTreeWritable(resolvedEntry);
-        rmSync5(resolvedEntry, { recursive: true, force: true });
-        status = "invalidated";
-      }
-    }
-    return { bootstrapRoot, entryPath, key, runCachePath, status };
-  }
-  function publishEffectiveToolsBootstrapCache(cache) {
-    if (cache.status === "hit") return "hit";
-    if (!existsSync8(cache.runCachePath)) return `${cache.status}_unavailable`;
-    const runCacheStat = lstatSync8(cache.runCachePath);
-    if (!runCacheStat.isDirectory() || runCacheStat.isSymbolicLink()) {
-      throw new Error("pi_managed_mcp_bootstrap_cache_unsafe: run cache");
-    }
-    if (existsSync8(cache.entryPath)) return "hit_raced";
-    const stagingPath = `${cache.entryPath}.tmp-${process.pid}-${currentTimeMs()}`;
-    try {
-      mkdirSync4(stagingPath, { mode: 448 });
-      const stagingCachePath = join9(stagingPath, "jiti");
-      copyTrustedTree(cache.runCachePath, stagingCachePath);
-      writePrivateFile2(join9(stagingPath, "manifest.json"), `${JSON.stringify({
-        schemaVersion: PI_EFFECTIVE_TOOLS_BOOTSTRAP_SCHEMA_VERSION,
-        key: cache.key,
-        treeSha256: trustedTreeDigest(stagingCachePath)
-      })}
-`);
-      try {
-        renameSync4(stagingPath, cache.entryPath);
-        makeTrustedTreeReadOnly(cache.entryPath);
-      } catch (error) {
-        if (error?.code !== "EEXIST" && error?.code !== "ENOTEMPTY") throw error;
-      }
-    } finally {
-      if (existsSync8(stagingPath)) {
-        makeTrustedTreeWritable(stagingPath);
-        rmSync5(stagingPath, { recursive: true, force: true });
-      }
-    }
-    return existsSync8(cache.entryPath) ? `${cache.status}_published` : `${cache.status}_unavailable`;
-  }
-  function writeEffectiveToolsProbePhase(phasePath, phase, attempt) {
+  function writeEffectiveToolsPhase(phasePath, phase, attempt) {
     let history = [];
     if (existsSync8(phasePath)) {
       try {
@@ -23971,189 +23806,6 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
       liveProbeAgeMs
     };
   }
-  function inspectEffectiveToolsProbeReceipt(receiptPath, phasePath) {
-    let phase = "missing";
-    let history = [];
-    if (existsSync8(phasePath)) {
-      try {
-        const phaseState = JSON.parse(readFileSync9(phasePath, "utf8"));
-        phase = typeof phaseState.phase === "string" ? phaseState.phase : "present";
-        history = Array.isArray(phaseState.history) ? phaseState.history : [];
-      } catch {
-        phase = "invalid";
-      }
-    }
-    if (!existsSync8(receiptPath)) return { phase, history, receipt: null };
-    try {
-      const receipt = JSON.parse(readFileSync9(receiptPath, "utf8"));
-      const receiptPhase = receipt?.status === "attested" || receipt?.status === "rejected" ? receipt.status : phase === "missing" ? "present" : phase;
-      return { phase: receiptPhase, history, receipt };
-    } catch {
-      return { phase: "invalid", history, receipt: 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 attempts = [PI_EFFECTIVE_TOOLS_ATTESTATION_TIMEOUT_MS, PI_EFFECTIVE_TOOLS_RETRY_TIMEOUT_MS];
-    let result2;
-    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);
-      const resolvedExecutorCommand = resolveExecutorCommand(executorCommand, env) ?? executorCommand;
-      result2 = spawnSyncImpl(resolvedExecutorCommand, [
-        "--no-session",
-        "--no-approve",
-        "--no-skills",
-        "--no-context-files",
-        // The enforcement extensions live in the run profile, not an agent dir,
-        // so the probe must load them explicitly alongside the user's normal Pi
-        // extensions and tools 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,
-        ...isWindowsCommandShim(resolvedExecutorCommand) ? { shell: true } : {},
-        ...spawnIdentity ?? {}
-      });
-      if (result2.error?.code === "ETIMEDOUT" && attempt < attempts.length) continue;
-      break;
-    }
-    const elapsedMs = Math.max(0, currentTimeMs() - startedAtMs);
-    if (result2.error) {
-      const code = typeof result2.error.code === "string" ? result2.error.code : "UNKNOWN";
-      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} 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 (result2.status !== 0) {
-      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=${result2.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(readFileSync9(input.receiptPath, "utf8"));
-    } catch {
-      throw new Error("pi_managed_mcp_effective_tools_failed: probe receipt missing");
-    }
-    const proxyPresenceMismatch = input.proxyMode === "required" ? receipt.proxyPresent !== true : input.proxyMode === "forbidden" && receipt.proxyPresent !== false;
-    if (receipt.status !== "attested" || receipt.mode !== "probe" || receipt.proxyMode !== input.proxyMode || proxyPresenceMismatch || receipt.effectiveSetHash !== input.effectiveSetHash || receipt.attestorSourceSha256 !== input.attestorSourceSha256 || receipt.configSha256 !== input.configSha256) {
-      throw new Error("pi_managed_mcp_effective_tools_failed: probe receipt mismatch");
-    }
-    const finalEffectiveTools = Array.isArray(receipt.finalEffectiveTools) ? receipt.finalEffectiveTools : [];
-    const finalEffectiveToolNames = finalEffectiveTools.map((tool) => tool?.name).filter((name) => typeof name === "string").sort();
-    const expectedFinalActiveToolNames = Array.isArray(input.finalActiveToolNames) ? input.finalActiveToolNames.slice().sort() : [];
-    const finalEffectiveSchemaBytes = finalEffectiveTools.reduce((total, tool) => total + (Number.isSafeInteger(tool?.schemaBytes) && tool.schemaBytes >= 0 ? tool.schemaBytes : Number.NaN), 0);
-    const finalEffectiveToolNameSet = new Set(finalEffectiveToolNames);
-    if (finalEffectiveTools.length === 0 || !/^[a-f0-9]{64}$/.test(receipt.finalEffectiveSetHash ?? "") || stablePiEffectiveToolSetHash(finalEffectiveTools) !== receipt.finalEffectiveSetHash || expectedFinalActiveToolNames.some((name) => !finalEffectiveToolNameSet.has(name)) || !Number.isSafeInteger(receipt.finalEffectiveSchemaBytes) || receipt.finalEffectiveSchemaBytes !== finalEffectiveSchemaBytes) {
-      throw new Error("pi_managed_mcp_effective_tools_failed: final tool schema receipt mismatch");
-    }
-    if (sha2565(readFileSync9(input.configPath)) !== input.configSha256) {
-      throw new Error("pi_managed_mcp_effective_tools_failed: config drifted during probe");
-    }
-    const finalCacheBytes = readFileSync9(input.cachePath);
-    if (receipt.cacheSha256 !== sha2565(finalCacheBytes) || stablePiManagedMcpCacheSemanticHash(finalCacheBytes, { ignoredServers: input.userMcpServerNames }) !== input.cacheSemanticHash) {
-      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,
-      effectiveToolSetHash: receipt.effectiveSetHash,
-      finalEffectiveToolSetHash: receipt.finalEffectiveSetHash,
-      finalEffectiveToolSchemaBytes: receipt.finalEffectiveSchemaBytes,
-      finalEffectiveToolCount: finalEffectiveTools.length,
-      finalEffectiveTools: finalEffectiveTools.map((tool) => ({
-        name: tool.name,
-        schemaHash: tool.schemaHash,
-        schemaBytes: tool.schemaBytes
-      })),
-      effectiveToolProbeDigest: sha2565(stablePiJson(receipt)),
-      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
-    };
-  }
   function prepareDirectPiToolAttestation(input) {
     const cachePath = join9(input.profileRoot, "mcp-cache.json");
     if (!input.directCatalog) {
@@ -24216,6 +23868,26 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
     };
     writePrivateFile2(manifestPath, `${JSON.stringify(manifest, null, 2)}
 `);
+    const providerToolContract = managedPiProviderToolContract(input.directCatalog.tools.map((tool) => ({
+      name: tool.exposedName,
+      description: tool.description,
+      parameters: normalizedPiToolSchema(tool.inputSchema, true)
+    })));
+    const declaredToolContract = {
+      effectiveToolContractSource: "governed_catalog",
+      effectiveToolValidationMode: "same_run_session_start_and_provider_request",
+      effectiveToolProxyMode: manifest.proxyMode,
+      effectiveToolSetHash: manifest.effectiveSetHash,
+      finalRequiredToolSetHash: providerToolContract.effectiveToolSetSha256,
+      finalRequiredToolSchemaBytes: providerToolContract.effectiveToolSchemaBytes,
+      finalRequiredToolCount: providerToolContract.effectiveToolCount,
+      finalRequiredTools: providerToolContract.definitions,
+      effectiveToolBindings: input.directCatalog.tools.map((tool) => ({
+        canonicalName: tool.name,
+        exposedName: tool.exposedName,
+        effectiveSchemaHash: tool.effectiveSchemaHash
+      })).sort((left, right) => left.canonicalName.localeCompare(right.canonicalName))
+    };
     const closureTools = input.directCatalog.tools.filter((tool) => RUN_EXIT_CLOSURE_DIRECT_TYPED_TOOL_NAMES.has(tool.name));
     const closureProfile = closureTools.length === RUN_EXIT_CLOSURE_DIRECT_TYPED_TOOL_NAMES.size ? (() => {
       const closureToolNames = closureTools.map((tool) => tool.exposedName);
@@ -24272,7 +23944,7 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         finalContextToolContract: managedPiProviderToolContract(closureTools.map((tool) => ({
           name: tool.exposedName,
           description: tool.description,
-          parameters: tool.inputSchema
+          parameters: normalizedPiToolSchema(tool.inputSchema, true)
         }))),
         cacheContentsBase64: closureCacheBytes.toString("base64"),
         cacheSha256: sha2565(closureCacheBytes),
@@ -24302,6 +23974,7 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         finalActiveToolNames: effectiveRunToolAllowlist,
         userMcpServerNames: input.userMcpServerNames,
         profileToolAllowlist: null,
+        declaredToolContract,
         closureProfile
       }
     };
@@ -24387,6 +24060,10 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         if (!existsSync8(adapterExtensionPath)) {
           throw new Error("pi_managed_mcp_adapter_extension_missing");
         }
+        const adapterRootStat = lstatSync8(dirname6(adapterExtensionPath));
+        if (!adapterRootStat.isDirectory() || adapterRootStat.isSymbolicLink()) {
+          throw new Error("pi_managed_mcp_adapter_extension_unsafe");
+        }
         const adapterExtensionStat = lstatSync8(adapterExtensionPath);
         if (!adapterExtensionStat.isFile() || adapterExtensionStat.isSymbolicLink()) {
           throw new Error("pi_managed_mcp_adapter_extension_unsafe");
@@ -24469,14 +24146,8 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         } : {}
       };
       if (directAttestationInput) {
-        writeEffectiveToolsProbePhase(directAttestationInput.phasePath, "prepared", 0);
+        writeEffectiveToolsPhase(directAttestationInput.phasePath, "prepared", 0);
       }
-      const effectiveToolsBootstrapCache = directAttestationInput ? prepareEffectiveToolsBootstrapCache(
-        input,
-        sharedRuntime,
-        nonEmpty3(input.executorCommand, "executorCommand"),
-        tmp
-      ) : null;
       const spawnIdentity = typeof input.prepareExecutorAccess === "function" ? input.prepareExecutorAccess({ profileRoot, workspaceRoot: cwd }) : null;
       const executorAttestation = attestPi(
         nonEmpty3(input.executorCommand, "executorCommand"),
@@ -24485,14 +24156,6 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         config,
         spawnIdentity
       );
-      const effectiveToolsAttestation = directAttestationInput ? attestDirectPiTools(
-        nonEmpty3(input.executorCommand, "executorCommand"),
-        env,
-        directAttestationInput,
-        spawnIdentity,
-        effectiveToolsBootstrapCache?.key ?? null
-      ) : {};
-      const effectiveToolProbeBootstrapCache = effectiveToolsBootstrapCache ? publishEffectiveToolsBootstrapCache(effectiveToolsBootstrapCache) : null;
       const runExitClosureOwnership = directAttestationInput ? {
         cache: ownershipStatSyncImpl(directAttestationInput.cachePath),
         manifest: ownershipStatSyncImpl(directAttestationInput.manifestPath),
@@ -24507,9 +24170,7 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         mcpArgsNormalization: "none",
         ...directCatalog ? {
           catalogSetHash: directCatalog.setHash,
-          ...effectiveToolsAttestation,
-          effectiveToolProbeBootstrapKey: effectiveToolsBootstrapCache?.key ?? null,
-          effectiveToolProbeBootstrapCache
+          ...directAttestationInput.declaredToolContract
         } : {},
         configMode: MANAGED_PI_CONFIG_MODE_SHARED,
         namespace: SUPPORTED_SERVER_NAME3,
@@ -24891,18 +24552,8 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         } : {}
       };
       if (directAttestationInput) {
-        writeEffectiveToolsProbePhase(directAttestationInput.phasePath, "prepared", 0);
+        writeEffectiveToolsPhase(directAttestationInput.phasePath, "prepared", 0);
       }
-      const sharedRuntime = {
-        home: sourcePiHome,
-        ...desktopAttestationReadiness?.ready ? { adapterRoot: desktopAttestationReadiness.adapterRoot } : {}
-      };
-      const effectiveToolsBootstrapCache = directAttestationInput ? prepareEffectiveToolsBootstrapCache(
-        input,
-        sharedRuntime,
-        nonEmpty3(input.executorCommand, "executorCommand"),
-        tmp
-      ) : null;
       const spawnIdentity = typeof input.prepareExecutorAccess === "function" ? input.prepareExecutorAccess({ profileRoot, workspaceRoot: cwd }) : null;
       const executorAttestation = directAttestationInput ? attestPi(
         nonEmpty3(input.executorCommand, "executorCommand"),
@@ -24911,14 +24562,6 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         config,
         spawnIdentity
       ) : {};
-      const effectiveToolsAttestation = directAttestationInput ? attestDirectPiTools(
-        nonEmpty3(input.executorCommand, "executorCommand"),
-        env,
-        directAttestationInput,
-        spawnIdentity,
-        effectiveToolsBootstrapCache?.key ?? null
-      ) : {};
-      const effectiveToolProbeBootstrapCache = effectiveToolsBootstrapCache ? publishEffectiveToolsBootstrapCache(effectiveToolsBootstrapCache) : null;
       const runExitClosureOwnership = directAttestationInput ? {
         cache: ownershipStatSyncImpl(directAttestationInput.cachePath),
         manifest: ownershipStatSyncImpl(directAttestationInput.manifestPath),
@@ -24933,9 +24576,7 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         mcpArgsNormalization: "none",
         ...directCatalog ? {
           catalogSetHash: directCatalog.setHash,
-          ...effectiveToolsAttestation,
-          effectiveToolProbeBootstrapKey: effectiveToolsBootstrapCache?.key ?? null,
-          effectiveToolProbeBootstrapCache
+          ...directAttestationInput.declaredToolContract
         } : {},
         configMode: "desktop_delegated_runtime_action_bridge",
         namespace: SUPPORTED_SERVER_NAME3,
@@ -33703,11 +33344,11 @@ function resolvePiModelContextBudget({
 }) {
   const instructionBytes = [...finalAgentInstructionFiles.values()].reduce((total, entry) => total + Number(entry.byteSize ?? 0), 0);
   const profileAttestation = record7(managedMcpProfile?.attestation);
-  const toolSchemaBytes = Number(profileAttestation.finalEffectiveToolSchemaBytes);
+  const toolSchemaBytes = Number(profileAttestation.finalRequiredToolSchemaBytes);
   if (!Number.isSafeInteger(toolSchemaBytes) || toolSchemaBytes < 1) {
     throw stableContextError(
       "model_context_attestation_unavailable",
-      "final tool schema size is missing"
+      "required governed tool schema size is missing"
     );
   }
   const skillMetadataBytes = Number(profileAttestation.enabledSkillMetadataBytes ?? 0);
@@ -33736,7 +33377,7 @@ function resolvePiModelContextBudget({
     knownFixedInputTokens,
     fixedInputBreakdown: {
       projectInstructionBytes: instructionBytes,
-      effectiveToolSchemaBytes: toolSchemaBytes,
+      requiredGovernedToolSchemaBytes: toolSchemaBytes,
       skillMetadataBytes
     },
     dynamicInputTokens,
@@ -34051,7 +33692,7 @@ function assertRequiredTaskAttachmentMaterialized(input, materialized) {
 }
 
 // src/amaster-runtime-daemon.mjs
-var CONNECTOR_VERSION = "0.1.1-beta.272";
+var CONNECTOR_VERSION = "0.1.1-beta.274";
 var CONNECTOR_CONTRACT_VERSION = "2026-06-04.v1";
 var daemonRequire = createRequire(import.meta.url);
 var MAX_CHECKPOINT_BYTES = 20 * 1024 * 1024;
@@ -35704,11 +35345,12 @@ function requireEffectiveToolSchemaAttestation(contextContract, executorKind, go
   const attestation = asRecord(managedMcpProfile?.attestation);
   const catalogSetHash = readString(attestation.catalogSetHash);
   const effectiveToolSetHash = readString(attestation.effectiveToolSetHash);
-  const finalEffectiveToolSetHash = readString(attestation.finalEffectiveToolSetHash);
-  if (!/^[a-f0-9]{64}$/.test(declaredSetHash ?? "") || catalogSetHash !== declaredSetHash || !/^[a-f0-9]{64}$/.test(effectiveToolSetHash ?? "") || !/^[a-f0-9]{64}$/.test(finalEffectiveToolSetHash ?? "") || !Number.isSafeInteger(attestation.finalEffectiveToolSchemaBytes) || attestation.finalEffectiveToolSchemaBytes < 1 || !/^[a-f0-9]{64}$/.test(readString(attestation.effectiveToolProbeDigest) ?? "")) {
+  const finalRequiredToolSetHash = readString(attestation.finalRequiredToolSetHash);
+  const catalogToolCount = Array.isArray(catalog.tools) ? catalog.tools.length : 0;
+  if (!/^[a-f0-9]{64}$/.test(declaredSetHash ?? "") || catalogSetHash !== declaredSetHash || readString(attestation.effectiveToolContractSource) !== "governed_catalog" || readString(attestation.effectiveToolValidationMode) !== "same_run_session_start_and_provider_request" || !/^[a-f0-9]{64}$/.test(effectiveToolSetHash ?? "") || !/^[a-f0-9]{64}$/.test(finalRequiredToolSetHash ?? "") || !Number.isSafeInteger(attestation.finalRequiredToolSchemaBytes) || attestation.finalRequiredToolSchemaBytes < 1 || !Number.isSafeInteger(attestation.finalRequiredToolCount) || attestation.finalRequiredToolCount !== catalogToolCount) {
     throw stableContextError(
       "context_effective_tool_schema_attestation_mismatch",
-      "final effective Pi tool schema proof is missing or does not match the governed catalog"
+      "the governed Pi tool schema contract is missing or does not match the catalog"
     );
   }
   return {
@@ -35716,10 +35358,10 @@ function requireEffectiveToolSchemaAttestation(contextContract, executorKind, go
     executorKind,
     declaredCatalogSetHash: declaredSetHash,
     effectiveToolSetHash,
-    finalEffectiveToolSetHash,
-    finalEffectiveToolSchemaBytes: attestation.finalEffectiveToolSchemaBytes,
-    finalEffectiveToolCount: attestation.finalEffectiveToolCount,
-    effectiveToolProbeDigest: attestation.effectiveToolProbeDigest,
+    finalRequiredToolSetHash,
+    finalRequiredToolSchemaBytes: attestation.finalRequiredToolSchemaBytes,
+    finalRequiredToolCount: attestation.finalRequiredToolCount,
+    validationMode: attestation.effectiveToolValidationMode,
     attestationId: readString(attestation.attestationId)
   };
 }
@@ -37387,7 +37029,7 @@ async function executePiTerminalTextRepairTurn(config, command, executor, execut
   ]);
   const completionOutputStopped = piCompletionOutputStopped(execution);
   const invalidOutput = piOutputValidationError(parsed, {
-    allowMissingTurnEnd: piOutputAllowsMissingTurnEnd(execution, parsed, { allowTerminalAgentEnd: true }),
+    allowMissingTurnEnd: completionOutputStopped || parsed.terminalEventType === "agent_end",
     completionOutputType: execution.completionOutputType,
     completionOutputHasFinalAssistantText: execution.completionOutputHasFinalAssistantText
   });
@@ -38450,11 +38092,6 @@ function piCompletionCleanupStopped(execution) {
 function piCompletionOutputStopped(execution) {
   return piCompletionCleanupStopped(execution) && PI_COMPLETION_OUTPUT_TYPES.has(readString(execution?.completionOutputType) ?? "") && (execution?.completionOutputType === "approval_required" || execution?.completionOutputHasFinalAssistantText === true);
 }
-function piOutputAllowsMissingTurnEnd(execution, parsed, options = {}) {
-  if (piCompletionOutputStopped(execution)) return true;
-  if (options.allowTerminalAgentEnd === true && parsed?.terminalEventType === "agent_end") return true;
-  return execution?.completionOutputType === "agent_settled" && execution?.completionOutputHasFinalAssistantText === true && execution?.exitCode === 0 && execution?.signal === null;
-}
 function piOutputValidationError(parsed, options = {}) {
   if (parsed?.errorMessage) return parsed.errorMessage;
   if (options.completionOutputType === "agent_settled" && options.completionOutputHasFinalAssistantText !== true && options.allowMissingFinalAssistantText !== true) {
@@ -38735,7 +38372,7 @@ async function executeRunCommand(config, command) {
       if (executor.kind === "pi") {
         assertManagedPiNonInteractiveInvocation(invocation.args, managedMcpProfile);
       }
-      await ingestLog(config, command, "system", "info", desktopDelegatedRunnerEnabled(config) && executor.kind === "pi" ? "Prepared desktop delegated Pi runtime action bridge" : `Attested isolated ${executor.kind} managed MCP profile`, {
+      await ingestLog(config, command, "system", "info", desktopDelegatedRunnerEnabled(config) && executor.kind === "pi" ? "Prepared desktop delegated Pi runtime action bridge" : executor.kind === "pi" ? "Prepared isolated Pi managed MCP profile" : `Attested isolated ${executor.kind} managed MCP profile`, {
         presentationKind: "managed_mcp_attestation",
         ...managedMcpProfile.attestation
       });
@@ -39298,16 +38935,15 @@ async function executeRunCommand(config, command) {
       );
     }
     const parsedForValidation = parsed;
-    const effectiveCompletionOutputHasFinalAssistantText = terminalTextRepair?.succeeded === true ? true : execution.completionOutputHasFinalAssistantText;
     const piTurnLimitFailure = executor.kind === "pi" && !cancelled && !hasOutputFlood && !hasArgumentAmplification && !hasMemoryLimit && execution.timedOut !== true && !execution.spawnError ? classifyPiTurnLimitResult(parsedForValidation, {
       authoritativeTerminalDisposition: Boolean(terminalRunDisposition)
     }) : null;
     const piInvalidOutputError = executor.kind === "pi" ? piOutputValidationError(parsedForValidation, {
-      allowMissingTurnEnd: piOutputAllowsMissingTurnEnd(execution, parsedForValidation),
+      allowMissingTurnEnd: completionOutputStopped,
       allowMissingAssistantOutput: execution.completionOutputType === "approval_required" || Boolean(terminalRunDisposition),
       allowMissingFinalAssistantText: Boolean(terminalRunDisposition),
       completionOutputType: execution.completionOutputType,
-      completionOutputHasFinalAssistantText: effectiveCompletionOutputHasFinalAssistantText
+      completionOutputHasFinalAssistantText: terminalTextRepair?.succeeded === true ? true : execution.completionOutputHasFinalAssistantText
     }) : null;
     const piOutputFailure = executor.kind === "pi" && !cancelled && !hasOutputFlood && !hasArgumentAmplification && !hasMemoryLimit && execution.timedOut !== true && !execution.spawnError ? classifyPiOutputFailure(parsedForValidation, {
       exitCode: execution.exitCode,

package/dist/amaster-runtime.mjs

@@ -7,7 +7,7 @@ import { homedir, hostname } from "node:os";
 import { fileURLToPath } from "node:url";
 import { BUILD_SUPPORTED_CAPABILITIES } from "./amaster-runtime-daemon/capability-registry.mjs";
 
-const CONNECTOR_VERSION = "0.1.1-beta.272";
+const CONNECTOR_VERSION = "0.1.1-beta.274";
 
 const CONFIG_KEY_MAP = new Map([
   ["server_url", "AMASTER_EMPLOYEE_SERVER_URL"],

package/package.json

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