@amaster.ai/employee-runtime-connector 0.1.1-beta.225 → 0.1.1-beta.226

package/dist/amaster-runtime-daemon/capability-registry.mjs

@@ -17,6 +17,7 @@ export const BUILD_SUPPORTED_CAPABILITIES = Object.freeze([
   "run_terminate",
   "logs_cost_workspace_status",
   "browser_credential_ref_fill_v1",
+  "execution_lanes_v1",
 ]);
 
 const DYNAMIC_READINESS = Object.freeze({

package/dist/amaster-runtime-daemon.mjs

@@ -4072,8 +4072,11 @@ var AMASTER_RUNTIME_CONNECTOR_CAPABILITIES = [
   "runtime_actions_v2",
   "continue_task_v1",
   "run_exit_live_path_closure_v1",
-  "browser_credential_ref_fill_v1"
+  "browser_credential_ref_fill_v1",
+  "execution_lanes_v1"
 ];
+var RUNTIME_EXECUTION_LANES = ["business", "conversation"];
+var runtimeExecutionLaneSchema = external_exports.enum(RUNTIME_EXECUTION_LANES);
 var TERMINAL_BUSINESS_RECONCILIATION_VERSION = "mirrorx.terminal-business-reconciliation/v1";
 var terminalBusinessReconciliationAuthoritySnapshotSchema = external_exports.object({
   outcomeId: external_exports.string().uuid().nullable(),
@@ -20307,6 +20310,7 @@ const terminalActionDispositions = new Map([
   ["create_interaction", new Set(["waiting_human", "handoff_existing_live_path"])],
   ["upsert_external_wait", new Set(["waiting_external"])],
   ["schedule_monitor", new Set(["scheduled_monitor"])],
+  ["continue_task", new Set(["continuation_scheduled"])],
 ]);
 const terminalToolNames = new Set(["runtime_action.submit", "runtime_action.status"]);
 
@@ -20330,6 +20334,18 @@ function shouldStopFromReceipt(rawResult) {
   const disposition = readString(effectResult.runDisposition);
   const existingOwner = asRecord(effectResult.existingOwner);
   const existingOwnerEpoch = Number(existingOwner.executionEpoch);
+  const continuationCount = Number(effectResult.continuationCount);
+  const maxContinuations = Number(effectResult.maxContinuations);
+  const exactContinuation = disposition === "continuation_scheduled"
+    && Boolean(readString(effectResult.chainId))
+    && Boolean(readString(effectResult.continuationIntentId))
+    && Boolean(readString(effectResult.wakeId))
+    && Number.isSafeInteger(Number(effectResult.executionEpoch))
+    && Number(effectResult.executionEpoch) > 0
+    && Number.isSafeInteger(continuationCount)
+    && continuationCount > 0
+    && Number.isSafeInteger(maxContinuations)
+    && continuationCount <= maxContinuations;
   if (!invocationId || !receiptInvocationId || !callId || !receiptCallId) return false;
 
   const exactQueuedWakeHandoff = disposition === "handoff_existing_live_path"
@@ -20356,7 +20372,8 @@ function shouldStopFromReceipt(rawResult) {
     && (disposition !== "waiting_human"
       || Boolean(readString(effectResult.interactionId) && readString(effectResult.epochKey)))
     && (disposition !== "handoff_existing_live_path"
-      || Boolean(readString(effectResult.epochKey) && exactQueuedWakeHandoff));
+      || Boolean(readString(effectResult.epochKey) && exactQueuedWakeHandoff))
+    && (disposition !== "continuation_scheduled" || exactContinuation);
 }
 
 export default function mirrorxRunTermination(pi) {
@@ -23500,6 +23517,39 @@ function resolveRuntimeCostModelIdentity({
   };
 }
 
+// src/amaster-runtime-daemon/execution-lanes.mjs
+function normalizeRuntimeExecutionLane(value) {
+  return value === "conversation" ? "conversation" : "business";
+}
+function runtimeExecutionLaneForCapabilities(value, capabilities) {
+  const lane = normalizeRuntimeExecutionLane(value);
+  return lane === "conversation" && !(Array.isArray(capabilities) && capabilities.includes("execution_lanes_v1")) ? "business" : lane;
+}
+function localRuntimeCommandLimit(input) {
+  const businessLimit = Number.isInteger(input.businessLimit) && input.businessLimit > 0 ? Math.min(input.businessLimit, 3) : 1;
+  const supportsExecutionLanes = Array.isArray(input.capabilities) && input.capabilities.includes("execution_lanes_v1");
+  return Math.min(4, businessLimit + (supportsExecutionLanes ? 1 : 0));
+}
+function selectRuntimeCommandsWithinLaneLimits(input) {
+  const businessLimit = Number.isInteger(input.businessLimit) && input.businessLimit > 0 ? Math.min(input.businessLimit, 3) : 1;
+  const totalLimit = Number.isInteger(input.totalLimit) && input.totalLimit > 0 ? Math.min(input.totalLimit, 4) : 1;
+  const counts = { business: 0, conversation: 0 };
+  for (const lane of Array.isArray(input.activeLanes) ? input.activeLanes : []) {
+    counts[runtimeExecutionLaneForCapabilities(lane, input.capabilities)] += 1;
+  }
+  const selected = [];
+  for (const command of Array.isArray(input.commands) ? input.commands : []) {
+    const lane = runtimeExecutionLaneForCapabilities(command?.executionLane, input.capabilities);
+    const total = counts.business + counts.conversation;
+    if (total >= totalLimit) continue;
+    if (lane === "business" && counts.business >= businessLimit) continue;
+    if (lane === "conversation" && counts.conversation >= 1) continue;
+    selected.push(command);
+    counts[lane] += 1;
+  }
+  return selected;
+}
+
 // src/amaster-runtime-daemon/prompt-compiler.mjs
 import { createHash as createHash9 } from "node:crypto";
 import { isAbsolute as isAbsolute5 } from "node:path";
@@ -24698,7 +24748,7 @@ function runtimeAuthorizationText(context, mode, {
   const completionContract = !suppressOrdinaryCompletionContract && completionRole && completionDeliverable ? [
     workDisposition.mode === "required" ? "Before the first business mutation, ensure the current required work disposition is recorded. Read-only governed checks may precede it. If no current valid receipt exists, call runtime_action_describe for record_work_disposition and persist exactly one truthful disposition before upsert_document, update_parent, add_comment, create_interaction, publish_delivery_manifest, or any other business mutation. Before ending this run, persist durable progress through Runtime Actions; browser and tool history alone are not durable progress." : "Before ending this run, persist durable progress through Runtime Actions and record one explicit task disposition. Browser and tool history alone are not durable progress.",
     firstDocumentCheckpoint,
-    continueTaskEnabled ? "If work remains in an ordinary productive run, call continue_task with a concrete nextAction and stable idempotencyKey, then end the run. For a future time recheck use schedule_monitor; for an external person or system action use upsert_external_wait. These are mutually exclusive final live paths. Do not call update_parent with status: in_progress." : "If work remains in an ordinary productive run, call update_parent with status: in_progress and a concrete next action so bounded continuation recovery can preserve a live path. Status: todo does not queue a normal continuation from an ordinary productive run. Only a server-issued successful-run handoff recovery may use status: todo, and only according to its exact Recovery Instruction. Otherwise use a supported terminal or waiting disposition."
+    continueTaskEnabled ? "Treat one Run as one bounded, durable checkpoint. Once that checkpoint is persisted and another independent research, build, or revision phase remains, call continue_task immediately with a concrete nextAction and stable idempotencyKey instead of keeping the current Run open, then end the run. Do not split an unfinished atomic mutation or claim progress that is not durable. For a future time recheck use schedule_monitor; for an external person or system action use upsert_external_wait. These are mutually exclusive final live paths. Do not call update_parent with status: in_progress." : "If work remains in an ordinary productive run, call update_parent with status: in_progress and a concrete next action so bounded continuation recovery can preserve a live path. Status: todo does not queue a normal continuation from an ordinary productive run. Only a server-issued successful-run handoff recovery may use status: todo, and only according to its exact Recovery Instruction. Otherwise use a supported terminal or waiting disposition."
   ].filter(Boolean).join(" ") : "";
   const businessOutcomeOwnershipContract = businessOutcome.mode === "required" ? evidenceAutoAcceptance ? [
     "Evidence-auto Business Outcome closure is owned by the Server terminal reconciler.",
@@ -25963,7 +26013,8 @@ var BUILD_SUPPORTED_CAPABILITIES = Object.freeze([
   "run_cancel",
   "run_terminate",
   "logs_cost_workspace_status",
-  "browser_credential_ref_fill_v1"
+  "browser_credential_ref_fill_v1",
+  "execution_lanes_v1"
 ]);
 var DYNAMIC_READINESS = Object.freeze({
   artifact_template_catalog_v1: {
@@ -26928,7 +26979,8 @@ var PI_TERMINAL_RUNTIME_ACTION_STATUSES = /* @__PURE__ */ new Set([
 var PI_TERMINATING_RUNTIME_ACTION_TO_DISPOSITION = /* @__PURE__ */ new Map([
   ["create_interaction", /* @__PURE__ */ new Set(["waiting_human", "handoff_existing_live_path"])],
   ["upsert_external_wait", /* @__PURE__ */ new Set(["waiting_external"])],
-  ["schedule_monitor", /* @__PURE__ */ new Set(["scheduled_monitor"])]
+  ["schedule_monitor", /* @__PURE__ */ new Set(["scheduled_monitor"])],
+  ["continue_task", /* @__PURE__ */ new Set(["continuation_scheduled"])]
 ]);
 var PI_TERMINATING_RUNTIME_ACTION_TOOLS = /* @__PURE__ */ new Set([
   "runtime_action.submit",
@@ -26991,10 +27043,17 @@ function governedMcpToolResult(structuredContent) {
   const epochKey = readString(effectResult.epochKey);
   const existingOwner = asRecord(effectResult.existingOwner);
   const existingOwnerEpoch = readNumber(existingOwner.executionEpoch, 0);
+  const continuationChainId = readString(effectResult.chainId);
+  const continuationIntentId = readString(effectResult.continuationIntentId);
+  const continuationWakeId = readString(effectResult.wakeId);
+  const continuationExecutionEpoch = readNumber(effectResult.executionEpoch, 0);
+  const continuationCount = readNumber(effectResult.continuationCount, 0);
+  const maxContinuations = readNumber(effectResult.maxContinuations, 0);
+  const exactContinuation = runDisposition === "continuation_scheduled" && continuationChainId && continuationIntentId && continuationWakeId && Number.isSafeInteger(continuationExecutionEpoch) && continuationExecutionEpoch > 0 && Number.isSafeInteger(continuationCount) && continuationCount > 0 && Number.isSafeInteger(maxContinuations) && continuationCount <= maxContinuations;
   const exactQueuedWakeHandoff = runDisposition === "handoff_existing_live_path" && readString(existingOwner.kind) === "queued_wake" && Boolean(readString(existingOwner.id)) && ["pending_dispatch", "queued", "deferred_issue_execution"].includes(
     readString(existingOwner.status) ?? ""
   ) && Number.isSafeInteger(existingOwnerEpoch) && existingOwnerEpoch > 0 && readString(existingOwner.nextAction) === "end_current_run";
-  const terminalRunDisposition = status === "succeeded" && providerStatus === "accepted" && PI_TERMINAL_RUNTIME_ACTION_STATUSES.has(runtimeActionResultStatus ?? "") && PI_TERMINATING_RUNTIME_ACTION_TOOLS.has(runtimeActionToolName ?? "") && effectResult.mustEndRun === true && Boolean(expectedDispositions?.has(runDisposition ?? "")) && invocationId && readString(providerReceipt.provider) === "amaster_actions" && readString(providerReceipt.invocationId) === invocationId && readString(providerReceipt.status) === "accepted" && receiptRunId && receiptCommandId && receiptIssueId && runtimeActionCallId && receiptCallId === runtimeActionCallId && (runDisposition !== "waiting_human" || Boolean(interactionId && epochKey)) && (runDisposition !== "handoff_existing_live_path" || Boolean(epochKey && exactQueuedWakeHandoff)) ? {
+  const terminalRunDisposition = status === "succeeded" && providerStatus === "accepted" && PI_TERMINAL_RUNTIME_ACTION_STATUSES.has(runtimeActionResultStatus ?? "") && PI_TERMINATING_RUNTIME_ACTION_TOOLS.has(runtimeActionToolName ?? "") && effectResult.mustEndRun === true && Boolean(expectedDispositions?.has(runDisposition ?? "")) && invocationId && readString(providerReceipt.provider) === "amaster_actions" && readString(providerReceipt.invocationId) === invocationId && readString(providerReceipt.status) === "accepted" && receiptRunId && receiptCommandId && receiptIssueId && runtimeActionCallId && receiptCallId === runtimeActionCallId && (runDisposition !== "waiting_human" || Boolean(interactionId && epochKey)) && (runDisposition !== "handoff_existing_live_path" || Boolean(epochKey && exactQueuedWakeHandoff)) && (runDisposition !== "continuation_scheduled" || Boolean(exactContinuation)) ? {
     disposition: runDisposition,
     actionType: receiptActionType,
     toolName: runtimeActionToolName,
@@ -27005,6 +27064,16 @@ function governedMcpToolResult(structuredContent) {
     issueId: receiptIssueId,
     ...interactionId ? { interactionId } : {},
     ...epochKey ? { epochKey } : {},
+    ...exactContinuation ? {
+      continuation: {
+        chainId: continuationChainId,
+        intentId: continuationIntentId,
+        wakeId: continuationWakeId,
+        executionEpoch: continuationExecutionEpoch,
+        count: continuationCount,
+        max: maxContinuations
+      }
+    } : {},
     ...exactQueuedWakeHandoff ? {
       existingOwner: {
         kind: "queued_wake",
@@ -27073,6 +27142,7 @@ function piTerminatingRunDispositionEvidence(results, expected = {}) {
   if (!result2) return null;
   const disposition = asRecord(result2.terminalRunDisposition);
   const existingOwner = asRecord(disposition.existingOwner);
+  const continuation = asRecord(disposition.continuation);
   return {
     kind: "runtime_action_run_disposition",
     disposition: readString(disposition.disposition),
@@ -27085,6 +27155,16 @@ function piTerminatingRunDispositionEvidence(results, expected = {}) {
     issueId: expectedIssueId,
     ...readString(disposition.interactionId) ? { interactionId: readString(disposition.interactionId) } : {},
     ...readString(disposition.epochKey) ? { epochKey: readString(disposition.epochKey) } : {},
+    ...readString(continuation.chainId) && readString(continuation.intentId) && readString(continuation.wakeId) ? {
+      continuation: {
+        chainId: readString(continuation.chainId),
+        intentId: readString(continuation.intentId),
+        wakeId: readString(continuation.wakeId),
+        executionEpoch: readNumber(continuation.executionEpoch, 0),
+        count: readNumber(continuation.count, 0),
+        max: readNumber(continuation.max, 0)
+      }
+    } : {},
     ...readString(existingOwner.kind) === "queued_wake" && readString(existingOwner.id) ? {
       existingOwner: {
         kind: "queued_wake",
@@ -27173,7 +27253,8 @@ function classifyPiTerminalCleanupDisposition(parsed, runtimeArtifacts) {
     diagnostics
   };
 }
-function classifyPiTurnLimitResult(parsed) {
+function classifyPiTurnLimitResult(parsed, options = {}) {
+  if (options.authoritativeTerminalDisposition === true) return null;
   const stopReason = readString(parsed?.stopReason);
   if (parsed?.sawAgentSettled !== true || !Number.isInteger(parsed?.settledEventIndex) || parsed?.terminalEventType !== "agent_end" || !["toolUse", "tool_use"].includes(stopReason ?? "")) return null;
   return {
@@ -29862,7 +29943,7 @@ function assertRequiredTaskAttachmentMaterialized(input, materialized) {
 }
 
 // src/amaster-runtime-daemon.mjs
-var CONNECTOR_VERSION = "0.1.1-beta.225";
+var CONNECTOR_VERSION = "0.1.1-beta.226";
 var CONNECTOR_CONTRACT_VERSION = "2026-06-04.v1";
 var daemonRequire = createRequire(import.meta.url);
 var MAX_CHECKPOINT_BYTES = 20 * 1024 * 1024;
@@ -29878,7 +29959,7 @@ var activeRunCommands = /* @__PURE__ */ new Map();
 var pendingResultOutboxRunCommands = /* @__PURE__ */ new Map();
 var pendingRunCompletionCommands = /* @__PURE__ */ new Map();
 var runCompletionFlights = /* @__PURE__ */ new Map();
-var localDispatchCommandIds = /* @__PURE__ */ new Set();
+var localDispatchCommands = /* @__PURE__ */ new Map();
 var workspaceStatusHashCache = /* @__PURE__ */ new Map();
 var processGroupRssSampleCache = null;
 var lastOrphanReaperRunAtMs = 0;
@@ -29952,6 +30033,7 @@ function runCompletionStateActiveRunCommands(config) {
     const command = asRecord(state.command);
     return {
       commandId: state.commandId,
+      executionLane: normalizeRuntimeExecutionLane(command.executionLane),
       ...readString(commandRunId(command)) ? { runId: readString(commandRunId(command)) } : {},
       ...readString(commandIssueId(command)) ? { issueId: readString(commandIssueId(command)) } : {},
       ...readString(executor.kind) ? { executorKind: readString(executor.kind) } : {},
@@ -29980,6 +30062,7 @@ function resultOutboxActiveRunCommands(config) {
     if (!commandId) continue;
     entries.push({
       commandId,
+      executionLane: normalizeRuntimeExecutionLane(activeRun.executionLane),
       ...readString(activeRun.runId) ? { runId: readString(activeRun.runId) } : {},
       ...readString(activeRun.issueId) ? { issueId: readString(activeRun.issueId) } : {},
       ...readString(activeRun.executorKind) ? { executorKind: readString(activeRun.executorKind) } : {},
@@ -30384,7 +30467,7 @@ function buildHeartbeatPayload(config, options = {}) {
   const orphanReaperSummary = asRecord(options.orphanReaper ?? lastOrphanReaperSummary);
   const activeRunCommandById = /* @__PURE__ */ new Map();
   for (const entry of [
-    ...Array.from(localDispatchCommandIds, (commandId) => ({ commandId, phase: "preparing" })),
+    ...Array.from(localDispatchCommands.values()),
     ...Array.from(activeRunCommands.values()),
     ...Array.from(pendingResultOutboxRunCommands.values()),
     ...Array.from(pendingRunCompletionCommands.values()),
@@ -30695,7 +30778,10 @@ function activeRunHeartbeatIntervalMs(config) {
 }
 function maxConcurrentCommands(config) {
   const configured = Number(config.maxConcurrentCommands);
-  return Number.isInteger(configured) && configured > 0 ? Math.min(configured, 50) : 1;
+  return localRuntimeCommandLimit({
+    businessLimit: Number.isInteger(configured) && configured > 0 ? configured : 1,
+    capabilities: config.capabilities
+  });
 }
 function activeRunCommandCount(config, options = {}) {
   const excludeCommandIds = new Set(readStringArray(options.excludeCommandIds));
@@ -30704,19 +30790,54 @@ function activeRunCommandCount(config, options = {}) {
     ...pendingResultOutboxRunCommands.keys(),
     ...pendingRunCompletionCommands.keys(),
     ...runCompletionStateEntries(config).map(({ state }) => state.commandId),
-    ...localDispatchCommandIds
+    ...localDispatchCommands.keys()
   ].filter((commandId) => !excludeCommandIds.has(commandId)));
   return commandIds.size;
 }
 function availableCommandSlots(config) {
   return Math.max(0, maxConcurrentCommands(config) - activeRunCommandCount(config));
 }
+function activeRuntimeExecutionLanes(config) {
+  const laneByCommandId = /* @__PURE__ */ new Map();
+  for (const entry of [
+    ...activeRunCommands.values(),
+    ...pendingResultOutboxRunCommands.values(),
+    ...pendingRunCompletionCommands.values(),
+    ...runCompletionStateActiveRunCommands(config),
+    ...localDispatchCommands.values()
+  ]) {
+    const commandId = readString(entry.commandId);
+    if (!commandId) continue;
+    const lane = runtimeExecutionLaneForCapabilities(entry.executionLane, config.capabilities);
+    if (!laneByCommandId.has(commandId) || lane === "conversation") {
+      laneByCommandId.set(commandId, lane);
+    }
+  }
+  return [...laneByCommandId.values()];
+}
+function locallyAdmittedCommands(config, commands) {
+  const admitted = selectRuntimeCommandsWithinLaneLimits({
+    commands,
+    activeLanes: activeRuntimeExecutionLanes(config),
+    businessLimit: Number(config.maxConcurrentCommands),
+    totalLimit: maxConcurrentCommands(config),
+    capabilities: config.capabilities
+  });
+  if (admitted.length !== commands.length) {
+    process.stderr.write(
+      `AMaster daemon deferred ${commands.length - admitted.length} leased command(s) at the local execution-lane guard.
+`
+    );
+  }
+  return admitted;
+}
 function rememberActiveRunCommand(command, metadata) {
   const commandId = readString(command.commandId) ?? readString(command.id);
   if (!commandId) return () => {
   };
   activeRunCommands.set(commandId, {
     commandId,
+    executionLane: normalizeRuntimeExecutionLane(command.executionLane),
     ...readString(commandRunId(command)) ? { runId: readString(commandRunId(command)) } : {},
     ...readString(commandIssueId(command)) ? { issueId: readString(commandIssueId(command)) } : {},
     ...metadata.executorKind ? { executorKind: metadata.executorKind } : {},
@@ -32397,7 +32518,7 @@ function walkManagedWorkdirs(root) {
 }
 function activeRuntimeExecutionRefs() {
   const activeRunIds = /* @__PURE__ */ new Set();
-  const activeCommandIds = new Set(localDispatchCommandIds);
+  const activeCommandIds = new Set(localDispatchCommands.keys());
   const activeWorkspacePaths = /* @__PURE__ */ new Set();
   for (const entry of [
     ...Array.from(activeRunCommands.values()),
@@ -32879,6 +33000,7 @@ function pendingRunCompletionSnapshot(config, state) {
   const execution = asRecord(executor.closureExecution);
   return {
     commandId: state.commandId,
+    executionLane: normalizeRuntimeExecutionLane(command.executionLane),
     ...readString(commandRunId(command)) ? { runId: readString(commandRunId(command)) } : {},
     ...readString(commandIssueId(command)) ? { issueId: readString(commandIssueId(command)) } : {},
     ...readString(executor.kind) ? { executorKind: readString(executor.kind) } : {},
@@ -34107,6 +34229,7 @@ function resultOutboxActiveRunSnapshot(command) {
   if (!current) return null;
   return {
     commandId,
+    executionLane: normalizeRuntimeExecutionLane(current.executionLane),
     ...readString(current.runId) ? { runId: readString(current.runId) } : {},
     ...readString(current.issueId) ? { issueId: readString(current.issueId) } : {},
     ...readString(current.executorKind) ? { executorKind: readString(current.executorKind) } : {},
@@ -35349,7 +35472,7 @@ async function executeRunCommand(config, command) {
     }) : null;
     if (terminalRunDisposition) {
       const disposition = readString(terminalRunDisposition.disposition);
-      parsed.summary = disposition === "handoff_existing_live_path" ? "This run handed control to the existing queued live path and ended normally without creating a duplicate interaction." : disposition === "waiting_human" ? "The requested human interaction was persisted; this run ended normally and will resume only under its continuation policy." : disposition === "waiting_external" ? "The external wait was persisted; this run ended normally and will resume only after the recorded condition is satisfied." : "The monitor schedule was persisted; this run ended normally and will resume only at the scheduled check.";
+      parsed.summary = disposition === "handoff_existing_live_path" ? "This run handed control to the existing queued live path and ended normally without creating a duplicate interaction." : disposition === "continuation_scheduled" ? "A bounded continuation was persisted; this run ended normally so another queued command can use the released execution slot." : disposition === "waiting_human" ? "The requested human interaction was persisted; this run ended normally and will resume only under its continuation policy." : disposition === "waiting_external" ? "The external wait was persisted; this run ended normally and will resume only after the recorded condition is satisfied." : "The monitor schedule was persisted; this run ended normally and will resume only at the scheduled check.";
       parsed.hasAssistantOutput = true;
       await ingestLog(
         config,
@@ -35527,7 +35650,9 @@ async function executeRunCommand(config, command) {
       );
     }
     const parsedForValidation = parsed;
-    const piTurnLimitFailure = executor.kind === "pi" && !cancelled && !hasOutputFlood && !hasArgumentAmplification && !hasMemoryLimit && execution.timedOut !== true && !execution.spawnError ? classifyPiTurnLimitResult(parsedForValidation) : null;
+    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: completionOutputStopped,
       allowMissingAssistantOutput: execution.completionOutputType === "approval_required",
@@ -35901,7 +36026,10 @@ async function runOnce(config) {
     leaseId,
     leaseSeconds: config.leaseSeconds
   });
-  const commands = Array.isArray(polled.commands) ? polled.commands : [];
+  const commands = locallyAdmittedCommands(
+    config,
+    Array.isArray(polled.commands) ? polled.commands : []
+  );
   await Promise.all(commands.map((command) => processCommand(config, command)));
   return commands.length;
 }
@@ -35934,10 +36062,19 @@ async function dispatchAvailableCommands(config, options = {}) {
     leaseId,
     leaseSeconds: config.leaseSeconds
   });
-  const commands = Array.isArray(polled.commands) ? polled.commands : [];
+  const commands = locallyAdmittedCommands(
+    config,
+    Array.isArray(polled.commands) ? polled.commands : []
+  );
   for (const command of commands) {
     const commandId = readString(command.commandId) ?? readString(command.id);
-    if (commandId) localDispatchCommandIds.add(commandId);
+    if (commandId) {
+      localDispatchCommands.set(commandId, {
+        commandId,
+        executionLane: normalizeRuntimeExecutionLane(command.executionLane),
+        phase: "preparing"
+      });
+    }
     void processCommand(config, command).catch((err) => {
       const idForLog = commandId ?? "unknown";
       const message = err instanceof Error ? err.stack || err.message : String(err);
@@ -35945,7 +36082,7 @@ async function dispatchAvailableCommands(config, options = {}) {
 ${message}
 `);
     }).finally(() => {
-      if (commandId) localDispatchCommandIds.delete(commandId);
+      if (commandId) localDispatchCommands.delete(commandId);
     });
   }
   return commands.length;

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