@amaster.ai/employee-runtime-connector 0.1.1-beta.255 → 0.1.1-beta.257

package/dist/amaster-runtime-daemon.mjs

@@ -5508,6 +5508,32 @@ var amasterRuntimeConnectorLogIngestSchema = external_exports.object({
   message: external_exports.string().max(16e3),
   payload: external_exports.record(external_exports.unknown()).default({})
 });
+var AMASTER_RUNTIME_CONNECTOR_LOG_BATCH_MAX_ENTRIES = 32;
+var AMASTER_RUNTIME_CONNECTOR_LOG_BATCH_MAX_BYTES = 128 * 1024;
+var amasterRuntimeConnectorLogIngestBatchSchema = external_exports.object({
+  entries: external_exports.array(amasterRuntimeConnectorLogIngestSchema).min(1).max(AMASTER_RUNTIME_CONNECTOR_LOG_BATCH_MAX_ENTRIES)
+}).superRefine((value, ctx) => {
+  const commandIds = new Set(value.entries.flatMap((entry) => entry.commandId ? [entry.commandId] : []));
+  if (commandIds.size > 1) {
+    ctx.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["entries"],
+      message: "Runtime connector log batch entries must share one commandId"
+    });
+  }
+  const serializedBytes = new TextEncoder().encode(JSON.stringify(value)).byteLength;
+  if (serializedBytes > AMASTER_RUNTIME_CONNECTOR_LOG_BATCH_MAX_BYTES) {
+    ctx.addIssue({
+      code: external_exports.ZodIssueCode.too_big,
+      type: "array",
+      maximum: AMASTER_RUNTIME_CONNECTOR_LOG_BATCH_MAX_BYTES,
+      inclusive: true,
+      exact: false,
+      path: ["entries"],
+      message: "Runtime connector log batch exceeds 128 KiB"
+    });
+  }
+});
 var amasterRuntimeConnectorCostIngestSchema = external_exports.object({
   commandId: external_exports.string().uuid(),
   idempotencyKey: external_exports.string().trim().regex(/^runtime-command-cost:[0-9a-f-]{36}$/i).optional(),
@@ -6506,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",
@@ -18655,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");
@@ -18729,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"),
@@ -18963,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");
       }
@@ -21744,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) {
@@ -21752,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 {
@@ -22482,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) : [];
@@ -24239,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
@@ -24278,6 +24363,7 @@ ${result2.stderr ?? ""}`, "Pi", MINIMUM_PI_VERSION);
         );
       }
       const adapterVersion = piMcpAdapterVersion(sharedRuntime.home);
+      if (directCatalog) assertPiMcpAdapterDirectCatalogSupport(adapterVersion);
       const {
         cachePath,
         directAttestationInput
@@ -24450,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,
@@ -24668,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),
@@ -24720,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
@@ -24862,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,
@@ -27481,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"
@@ -27617,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",
@@ -27821,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 {
@@ -27885,6 +28084,7 @@ function parsePiJsonl(stdout) {
   const mcpToolResults = [];
   const cleanupDiagnostics = [];
   const diagnostics = [];
+  let governedMcpUnavailable = null;
   const errorEvents = [];
   let retry = null;
   let turnStartIndex = -1;
@@ -27895,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);
@@ -28032,6 +28233,7 @@ function parsePiJsonl(stdout) {
     ...nonCleanupErrorCount > 0 ? { nonCleanupErrorCount } : {},
     ...cleanupDiagnostics.length > 0 ? { cleanupDiagnostics } : {},
     ...diagnostics.length > 0 ? { diagnostics } : {},
+    ...governedMcpUnavailable ? { governedMcpUnavailable } : {},
     ...uniqueMcpToolResults.length > 0 ? { mcpToolResults: uniqueMcpToolResults } : {}
   };
 }
@@ -33516,7 +33718,7 @@ function assertRequiredTaskAttachmentMaterialized(input, materialized) {
 }
 
 // src/amaster-runtime-daemon.mjs
-var CONNECTOR_VERSION = "0.1.1-beta.255";
+var CONNECTOR_VERSION = "0.1.1-beta.257";
 var CONNECTOR_CONTRACT_VERSION = "2026-06-04.v1";
 var daemonRequire = createRequire2(import.meta.url);
 var MAX_CHECKPOINT_BYTES = 20 * 1024 * 1024;
@@ -35183,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),
@@ -35645,6 +35850,25 @@ function redactProtectedText(value, protectedValues = []) {
   }
   return text3;
 }
+var RUNTIME_LOG_BATCH_MAX_ENTRIES = 32;
+var RUNTIME_LOG_BATCH_MAX_BYTES = 128 * 1024;
+var RUNTIME_LOG_BATCH_FLUSH_MS = 250;
+function runtimeLogBatchEntries(command, entries) {
+  return entries.map((entry) => ({
+    commandId: command.commandId,
+    runId: commandRunId(command) ?? void 0,
+    stream: entry.stream,
+    level: entry.level,
+    message: truncateText(entry.message),
+    payload: entry.payload ?? {}
+  }));
+}
+function runtimeLogBatchEntryBytes(command, entry) {
+  return Buffer.byteLength(JSON.stringify(runtimeLogBatchEntries(command, [entry])[0]));
+}
+function runtimeLogBatchBytes(command, entries) {
+  return Buffer.byteLength(JSON.stringify({ entries: runtimeLogBatchEntries(command, entries) }));
+}
 function createLiveOutputLogger(config, command, executorKind, protectedValues = [], onMcpToolResults = null, options = {}) {
   const buffers = { stdout: "", stderr: "" };
   const displayCounts = { stdout: 0, stderr: 0, system: 0 };
@@ -35667,6 +35891,16 @@ function createLiveOutputLogger(config, command, executorKind, protectedValues =
   let liveLogDeliveryFailed = false;
   let failedLiveLogDeliveryCount = 0;
   let skippedLiveLogDeliveryCount = 0;
+  let logEntriesAttempted = 0;
+  let logEntriesAccepted = 0;
+  let logEntriesInvalidDropped = 0;
+  let logEntriesAmbiguousDropped = 0;
+  let logBatchRequestsAttempted = 0;
+  let logBatchRequestsAccepted = 0;
+  let firstLogDeliveryFailureCategory = null;
+  let pendingBatch = [];
+  let pendingBatchBytes = runtimeLogBatchBytes(command, []);
+  let pendingBatchTimer = null;
   const piToolArgumentTracker = executorKind === "pi" ? createPiToolArgumentAmplificationTracker(options.piToolArgumentGuard) : null;
   const fullTranscriptEnabled = executorKind === "pi" && readString(asRecord(asRecord(command).payload).transcriptDetail) === AMASTER_RUNTIME_TRANSCRIPT_DETAIL_FULL;
   const maxEntriesPerStream = parsePositiveInteger(
@@ -35723,34 +35957,66 @@ function createLiveOutputLogger(config, command, executorKind, protectedValues =
     }
     nonProgressEventCount += 1;
   };
-  const deliverLiveLog = async (entry, options2 = {}) => {
+  const deliverLiveLogBatch = async (entries, options2 = {}) => {
+    if (entries.length === 0) return;
     const terminalSummary = options2.terminalSummary === true;
-    if (liveLogDeliveryFailed && !terminalSummary) {
-      skippedLiveLogDeliveryCount += 1;
+    const bisectRecovery = options2.bisectRecovery === true;
+    if (liveLogDeliveryFailed && !terminalSummary && !bisectRecovery) {
+      skippedLiveLogDeliveryCount += entries.length;
       return;
     }
-    let deliveryFailed = false;
-    await ingestLog(
-      config,
-      command,
-      entry.stream,
-      entry.level,
-      truncateText(entry.message),
-      entry.payload ?? {},
-      {
-        timeoutMs: 1e3,
-        onError: (message) => {
-          deliveryFailed = true;
-          process.stderr.write(terminalSummary ? `${message}; terminal live-log summary was not delivered
+    let deliveryError = null;
+    if (!bisectRecovery) logEntriesAttempted += entries.length;
+    logBatchRequestsAttempted += 1;
+    const response = await ingestLogBatch(config, command, entries, {
+      timeoutMs: 1e3,
+      onError: (_message, error) => {
+        deliveryError = error;
+      }
+    });
+    if (response) {
+      logEntriesAccepted += readNumber(response.acceptedCount, entries.length);
+      logBatchRequestsAccepted += 1;
+      return;
+    }
+    if (Number(deliveryError?.httpStatus) === 400) {
+      firstLogDeliveryFailureCategory ??= "invalid";
+      if (entries.length === 1) {
+        logEntriesInvalidDropped += 1;
+        failedLiveLogDeliveryCount += 1;
+        return;
+      }
+      const midpoint = Math.floor(entries.length / 2);
+      const recoveryOptions = { ...options2, bisectRecovery: true };
+      await deliverLiveLogBatch(entries.slice(0, midpoint), recoveryOptions);
+      await deliverLiveLogBatch(entries.slice(midpoint), recoveryOptions);
+      return;
+    }
+    firstLogDeliveryFailureCategory ??= "ambiguous";
+    logEntriesAmbiguousDropped += entries.length;
+    if (!terminalSummary) liveLogDeliveryFailed = true;
+    const message = `AMaster daemon could not determine whether ${entries.length} runtime log entr${entries.length === 1 ? "y was" : "ies were"} accepted`;
+    process.stderr.write(terminalSummary ? `${message}; terminal live-log summary was not delivered
 ` : `${message}; suppressing remaining live logs for this executor turn
 `);
-        }
-      }
-    );
-    if (deliveryFailed) {
-      liveLogDeliveryFailed = true;
-      failedLiveLogDeliveryCount += 1;
+    failedLiveLogDeliveryCount += 1;
+  };
+  const flushPendingBatch = () => {
+    if (pendingBatchTimer) {
+      clearTimeout(pendingBatchTimer);
+      pendingBatchTimer = null;
     }
+    if (pendingBatch.length === 0) return;
+    const entries = pendingBatch;
+    pendingBatch = [];
+    pendingBatchBytes = runtimeLogBatchBytes(command, []);
+    queue = queue.then(() => deliverLiveLogBatch(entries)).catch(() => {
+    });
+  };
+  const schedulePendingBatch = () => {
+    if (pendingBatchTimer) return;
+    pendingBatchTimer = setTimeout(() => flushPendingBatch(), RUNTIME_LOG_BATCH_FLUSH_MS);
+    pendingBatchTimer.unref?.();
   };
   const enqueue = (entry) => {
     const stream = entry.stream === "stderr" || entry.stream === "system" ? entry.stream : "stdout";
@@ -35759,8 +36025,19 @@ function createLiveOutputLogger(config, command, executorKind, protectedValues =
       return;
     }
     displayCounts[stream] = (displayCounts[stream] ?? 0) + 1;
-    queue = queue.then(() => deliverLiveLog(entry)).catch(() => {
-    });
+    const entryBytes = runtimeLogBatchEntryBytes(command, entry);
+    let candidateBatchBytes = pendingBatchBytes + (pendingBatch.length > 0 ? 1 : 0) + entryBytes;
+    if (pendingBatch.length > 0 && (pendingBatch.length >= RUNTIME_LOG_BATCH_MAX_ENTRIES || candidateBatchBytes > RUNTIME_LOG_BATCH_MAX_BYTES)) {
+      flushPendingBatch();
+      candidateBatchBytes = pendingBatchBytes + entryBytes;
+    }
+    pendingBatch.push(entry);
+    pendingBatchBytes = candidateBatchBytes;
+    if (pendingBatch.length >= RUNTIME_LOG_BATCH_MAX_ENTRIES || pendingBatchBytes >= RUNTIME_LOG_BATCH_MAX_BYTES) {
+      flushPendingBatch();
+    } else {
+      schedulePendingBatch();
+    }
   };
   const shouldSuppressDuplicatePiAgentMessage = (entry) => {
     if (executorKind !== "pi") return false;
@@ -35890,22 +36167,25 @@ function createLiveOutputLogger(config, command, executorKind, protectedValues =
       }
       await observationQueue;
       if (observationError) throw observationError;
+      flushPendingBatch();
       await queue;
       const suppressedSummaries = Object.entries(suppressedCounts).filter(([, count2]) => count2 > 0).map(([stream, count2]) => ({ stream, count: count2 }));
-      if (suppressedSummaries.length > 0) {
+      if (suppressedSummaries.length > 0 || liveLogDeliveryFailed) {
         const suppressedCount = suppressedSummaries.reduce((total, summary) => total + summary.count, 0);
-        await deliverLiveLog({
+        await deliverLiveLogBatch([{
           stream: "system",
-          level: "info",
-          message: `Runtime output summarized: ${suppressedCount} event(s) suppressed after ${maxEntriesPerStream} live log entries per stream`,
+          level: liveLogDeliveryFailed ? "warn" : "info",
+          message: liveLogDeliveryFailed ? `Runtime output delivery was incomplete: ${logEntriesAmbiguousDropped} entr${logEntriesAmbiguousDropped === 1 ? "y" : "ies"} had an ambiguous server outcome` : `Runtime output summarized: ${suppressedCount} event(s) suppressed after ${maxEntriesPerStream} live log entries per stream`,
           payload: {
             presentationKind: "output_summary",
             executorKind,
             suppressedCount,
             suppressedByStream: suppressedSummaries,
-            maxEntriesPerStream
+            maxEntriesPerStream,
+            deliveryIncomplete: liveLogDeliveryFailed,
+            ambiguousDropped: logEntriesAmbiguousDropped
           }
-        }, { terminalSummary: true });
+        }], { terminalSummary: true });
       }
     },
     hasStream(stream) {
@@ -35930,10 +36210,17 @@ function createLiveOutputLogger(config, command, executorKind, protectedValues =
       const normalizedFloodLimitBytes = readNumber(floodLimitBytes, 0);
       return {
         liveLogDelivery: {
-          status: liveLogDeliveryFailed ? "partial" : "complete",
+          status: liveLogDeliveryFailed || logEntriesInvalidDropped > 0 ? "partial" : "complete",
           failed: failedLiveLogDeliveryCount,
           skipped: skippedLiveLogDeliveryCount
         },
+        logEntriesAttempted,
+        logEntriesAccepted,
+        logEntriesInvalidDropped,
+        logEntriesAmbiguousDropped,
+        logBatchRequestsAttempted,
+        logBatchRequestsAccepted,
+        ...firstLogDeliveryFailureCategory ? { firstLogDeliveryFailureCategory } : {},
         rawBytesByStream,
         rawOutputBytes,
         retainedBytesByStream,
@@ -36573,6 +36860,15 @@ async function ingestLog(config, command, stream, level, message, payload = {},
     payload
   }, options);
 }
+async function ingestLogBatch(config, command, entries, options = {}) {
+  const connectorId = requireConnectorId(config);
+  return await bestEffortPostJson(
+    config,
+    `/api/amaster/runtime-connectors/${connectorId}/ingest/logs/batch`,
+    { entries: runtimeLogBatchEntries(command, entries) },
+    options
+  );
+}
 function parsedUsageCostCents(usage) {
   const costUsd = readNumber(asRecord(usage).costUsd, 0);
   if (!Number.isFinite(costUsd) || costUsd <= 0) return 0;
@@ -38024,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
@@ -38585,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.255";
+const CONNECTOR_VERSION = "0.1.1-beta.257";
 
 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.255",
+  "version": "0.1.1-beta.257",
   "description": "MirrorX runtime connector CLI and daemon",
   "license": "MIT",
   "type": "module",