@amaster.ai/employee-runtime-connector 0.1.1-beta.256 → 0.1.1-beta.258

package/dist/amaster-runtime-daemon.mjs

@@ -6532,6 +6532,20 @@ var ERROR_PRESENTATIONS = {
     nextAction: "\u5145\u503C\u540E\u7CFB\u7EDF\u4F1A\u5B9A\u65F6\u68C0\u67E5\u5E76\u81EA\u52A8\u6062\u590D\uFF0C\u65E0\u9700\u624B\u52A8\u91CD\u8BD5\u3002",
     tone: "warning"
   },
+  pi_governed_tool_surface_changed: {
+    label: "\u53D7\u7BA1\u5DE5\u5177\u5B9A\u4E49\u5DF2\u53D8\u5316",
+    summary: "\u8FD0\u884C\u671F\u95F4\u7684\u53D7\u7BA1\u5DE5\u5177\u6570\u91CF\u6216\u5B9A\u4E49\u53D1\u751F\u53D8\u5316\uFF0C\u7CFB\u7EDF\u5DF2\u505C\u6B62\u91C7\u4FE1\u672C\u6B21\u8F93\u51FA\u3002",
+    nextAction: "\u68C0\u67E5 Governed MCP \u5DE5\u5177\u76EE\u5F55\u4E0E adapter \u7248\u672C\uFF1B\u7CFB\u7EDF\u4EC5\u4F1A\u5728\u786E\u8BA4\u6CA1\u6709\u672A\u51B3\u526F\u4F5C\u7528\u540E\u8FDB\u884C\u4E00\u6B21\u5B89\u5168\u91CD\u8BD5\u3002",
+    actionTitle: "\u6838\u5BF9\u53D7\u7BA1\u5DE5\u5177\u76EE\u5F55\u540E\u91CD\u8BD5",
+    tone: "danger"
+  },
+  pi_governed_mcp_unavailable: {
+    label: "\u53D7\u7BA1\u5DE5\u5177\u6682\u4E0D\u53EF\u7528",
+    summary: "\u8FD0\u884C\u6240\u9700\u7684\u53D7\u7BA1\u5DE5\u5177\u8FDE\u63A5\u6682\u4E0D\u53EF\u7528\uFF0C\u7CFB\u7EDF\u5DF2\u4FDD\u7559\u672C\u6B21\u8FD0\u884C\u7684\u526F\u4F5C\u7528\u8BC1\u636E\u3002",
+    nextAction: "\u7B49\u5F85\u8FDE\u63A5\u6062\u590D\uFF1B\u53EA\u6709\u5728\u786E\u8BA4\u672C\u6B21\u8FD0\u884C\u6CA1\u6709\u672A\u51B3\u526F\u4F5C\u7528\u65F6\uFF0C\u7CFB\u7EDF\u624D\u4F1A\u8FDB\u884C\u4E00\u6B21\u5B89\u5168\u91CD\u8BD5\u3002",
+    actionTitle: "\u68C0\u67E5\u53D7\u7BA1\u5DE5\u5177\u8FDE\u63A5",
+    tone: "warning"
+  },
   issue_assignee_changed: {
     label: "\u4EFB\u52A1\u5DF2\u6539\u6D3E",
     summary: "\u65E7\u8D1F\u8D23\u4EBA\u7684\u6392\u961F\u8FD0\u884C\u5DF2\u53D6\u6D88\uFF0C\u65B0\u8D1F\u8D23\u4EBA\u4F1A\u81EA\u52A8\u63A5\u624B\u3002",
@@ -18681,6 +18695,12 @@ function requiredInteger(value, name, minimum = 0) {
   if (!Number.isSafeInteger(value) || value < minimum) throw new Error(`pi_final_context_attestor_invalid: ${name}`);
   return value;
 }
+function optionalSha256(value, name) {
+  if (value === void 0 || value === null) return null;
+  const hash = requiredString(value, name);
+  if (!/^[a-f0-9]{64}$/.test(hash)) throw new Error(`pi_final_context_attestor_invalid: ${name}`);
+  return hash;
+}
 function managedPiProjectInstructionExtensionSource(input) {
   const projectInstructionPath = resolve3(requiredString(input.projectInstructionPath, "projectInstructionPath"));
   const projectInstructionSha256 = requiredString(input.projectInstructionSha256, "projectInstructionSha256");
@@ -18755,6 +18775,9 @@ function managedPiFinalContextAttestorExtensionSource(input) {
     effectiveToolSchemaBytes: requiredInteger(input.effectiveToolSchemaBytes, "effectiveToolSchemaBytes", 1),
     effectiveToolSetSha256: requiredString(input.effectiveToolSetSha256, "effectiveToolSetSha256"),
     effectiveToolCount: requiredInteger(input.effectiveToolCount, "effectiveToolCount", 1),
+    catalogSetSha256: optionalSha256(input.catalogSetSha256, "catalogSetSha256"),
+    configSha256: optionalSha256(input.configSha256, "configSha256"),
+    cacheSha256: optionalSha256(input.cacheSha256, "cacheSha256"),
     toolSetMode,
     requiredToolEntries,
     skillMetadataBytes: requiredInteger(input.skillMetadataBytes, "skillMetadataBytes"),
@@ -18989,17 +19012,28 @@ export default function amasterFinalModelContextAttestor(pi) {
       requiredToolSet.hash = sha256(stableJson(requiredToolSet.entries));
       if (requiredToolSet.entries.length !== CONTRACT.effectiveToolCount) {
         observe("provider_tool_count_mismatch", {
+          reason: "provider_tool_count_mismatch",
           expectedCount: CONTRACT.effectiveToolCount,
           actualCount: requiredToolSet.entries.length,
-          actualEntries: toolSet.entries,
+          providerCallIndex: calls.length + 1,
+          contractToolSetSha256: CONTRACT.effectiveToolSetSha256,
+          ...(CONTRACT.catalogSetSha256 ? { catalogSetSha256: CONTRACT.catalogSetSha256 } : {}),
+          ...(CONTRACT.configSha256 ? { configSha256: CONTRACT.configSha256 } : {}),
+          ...(CONTRACT.cacheSha256 ? { cacheSha256: CONTRACT.cacheSha256 } : {}),
         });
         reject("provider_tool_count_mismatch");
       }
       if (requiredToolSet.hash !== CONTRACT.effectiveToolSetSha256) {
         observe("provider_tool_set_mismatch", {
-          expectedToolSetSha256: CONTRACT.effectiveToolSetSha256,
-          actualToolSetSha256: toolSet.hash,
-          actualEntries: toolSet.entries,
+          reason: "provider_tool_set_mismatch",
+          expectedCount: CONTRACT.effectiveToolCount,
+          actualCount: requiredToolSet.entries.length,
+          providerCallIndex: calls.length + 1,
+          contractToolSetSha256: CONTRACT.effectiveToolSetSha256,
+          actualToolSetSha256: requiredToolSet.hash,
+          ...(CONTRACT.catalogSetSha256 ? { catalogSetSha256: CONTRACT.catalogSetSha256 } : {}),
+          ...(CONTRACT.configSha256 ? { configSha256: CONTRACT.configSha256 } : {}),
+          ...(CONTRACT.cacheSha256 ? { cacheSha256: CONTRACT.cacheSha256 } : {}),
         });
         reject("provider_tool_set_mismatch");
       }
@@ -21770,6 +21804,7 @@ import { spawnSync as spawnSync3 } from "node:child_process";
 // src/amaster-runtime-daemon/pi-mcp-adapter-config.mjs
 var CONFIG_HASH_V2_24_MINIMUM = [2, 24, 0];
 var CONFIG_HASH_V2_26_MINIMUM = [2, 26, 0];
+var DIRECT_CATALOG_FREEZE_MINIMUM = [2, 32, 1];
 function piMcpAdapterVersionAtLeast(version, minimum) {
   const actual = version.split(/[.-]/, 3).map(Number);
   for (let index = 0; index < minimum.length; index += 1) {
@@ -21778,6 +21813,13 @@ function piMcpAdapterVersionAtLeast(version, minimum) {
   }
   return true;
 }
+function assertPiMcpAdapterDirectCatalogSupport(version) {
+  if (typeof version !== "string" || !piMcpAdapterVersionAtLeast(version, DIRECT_CATALOG_FREEZE_MINIMUM)) {
+    throw new Error(
+      `pi_managed_mcp_unsupported_adapter_version: direct catalog requires pi-mcp-adapter >=2.32.1; found ${typeof version === "string" ? version : "unknown"}`
+    );
+  }
+}
 function piMcpAdapterServerConfigIdentity(definition, adapterVersion) {
   const supportsV224Config = piMcpAdapterVersionAtLeast(adapterVersion, CONFIG_HASH_V2_24_MINIMUM);
   return {
@@ -22508,6 +22550,23 @@ function applyManagedPiToolAllowlist(args, profile) {
     ...args.slice(printArgIndex)
   ];
 }
+function assertManagedPiNonInteractiveInvocation(args, profile) {
+  if (profile?.directCatalogFrozen !== true) return;
+  let effectiveMode = null;
+  for (let index = 0; index < args.length; index += 1) {
+    if (args[index] === "--mode") {
+      effectiveMode = args[index + 1] ?? null;
+      index += 1;
+    } else if (args[index].startsWith("--mode=")) {
+      effectiveMode = args[index].slice("--mode=".length);
+    }
+  }
+  const hasJsonMode = effectiveMode === "json";
+  const hasPrintMode = args.includes("-p") || args.includes("--print");
+  if (!hasJsonMode || !hasPrintMode) {
+    throw new Error("pi_managed_mcp_invocation_invalid: frozen direct catalog requires --mode json and -p/--print");
+  }
+}
 function applyManagedPiRunExitClosureArgs(args, profile) {
   const narrowedArgs = [...args];
   const toolAllowlist = Array.isArray(profile?.toolAllowlist) ? profile.toolAllowlist.filter((name) => typeof name === "string" && name) : [];
@@ -24265,7 +24324,7 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         settings: {
           toolPrefix: "none",
           scriptMode: false,
-          ...directCatalog ? { directToolResultDetails: "bounded" } : {}
+          ...directCatalog ? { directToolResultDetails: "bounded", freezeDirectTools: true } : {}
         },
         mcpServers: {
           [SUPPORTED_SERVER_NAME3]: serverConfig
@@ -24304,6 +24363,7 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         );
       }
       const adapterVersion = piMcpAdapterVersion(sharedRuntime.home);
+      if (directCatalog) assertPiMcpAdapterDirectCatalogSupport(adapterVersion);
       const {
         cachePath,
         directAttestationInput
@@ -24476,6 +24536,7 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         // The attestor verifies the naturally active surface after all extensions
         // load; CLI --tools remains unused so user-level tools stay available.
         toolAllowlist: directAttestationInput?.profileToolAllowlist ?? null,
+        directCatalogFrozen: Boolean(directCatalog),
         protectedValues: [.../* @__PURE__ */ new Set([
           sessionToken,
           ...sharedRuntime.protectedValues,
@@ -24694,7 +24755,7 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
           // prefix is local presentation state and must not rename this run's
           // governed tools.
           ...directCatalog ? { toolPrefix: "none" } : {},
-          ...directCatalog ? { directToolResultDetails: "bounded" } : {}
+          ...directCatalog ? { directToolResultDetails: "bounded", freezeDirectTools: true } : {}
         },
         mcpServers: {
           ...record9(sourceMcp.mcpServers),
@@ -24746,6 +24807,7 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
       }
       const userMcpServerNames = Object.keys(record9(sourceMcp.mcpServers)).filter((serverName) => serverName !== SUPPORTED_SERVER_NAME3);
       const adapterVersion = desktopAttestationReadiness?.ready ? desktopAttestationReadiness.adapterVersion : null;
+      if (directCatalog) assertPiMcpAdapterDirectCatalogSupport(adapterVersion);
       const {
         cachePath,
         directAttestationInput
@@ -24888,6 +24950,7 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
           }
         } : {},
         toolAllowlist: directAttestationInput?.profileToolAllowlist ?? null,
+        directCatalogFrozen: Boolean(directCatalog),
         protectedValues: [.../* @__PURE__ */ new Set([sessionToken, ...seededRuntime.protectedValues])],
         attestation: {
           ...attestationFacts,
@@ -27507,6 +27570,17 @@ var PI_PROVIDER_PROTOCOL_RE = /provider[^\n]*finish_reason[^\n]*unexpected_state
 var PI_PROVIDER_RETRY_AFTER_SECONDS_RE = /retry[-\s]?after\s*[:=]?\s*(\d{1,6})\s*(?:seconds?|secs?|s)\b/i;
 var PI_TERMINAL_CLEANUP_PERMISSION_RE = /(?:\bkill\b[^\n]*\bEPERM\b|\bEPERM\b[^\n]*\bkill\b)/i;
 var MAX_PI_PROVIDER_RETRY_AFTER_SECONDS = 7 * 24 * 60 * 60;
+var PI_GOVERNED_MCP_UNAVAILABLE_REASONS = /* @__PURE__ */ new Set([
+  "server_unavailable",
+  "not_connected",
+  "init_failed"
+]);
+var PI_GOVERNED_TOOL_SURFACE_REASONS = /* @__PURE__ */ new Set([
+  "provider_tool_count_mismatch",
+  "provider_tool_set_mismatch",
+  "provider_tool_invalid",
+  "provider_tools_missing"
+]);
 var PI_DURABLE_RUNTIME_ACTION_WRITE_TOOLS = /* @__PURE__ */ new Set([
   "runtime_action.submit",
   "runtime_action.commit"
@@ -27643,9 +27717,80 @@ function classifyPiProviderError(input, now = /* @__PURE__ */ new Date()) {
     ...retryNotBefore ? { retryNotBefore: retryNotBefore.toISOString() } : {}
   };
 }
+function safeSha256(value) {
+  const hash = readString(value);
+  return /^[a-f0-9]{64}$/.test(hash ?? "") ? hash : null;
+}
+function safeNonNegativeInteger(value) {
+  return Number.isSafeInteger(value) && value >= 0 ? value : null;
+}
+function classifyPiGovernedToolSurfaceFailure(options) {
+  if (options.exitCode !== 78) return null;
+  const stderr = String(options.stderr ?? "");
+  const rejectedReason = stderr.split(/\r?\n/).map((line) => line.startsWith("pi_final_model_context_attestation_rejected:") ? line.slice("pi_final_model_context_attestation_rejected:".length).trim() : null).find((reason) => reason && PI_GOVERNED_TOOL_SURFACE_REASONS.has(reason));
+  if (!rejectedReason) return null;
+  const observationPrefix = "pi_final_model_context_attestation_observation:";
+  let observation = {};
+  for (const line of stderr.split(/\r?\n/)) {
+    if (!line.startsWith(observationPrefix) || line.length > 4096) continue;
+    try {
+      const candidate = asRecord(JSON.parse(line.slice(observationPrefix.length)));
+      if (readString(candidate.reason) === rejectedReason && readString(candidate.event) === rejectedReason) {
+        observation = candidate;
+      }
+    } catch {
+    }
+  }
+  const expectedCount = safeNonNegativeInteger(observation.expectedCount);
+  const actualCount = safeNonNegativeInteger(observation.actualCount);
+  const providerCallIndex = safeNonNegativeInteger(observation.providerCallIndex);
+  const contractToolSetSha256 = safeSha256(observation.contractToolSetSha256);
+  const actualToolSetSha256 = safeSha256(observation.actualToolSetSha256);
+  const catalogSetSha256 = safeSha256(observation.catalogSetSha256);
+  const configSha256 = safeSha256(observation.configSha256);
+  const cacheSha256 = safeSha256(observation.cacheSha256);
+  return {
+    errorCode: "pi_governed_tool_surface_changed",
+    errorFamily: "governance_invariant",
+    retryable: false,
+    governedToolSurface: {
+      reason: rejectedReason,
+      ...expectedCount !== null ? { expectedCount } : {},
+      ...actualCount !== null ? { actualCount } : {},
+      ...providerCallIndex !== null ? { providerCallIndex } : {},
+      ...contractToolSetSha256 ? { contractToolSetSha256 } : {},
+      ...actualToolSetSha256 ? { actualToolSetSha256 } : {},
+      ...catalogSetSha256 ? { catalogSetSha256 } : {},
+      ...configSha256 ? { configSha256 } : {},
+      ...cacheSha256 ? { cacheSha256 } : {}
+    }
+  };
+}
 function classifyPiOutputFailure(input, options = {}) {
+  const commandFailed = Number.isInteger(options.exitCode) && options.exitCode !== 0 || Boolean(readString(options.invalidOutputError)) || Boolean(readString(options.finalContextAttestationError));
+  const governedSurfaceFailure = classifyPiGovernedToolSurfaceFailure(options);
+  if (governedSurfaceFailure) return governedSurfaceFailure;
+  if (readString(options.finalContextAttestationError)) {
+    return {
+      errorCode: "pi_final_context_attestation_failed",
+      errorFamily: "governance_invariant",
+      retryable: false
+    };
+  }
   const providerFailure = classifyPiProviderError(input, options.now);
   if (providerFailure) return providerFailure;
+  const governedMcpUnavailable = asRecord(asRecord(input).governedMcpUnavailable);
+  const governedUnavailableReason = readString(governedMcpUnavailable.reason);
+  if (commandFailed && governedUnavailableReason && PI_GOVERNED_MCP_UNAVAILABLE_REASONS.has(governedUnavailableReason)) {
+    return {
+      errorCode: "pi_governed_mcp_unavailable",
+      errorFamily: "transient_infra",
+      governedMcpUnavailable: {
+        reason: governedUnavailableReason,
+        ...readString(governedMcpUnavailable.toolName) ? { toolName: readString(governedMcpUnavailable.toolName) } : {}
+      }
+    };
+  }
   if (!readString(options.invalidOutputError)) return null;
   return {
     errorCode: "pi_executor_invalid_output",
@@ -27847,6 +27992,34 @@ function piMcpToolResults(event) {
   }
   return results;
 }
+function piGovernedMcpUnavailableEvidence(event) {
+  const messageToolResults = [
+    event?.message,
+    ...Array.isArray(event?.messages) ? event.messages : [],
+    ...Array.isArray(event?.toolResults) ? event.toolResults : []
+  ];
+  const unavailableEvidence = (rawResult, fallbackToolName = null) => {
+    const result2 = asRecord(rawResult);
+    const details = asRecord(result2.details);
+    const reason = readString(details.error);
+    if (readString(details.server) !== "amaster" || !reason || !PI_GOVERNED_MCP_UNAVAILABLE_REASONS.has(reason)) return null;
+    const toolName = readString(result2.toolName) ?? readString(details.toolName) ?? fallbackToolName;
+    return {
+      reason,
+      ...toolName && /^[A-Za-z][A-Za-z0-9_-]{0,127}$/.test(toolName) ? { toolName } : {}
+    };
+  };
+  for (const rawResult of messageToolResults) {
+    const result2 = asRecord(rawResult);
+    if (readString(result2.role) !== "toolResult") continue;
+    const evidence = unavailableEvidence(result2);
+    if (evidence) return evidence;
+  }
+  if (readString(event?.type) === "tool_execution_end") {
+    return unavailableEvidence(event?.result, readString(event?.toolName));
+  }
+  return null;
+}
 function piRuntimeWebEvidence(event) {
   if (readString(event?.type) === "amaster_web_evidence" && readString(event?.version) === "runtime_web_evidence_v1") {
     try {
@@ -27911,6 +28084,7 @@ function parsePiJsonl(stdout) {
   const mcpToolResults = [];
   const cleanupDiagnostics = [];
   const diagnostics = [];
+  let governedMcpUnavailable = null;
   const errorEvents = [];
   let retry = null;
   let turnStartIndex = -1;
@@ -27921,6 +28095,7 @@ function parsePiJsonl(stdout) {
     if (!event) continue;
     eventIndex += 1;
     mcpToolResults.push(...piMcpToolResults(event));
+    governedMcpUnavailable = piGovernedMcpUnavailableEvidence(event) ?? governedMcpUnavailable;
     if (event.type === "turn_start") turnStartIndex = eventIndex;
     if (event.type === "auto_retry_start") {
       const message = readString(event.errorMessage);
@@ -28058,6 +28233,7 @@ function parsePiJsonl(stdout) {
     ...nonCleanupErrorCount > 0 ? { nonCleanupErrorCount } : {},
     ...cleanupDiagnostics.length > 0 ? { cleanupDiagnostics } : {},
     ...diagnostics.length > 0 ? { diagnostics } : {},
+    ...governedMcpUnavailable ? { governedMcpUnavailable } : {},
     ...uniqueMcpToolResults.length > 0 ? { mcpToolResults: uniqueMcpToolResults } : {}
   };
 }
@@ -33542,7 +33718,7 @@ function assertRequiredTaskAttachmentMaterialized(input, materialized) {
 }
 
 // src/amaster-runtime-daemon.mjs
-var CONNECTOR_VERSION = "0.1.1-beta.256";
+var CONNECTOR_VERSION = "0.1.1-beta.258";
 var CONNECTOR_CONTRACT_VERSION = "2026-06-04.v1";
 var daemonRequire = createRequire2(import.meta.url);
 var MAX_CHECKPOINT_BYTES = 20 * 1024 * 1024;
@@ -35209,6 +35385,9 @@ function attachPiFinalContextAttestor(profile, input) {
     effectiveToolSchemaBytes: governedToolContract.effectiveToolSchemaBytes,
     effectiveToolSetSha256: governedToolContract.effectiveToolSetSha256,
     effectiveToolCount: governedToolContract.effectiveToolCount,
+    catalogSetSha256: readString(profileAttestation.catalogSetHash),
+    configSha256: readString(asRecord(profile.runExitClosureBaseline).configSha256) ?? readString(profileAttestation.configSha256),
+    cacheSha256: readString(asRecord(profile.runExitClosureBaseline).cacheSha256),
     toolSetMode: "required_subset",
     requiredToolEntries: governedToolContract.entries.map(({ name, schemaHash }) => ({ name, schemaHash })),
     skillMetadataBytes: Number(profile.attestation?.enabledSkillMetadataBytes ?? 0),
@@ -38141,6 +38320,9 @@ async function executeRunCommand(config, command) {
       if (executor.kind === "pi" && Array.isArray(managedMcpProfile.extensionArgs) && managedMcpProfile.extensionArgs.length > 0) {
         invocation.args = [...invocation.args, ...managedMcpProfile.extensionArgs];
       }
+      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`, {
         presentationKind: "managed_mcp_attestation",
         ...managedMcpProfile.attestation
@@ -38702,7 +38884,12 @@ async function executeRunCommand(config, command) {
       completionOutputType: execution.completionOutputType,
       completionOutputHasFinalAssistantText: terminalTextRepair?.succeeded === true ? true : execution.completionOutputHasFinalAssistantText
     }) : null;
-    const piOutputFailure = executor.kind === "pi" && !cancelled && !hasOutputFlood && !hasArgumentAmplification && !hasMemoryLimit && execution.timedOut !== true && !execution.spawnError ? classifyPiOutputFailure(parsedForValidation, { invalidOutputError: piInvalidOutputError }) : null;
+    const piOutputFailure = executor.kind === "pi" && !cancelled && !hasOutputFlood && !hasArgumentAmplification && !hasMemoryLimit && execution.timedOut !== true && !execution.spawnError ? classifyPiOutputFailure(parsedForValidation, {
+      exitCode: execution.exitCode,
+      stderr: execution.stderr,
+      finalContextAttestationError: finalModelContextAttestationError,
+      invalidOutputError: piInvalidOutputError
+    }) : null;
     const piProviderFailure = piOutputFailure?.errorCode !== "pi_executor_invalid_output" ? piOutputFailure : null;
     const parsedErrorMessage = outputFloodError ?? argumentAmplificationError ?? memoryLimitError ?? finalModelContextAttestationError ?? piTurnLimitFailure?.message ?? piInvalidOutputError ?? nativeSessionRolloutError ?? nativeSessionRolloutCleanupError ?? parsedForValidation.errorMessage;
     const codexTransientFailure = executor.kind === "codex" && (execution.exitCode ?? 0) !== 0 ? classifyCodexTransientUpstreamError({

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.256";
+const CONNECTOR_VERSION = "0.1.1-beta.258";
 
 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.256",
+  "version": "0.1.1-beta.258",
   "description": "MirrorX runtime connector CLI and daemon",
   "license": "MIT",
   "type": "module",