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

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(),
@@ -4311,6 +4314,7 @@ var amasterRuntimeConnectorCreateCommandSchema = external_exports.object({
 var amasterRuntimeConnectorPollCommandsSchema = external_exports.object({
   limit: external_exports.number().int().min(1).max(50).default(1),
   maxConcurrentCommands: external_exports.number().int().min(1).max(50).optional(),
+  maxConcurrentBusinessCommands: external_exports.number().int().min(1).max(3).optional(),
   leaseId: external_exports.string().trim().min(1).optional(),
   leaseSeconds: external_exports.number().int().min(1).max(3600).default(60)
 });
@@ -20307,6 +20311,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 +20335,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 +20373,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 +23518,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";
@@ -23770,7 +23821,7 @@ function estimatedTokens(chars) {
 }
 function promptContextMode(input) {
   const nativeSession = asRecord(input.nativeSession);
-  if (nativeSession.mode === "governed_action_approval" || readString(input.context?.resumeFromRunId) || isRecoveryWakeReason(input.wakeReason) || CONTINUATION_WAKE_PATTERN.test(input.wakeReason ?? "")) return "continuation";
+  if (nativeSession.mode === "governed_action_approval" || input.wakeReason === "continue_task" || readString(input.context?.resumeFromRunId) || isRecoveryWakeReason(input.wakeReason) || CONTINUATION_WAKE_PATTERN.test(input.wakeReason ?? "")) return "continuation";
   if (nativeSession.resume === true || Object.keys(asRecord(input.context?.paperclipContinuationSummary)).length > 0) {
     return "warm";
   }
@@ -23800,12 +23851,54 @@ function commentBodies(context) {
   const comments = Array.isArray(asRecord(context.paperclipWake).comments) ? asRecord(context.paperclipWake).comments : [];
   return comments.map((entry) => readString(asRecord(entry).body)).filter(Boolean);
 }
-function continuationText(context) {
+function continuationText(context, { omitNextAction = false } = {}) {
   const summary = asRecord(context.paperclipContinuationSummary);
-  const body = readString(summary.body);
+  const rawBody = readString(summary.body);
+  const body = omitNextAction ? rawBody?.replace(/(?:^|\n)##[ \t]+Next Action[ \t]*\n[\s\S]*$/iu, "").trimEnd() : rawBody;
   if (!body) return "";
   return [readString(summary.title), body].filter(Boolean).join("\n");
 }
+function authoritativeContinuationNextAction(context, input) {
+  if (input.wakeReason !== "continue_task") return null;
+  const nextAction = readString(context.nextAction);
+  const sourceRunId = readString(context.sourceRunId);
+  const continuationChainId = readString(context.continuationChainId);
+  const continuationIntentId = readString(context.continuationIntentId);
+  if (!nextAction || !sourceRunId || !continuationChainId || !continuationIntentId) {
+    throw promptBudgetError(
+      "continuation_next_action_unavailable",
+      "Continue Task wake requires an exact next action and complete continuation lineage"
+    );
+  }
+  const rawCheckpointPaths = context.checkpointPaths;
+  const checkpointPaths = rawCheckpointPaths === void 0 ? [] : Array.isArray(rawCheckpointPaths) ? rawCheckpointPaths.map((entry) => readString(entry)) : null;
+  if (checkpointPaths === null || checkpointPaths.length > 20 || checkpointPaths.some((path) => !path) || new Set(checkpointPaths).size !== checkpointPaths.length) {
+    throw promptBudgetError(
+      "continuation_checkpoint_contract_invalid",
+      "Continue Task wake contains invalid checkpoint path authority"
+    );
+  }
+  return {
+    sourceRef: [
+      `run:${sourceRunId}`,
+      `continuation-chain:${continuationChainId}`,
+      `continuation-intent:${continuationIntentId}`
+    ],
+    content: [
+      "The Server persisted this exact instruction when the predecessor Run yielded its execution slot.",
+      "Execute this instruction as the current stage. Do not restart the original task or repeat completed predecessor work unless this instruction explicitly requires it.",
+      "This instruction overrides any generic or inferred Next Action in the Continuation Summary.",
+      ...checkpointPaths.length > 0 ? [
+        `The Connector restored these exact predecessor checkpoint files into the current execution workspace: ${JSON.stringify(checkpointPaths)}.`,
+        "Use only these paths as run-local file continuity evidence; other predecessor workspace files were not carried forward."
+      ] : [
+        "No predecessor run-local files were declared for carry-forward. Use Server-durable documents, artifacts, work products, or the exact instruction below instead of assuming an old workspace file exists."
+      ],
+      "",
+      nextAction
+    ].join("\n")
+  };
+}
 var CONTINUATION_SUMMARY_TITLE_ALLOWLIST = /* @__PURE__ */ new Set(["Continuation Summary", "Predecessor Execution Summary"]);
 function continuationSectionTitle(context) {
   const title = readString(asRecord(context.paperclipContinuationSummary).title);
@@ -24698,7 +24791,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. If the nextAction depends on files created in this run, include their exact workspace-relative POSIX paths in checkpointPaths; only those files are integrity-checked and carried into the successor workspace. A run-local file omitted from checkpointPaths is not durable continuation state. 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.",
@@ -25044,6 +25137,7 @@ var COMPANY_INITIALIZATION_PRE_AUTHORITY_SECTIONS = /* @__PURE__ */ new Set([
   "execution_review_contract",
   "governed_business_state",
   "continuation_postcondition_gap",
+  "continuation_next_action",
   "continuation_summary",
   "resolved_dependencies",
   "runtime_delivery_readiness",
@@ -25383,8 +25477,12 @@ function compileCommandPromptWithManifest(input, options = {}) {
     `issue:${input.issueId ?? "unknown"}`,
     ...taskCommentIds.map((commentId) => `comment:${commentId}`)
   ];
-  const continuationSummary = continuationText(context);
-  const includeTask = mode === "cold" || !continuationSummary && asRecord(input.nativeSession).mode !== "governed_action_approval";
+  const continuationNextAction = authoritativeContinuationNextAction(context, input);
+  const rawContinuationSummary = continuationText(context);
+  const continuationSummary = continuationText(context, {
+    omitNextAction: Boolean(continuationNextAction)
+  });
+  const includeTask = mode === "cold" || !rawContinuationSummary && !continuationNextAction && asRecord(input.nativeSession).mode !== "governed_action_approval";
   const wakeBodies = commentBodies(context);
   const hasTaskCommentIds = Array.isArray(context.paperclipTaskMarkdownCommentIds);
   const commentsDuplicatedByTask = !hasTaskCommentIds && hasTask && wakeBodies.length > 0 && wakeBodies.every((body) => taskText.includes(body));
@@ -25436,6 +25534,7 @@ ${resolvedDependencies.details.content}` : resolvedDependencies.details.content
   const rawSections = [
     { name: "recovery_instruction", title: "Recovery Instruction", priority: 100, sourceRef: `run:${input.runId ?? "unknown"}`, content: completeRecoveryInstruction, truncationReason: completeRecoveryInstruction ? null : "mode_selection" },
     { name: "approval_continuation", title: "Approved Runtime Action Continuation", priority: 99, sourceRef: `run:${input.runId ?? "unknown"}`, content: approvalContinuationText(input), truncationReason: mode === "continuation" ? null : "mode_selection" },
+    ...continuationNextAction ? [{ name: "continuation_next_action", title: "Authoritative Continuation Next Action", priority: 100, ...continuationNextAction }] : [],
     { name: "wake_comments", title: wakeDeltaTitle, priority: interactionResolution ? 99 : 95, sourceRef: wakeDeltaSourceRefs, originalContent: wakeDeltaOriginal, content: wakeDeltaContent, truncationReason: commentsSelected ? null : "duplicate_task_context" },
     { name: "task", title: "Task Context", priority: 90, sourceRef: taskSourceRefs, originalContent: [taskText, taskCommentRefGuidance(input, taskText)].filter(Boolean).join("\n"), content: includeTask ? [taskText, taskCommentRefGuidance(input, taskText)].filter(Boolean).join("\n") : "", truncationReason: includeTask ? null : "mode_selection" },
     ...taskAcceptanceContract ? [{ name: "task_acceptance_contract", title: "Task Acceptance Contract", priority: 100, ...taskAcceptanceContract }] : [],
@@ -25963,7 +26062,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,12 +27028,24 @@ 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",
   "runtime_action.status"
 ]);
+function continuationCheckpointPaths(value) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value) || value.length < 1 || value.length > 20) return null;
+  const paths = value.map((entry) => readString(entry));
+  if (paths.some((entry) => !entry)) return null;
+  if (new Set(paths).size !== paths.length) return null;
+  for (const path of paths) {
+    if (path.includes("\\") || path.startsWith("/") || /^[A-Za-z]:\//.test(path) || path.split("/").some((segment) => !segment || segment === "." || segment === ".." || segment.startsWith(".")) || path.startsWith("input-attachments/") || ["AGENTS.md", "SOUL.md"].includes(path.split("/").at(-1) ?? "")) return null;
+  }
+  return paths;
+}
 function approvedMcpInvocationSucceeded(results, invocationId) {
   const approvedInvocationId = readString(invocationId);
   return Boolean(approvedInvocationId && (Array.isArray(results) ? results : []).some((rawResult) => {
@@ -26991,10 +27103,18 @@ 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 continuationCheckpointPathList = continuationCheckpointPaths(effectResult.checkpointPaths);
+  const exactContinuation = runDisposition === "continuation_scheduled" && continuationChainId && continuationIntentId && continuationWakeId && Number.isSafeInteger(continuationExecutionEpoch) && continuationExecutionEpoch > 0 && Number.isSafeInteger(continuationCount) && continuationCount > 0 && Number.isSafeInteger(maxContinuations) && continuationCount <= maxContinuations && continuationCheckpointPathList !== null;
   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 +27125,17 @@ function governedMcpToolResult(structuredContent) {
     issueId: receiptIssueId,
     ...interactionId ? { interactionId } : {},
     ...epochKey ? { epochKey } : {},
+    ...exactContinuation ? {
+      continuation: {
+        chainId: continuationChainId,
+        intentId: continuationIntentId,
+        wakeId: continuationWakeId,
+        executionEpoch: continuationExecutionEpoch,
+        count: continuationCount,
+        max: maxContinuations,
+        ...continuationCheckpointPathList.length > 0 ? { checkpointPaths: continuationCheckpointPathList } : {}
+      }
+    } : {},
     ...exactQueuedWakeHandoff ? {
       existingOwner: {
         kind: "queued_wake",
@@ -27073,6 +27204,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 +27217,17 @@ 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),
+        ...Array.isArray(continuation.checkpointPaths) ? { checkpointPaths: continuation.checkpointPaths.map((entry) => readString(entry)).filter(Boolean) } : {}
+      }
+    } : {},
     ...readString(existingOwner.kind) === "queued_wake" && readString(existingOwner.id) ? {
       existingOwner: {
         kind: "queued_wake",
@@ -27173,7 +27316,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 {
@@ -27760,14 +27904,11 @@ function piRuntimeWebEvidence(event) {
 }
 function parsePiJsonl(stdout) {
   let sessionId = null;
-  let errorMessage = null;
   let streamingText = "";
   let sawTurnEnd = false;
   let terminalEventType = null;
   let stopReason = null;
   let hasAssistantOutput = false;
-  let nonCleanupErrorCount = 0;
-  let nonCleanupErrorMessage = null;
   let terminalEventIndex = null;
   let sawAgentSettled = false;
   let settledEventIndex = null;
@@ -27776,12 +27917,45 @@ function parsePiJsonl(stdout) {
   const mcpToolResults = [];
   const cleanupDiagnostics = [];
   const diagnostics = [];
+  const errorEvents = [];
+  let retry = null;
+  let turnStartIndex = -1;
+  let successfulAssistantIndex = -1;
   const usage = { inputTokens: 0, cachedInputTokens: 0, outputTokens: 0 };
   for (const rawLine of String(stdout ?? "").split(/\r?\n/)) {
     const event = parseJsonLine(rawLine.trim());
     if (!event) continue;
     eventIndex += 1;
     mcpToolResults.push(...piMcpToolResults(event));
+    if (event.type === "turn_start") turnStartIndex = eventIndex;
+    if (event.type === "auto_retry_start") {
+      const message = readString(event.errorMessage);
+      const lastError = errorEvents.at(-1);
+      const matched = Number.isSafeInteger(event.attempt) && event.attempt > 0 && (event.attempt === 1 || event.attempt === retry?.attempt + 1) && turnStartIndex >= 0 && lastError?.provider === true && lastError.message === message && lastError.eventIndex === terminalEventIndex && terminalEventType === "agent_end";
+      const priorErrors = retry && event.attempt === retry.attempt + 1 ? retry.errors : [];
+      retry = matched ? {
+        attempt: event.attempt,
+        startIndex: eventIndex,
+        errors: [...priorErrors, ...errorEvents.filter((error) => error.eventIndex >= turnStartIndex && error.provider && error.message === message)]
+      } : null;
+      continue;
+    }
+    if (event.type === "auto_retry_end") {
+      if (event.success === true && retry && event.attempt === retry.attempt && successfulAssistantIndex > retry.startIndex) {
+        for (const error of retry.errors) error.recoveredAt = eventIndex;
+        diagnostics.push({
+          source: "provider",
+          phase: "retry",
+          severity: "info",
+          code: "pi_provider_retry_recovered",
+          attempt: retry.attempt,
+          recoveredErrorEventCount: retry.errors.length,
+          eventIndex
+        });
+      }
+      retry = null;
+      continue;
+    }
     if (event.type === "session") {
       sessionId = readString(event.sessionId) ?? readString(event.id) ?? sessionId;
       continue;
@@ -27817,9 +27991,12 @@ function parsePiJsonl(stdout) {
       stopReason = readString(event.stopReason ?? event.stop_reason) ?? piNestedMessageStopReason(event) ?? stopReason;
       const terminalError = piStopReasonErrorText(event) ?? piNestedMessageErrorText(event);
       if (terminalError) {
-        nonCleanupErrorCount += 1;
-        nonCleanupErrorMessage = terminalError;
-        errorMessage = terminalError;
+        errorEvents.push({
+          message: terminalError,
+          eventIndex,
+          provider: classifyPiProviderError({ errorMessage: terminalError })?.errorFamily === "transient_upstream"
+        });
+        successfulAssistantIndex = -1;
         if (PI_PROVIDER_PROTOCOL_RE.test(terminalError)) {
           diagnostics.push({
             source: "provider",
@@ -27831,6 +28008,9 @@ function parsePiJsonl(stdout) {
           });
         }
       }
+      if (event.type === "message_end" && asRecord(event.message).role === "assistant" && !terminalError && ["stop", "toolUse"].includes(piMessageStopReason(event.message))) {
+        successfulAssistantIndex = eventIndex;
+      }
       hasAssistantOutput = maybeCapturePiMessage(event, messages, usage) || hasAssistantOutput;
       continue;
     }
@@ -27850,11 +28030,9 @@ function parsePiJsonl(stdout) {
           ...diagnostic,
           eventIndex
         });
-        errorMessage = nonCleanupErrorMessage ?? eventError;
       } else {
-        nonCleanupErrorCount += 1;
-        nonCleanupErrorMessage = eventError;
-        errorMessage = eventError;
+        errorEvents.push({ message: eventError, eventIndex, provider: false });
+        successfulAssistantIndex = -1;
         if (PI_PROVIDER_PROTOCOL_RE.test(eventError)) {
           diagnostics.push({
             source: "provider",
@@ -27868,6 +28046,9 @@ function parsePiJsonl(stdout) {
       }
     }
   }
+  const unresolvedErrors = errorEvents.filter((error) => !(Number.isInteger(error.recoveredAt) && terminalEventIndex > error.recoveredAt && sawAgentSettled && settledEventIndex > terminalEventIndex));
+  const nonCleanupErrorCount = unresolvedErrors.length;
+  const errorMessage = unresolvedErrors.at(-1)?.message ?? cleanupDiagnostics.at(-1)?.message ?? null;
   const uniqueMcpToolResults = dedupeGovernedMcpToolResults(mcpToolResults);
   return {
     sessionId,
@@ -29862,7 +30043,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.227";
 var CONNECTOR_CONTRACT_VERSION = "2026-06-04.v1";
 var daemonRequire = createRequire(import.meta.url);
 var MAX_CHECKPOINT_BYTES = 20 * 1024 * 1024;
@@ -29878,7 +30059,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 +30133,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 +30162,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 +30567,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 +30878,14 @@ 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 maxConcurrentBusinessCommands(config) {
+  const configured = Number(config.maxConcurrentCommands);
+  return Number.isInteger(configured) && configured > 0 ? Math.min(configured, 3) : 1;
 }
 function activeRunCommandCount(config, options = {}) {
   const excludeCommandIds = new Set(readStringArray(options.excludeCommandIds));
@@ -30704,19 +30894,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 } : {},
@@ -30913,6 +31138,7 @@ async function poll(config) {
   const body = await postJson(config, `/api/amaster/runtime-connectors/${connectorId}/commands/poll`, {
     limit: Math.max(1, limit),
     maxConcurrentCommands: maxCommands,
+    maxConcurrentBusinessCommands: maxConcurrentBusinessCommands(config),
     leaseId: `amaster-${Date.now()}`,
     leaseSeconds: config.leaseSeconds
   });
@@ -32397,7 +32623,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 +33105,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 +34334,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) } : {},
@@ -34639,10 +34867,36 @@ function safeCheckpointRelativePath(rawPath) {
 function hashFileSha256(filePath) {
   return createHash17("sha256").update(readFileSync18(filePath)).digest("hex");
 }
+function expectedContinuationCheckpoint(command) {
+  const payload = asRecord(command.payload);
+  const envelope = asRecord(payload.contextEnvelope);
+  const context = asRecord(asRecord(envelope.runDecisionContext).content);
+  if (readString(context.wakeReason) !== "continue_task") return null;
+  const rawPaths = context.checkpointPaths;
+  if (rawPaths === void 0) return null;
+  if (!Array.isArray(rawPaths) || rawPaths.length < 1 || rawPaths.length > 20) {
+    throw new Error("continuation_checkpoint_contract_invalid: checkpointPaths");
+  }
+  const paths = rawPaths.map((entry) => safeCheckpointRelativePath(readString(entry)));
+  if (paths.some((entry) => !entry) || new Set(paths).size !== paths.length) {
+    throw new Error("continuation_checkpoint_contract_invalid: checkpointPaths");
+  }
+  const sourceRunId = readString(context.sourceRunId);
+  const continuationChainId = readString(context.continuationChainId);
+  const continuationIntentId = readString(context.continuationIntentId);
+  if (!sourceRunId || !continuationChainId || !continuationIntentId) {
+    throw new Error("continuation_checkpoint_contract_invalid: lineage");
+  }
+  return { paths, sourceRunId, continuationChainId, continuationIntentId };
+}
 async function materializeIssueCheckpoint(config, command, workspace) {
   const checkpointDir = issueCheckpointDir(workspace);
   const manifestPath = join17(checkpointDir, "manifest.json");
-  if (!existsSync17(manifestPath)) return [];
+  const expectedContinuation = expectedContinuationCheckpoint(command);
+  if (!existsSync17(manifestPath)) {
+    if (expectedContinuation) throw new Error("continuation_checkpoint_unavailable: manifest_missing");
+    return [];
+  }
   let manifest;
   try {
     manifest = asRecord(JSON.parse(readFileSync18(manifestPath, "utf8")));
@@ -34653,11 +34907,21 @@ async function materializeIssueCheckpoint(config, command, workspace) {
   const expiresAt = Date.parse(readString(manifest.expiresAt) ?? "");
   if (!Number.isFinite(expiresAt) || expiresAt <= Date.now() || readString(manifest.issueId) !== commandIssueId(command)) {
     rmSync9(checkpointDir, { recursive: true, force: true });
+    if (expectedContinuation) throw new Error("continuation_checkpoint_unavailable: manifest_expired_or_mismatched");
     return [];
   }
   try {
+    if (readString(manifest.kind) === "continue_task" && !expectedContinuation) {
+      return [];
+    }
     const files = Array.isArray(manifest.files) ? manifest.files : [];
     if (files.length > 20) throw new Error("issue checkpoint manifest exceeds the limit of 20 files");
+    if (expectedContinuation) {
+      const manifestPaths = files.map((entry) => safeCheckpointRelativePath(readString(asRecord(entry).path)));
+      if (readString(manifest.kind) !== "continue_task" || readString(manifest.sourceRunId) !== expectedContinuation.sourceRunId || readString(manifest.continuationChainId) !== expectedContinuation.continuationChainId || readString(manifest.continuationIntentId) !== expectedContinuation.continuationIntentId || manifestPaths.some((entry) => !entry) || manifestPaths.length !== expectedContinuation.paths.length || manifestPaths.some((entry, index) => entry !== expectedContinuation.paths[index])) {
+        throw new Error("continuation_checkpoint_lineage_mismatch");
+      }
+    }
     const filesRoot = realpathSync8(join17(checkpointDir, "files"));
     const workspaceRoot = realpathSync8(workspace.cwd);
     const validated = [];
@@ -34686,22 +34950,45 @@ async function materializeIssueCheckpoint(config, command, workspace) {
       }
       totalBytes += expectedByteSize;
       if (totalBytes > MAX_CHECKPOINT_BYTES) throw new Error("issue checkpoint exceeds the 20 MB restore limit");
-      validated.push({ relativePath, source, target });
+      validated.push({
+        relativePath,
+        source,
+        target,
+        expectedSha256,
+        expectedByteSize
+      });
     }
     const materialized = [];
-    for (const { relativePath, source, target } of validated) {
-      try {
-        lstatSync11(target);
-        continue;
-      } catch (err) {
-        if (err?.code !== "ENOENT") throw err;
-      }
+    for (const { relativePath, source, target, expectedSha256, expectedByteSize } of validated) {
       mkdirSync9(dirname11(target), { recursive: true });
       const targetParent = realpathSync8(dirname11(target));
       if (!pathWithin3(targetParent, workspaceRoot)) {
         throw new Error(`issue checkpoint target escapes its workspace: ${relativePath}`);
       }
-      copyFileSync2(source, target);
+      let existingTarget = null;
+      try {
+        existingTarget = lstatSync11(target);
+      } catch (err) {
+        if (err?.code !== "ENOENT") throw err;
+      }
+      if (existingTarget && !existingTarget.isFile()) {
+        throw new Error(`issue checkpoint target is not a regular file: ${relativePath}`);
+      }
+      if (existingTarget && existingTarget.size === expectedByteSize && hashFileSha256(target) === expectedSha256) {
+        materialized.push(relativePath);
+        continue;
+      }
+      const temporaryTarget = join17(targetParent, `.${basename8(target)}.checkpoint-${randomUUID()}.tmp`);
+      try {
+        copyFileSync2(source, temporaryTarget);
+        const temporaryStat = lstatSync11(temporaryTarget);
+        if (!temporaryStat.isFile() || temporaryStat.size !== expectedByteSize || hashFileSha256(temporaryTarget) !== expectedSha256) {
+          throw new Error(`issue checkpoint target verification failed: ${relativePath}`);
+        }
+        renameSync10(temporaryTarget, target);
+      } finally {
+        rmSync9(temporaryTarget, { force: true });
+      }
       materialized.push(relativePath);
     }
     if (materialized.length > 0) {
@@ -34723,48 +35010,112 @@ async function materializeIssueCheckpoint(config, command, workspace) {
     throw restoreErr;
   }
 }
-async function saveIssueCheckpoint(config, command, workspace, candidates) {
+async function saveIssueCheckpoint(config, command, workspace, candidates, options = {}) {
   const checkpointDir = issueCheckpointDir(workspace);
-  const filesDir = join17(checkpointDir, "files");
-  rmSync9(checkpointDir, { recursive: true, force: true });
+  const commandKey = readString(command.commandId)?.replace(/[^A-Za-z0-9_-]/g, "-") ?? randomUUID();
+  const stagingDir = `${checkpointDir}.tmp-${commandKey}`;
+  const backupDir = `${checkpointDir}.previous-${commandKey}`;
+  const filesDir = join17(stagingDir, "files");
+  rmSync9(stagingDir, { recursive: true, force: true });
+  rmSync9(backupDir, { recursive: true, force: true });
   mkdirSync9(filesDir, { recursive: true });
-  const files = [];
-  let totalBytes = 0;
-  const workspaceRoot = realpathSync8(workspace.cwd);
-  for (const candidate of candidates.slice(0, 20)) {
-    const relativePath = safeCheckpointRelativePath(candidate.rawPath);
-    const source = readString(candidate.filePath);
-    if (!relativePath || !source || !existsSync17(source) || !statSync11(source).isFile()) continue;
-    const ownedSource = realpathSync8(source);
-    if (!pathWithin3(ownedSource, workspaceRoot)) {
-      throw new Error(`issue checkpoint source escapes its execution workspace: ${relativePath}`);
-    }
-    const byteSize = statSync11(ownedSource).size;
-    if (byteSize <= 0 || totalBytes + byteSize > MAX_CHECKPOINT_BYTES) continue;
-    const target = resolve16(filesDir, relativePath);
-    if (!pathWithin3(target, filesDir)) continue;
-    mkdirSync9(dirname11(target), { recursive: true });
-    copyFileSync2(ownedSource, target);
-    totalBytes += byteSize;
-    files.push({ path: relativePath, byteSize, sha256: hashFileSha256(ownedSource) });
-  }
-  if (files.length === 0) {
-    rmSync9(checkpointDir, { recursive: true, force: true });
-    return null;
-  }
-  const manifest = {
-    version: 1,
-    issueId: commandIssueId(command),
-    sourceRunId: commandRunId(command),
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    expiresAt: new Date(Date.now() + CHECKPOINT_TTL_MS).toISOString(),
-    totalBytes,
-    files
-  };
-  writeFileSync11(join17(checkpointDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+  try {
+    const files = [];
+    let totalBytes = 0;
+    const workspaceRoot = realpathSync8(workspace.cwd);
+    const requiredPaths = Array.isArray(options.requiredPaths) ? options.requiredPaths : [];
+    const selectedCandidates = requiredPaths.length > 0 ? requiredPaths.map((requiredPath) => {
+      const normalized = safeCheckpointRelativePath(requiredPath);
+      if (!normalized) {
+        throw new Error(`continuation_checkpoint_file_unavailable: ${requiredPath}`);
+      }
+      const sourceCandidate = resolve16(workspaceRoot, normalized);
+      if (!pathWithin3(sourceCandidate, workspaceRoot)) {
+        throw new Error(`continuation_checkpoint_file_unavailable: ${requiredPath}`);
+      }
+      let sourceStat;
+      try {
+        sourceStat = lstatSync11(sourceCandidate);
+      } catch (err) {
+        if (err?.code === "ENOENT") {
+          throw new Error(`continuation_checkpoint_file_unavailable: ${requiredPath}`);
+        }
+        throw err;
+      }
+      if (!sourceStat.isFile()) {
+        throw new Error(`continuation_checkpoint_file_unavailable: ${requiredPath}`);
+      }
+      const ownedSource = realpathSync8(sourceCandidate);
+      if (!pathWithin3(ownedSource, workspaceRoot)) {
+        throw new Error(`issue checkpoint source escapes its execution workspace: ${normalized}`);
+      }
+      return { rawPath: normalized, filePath: ownedSource };
+    }) : candidates.slice(0, 20);
+    for (const candidate of selectedCandidates) {
+      const relativePath = safeCheckpointRelativePath(candidate.rawPath);
+      const source = readString(candidate.filePath);
+      if (!relativePath || !source || !existsSync17(source) || !statSync11(source).isFile()) {
+        if (requiredPaths.length > 0) throw new Error(`continuation_checkpoint_file_unavailable: ${candidate.rawPath}`);
+        continue;
+      }
+      const ownedSource = realpathSync8(source);
+      if (!pathWithin3(ownedSource, workspaceRoot)) {
+        throw new Error(`issue checkpoint source escapes its execution workspace: ${relativePath}`);
+      }
+      const byteSize = statSync11(ownedSource).size;
+      if (byteSize <= 0 || totalBytes + byteSize > MAX_CHECKPOINT_BYTES) {
+        if (requiredPaths.length > 0) throw new Error(`continuation_checkpoint_file_size_invalid: ${relativePath}`);
+        continue;
+      }
+      const target = resolve16(filesDir, relativePath);
+      if (!pathWithin3(target, filesDir)) continue;
+      mkdirSync9(dirname11(target), { recursive: true });
+      copyFileSync2(ownedSource, target);
+      const storedStat = lstatSync11(target);
+      if (!storedStat.isFile() || storedStat.size !== byteSize) {
+        throw new Error(`issue checkpoint copy verification failed: ${relativePath}`);
+      }
+      totalBytes += byteSize;
+      files.push({ path: relativePath, byteSize, sha256: hashFileSha256(target) });
+    }
+    if (files.length === 0) {
+      rmSync9(stagingDir, { recursive: true, force: true });
+      rmSync9(checkpointDir, { recursive: true, force: true });
+      return null;
+    }
+    const manifest = {
+      version: options.continuation ? 2 : 1,
+      issueId: commandIssueId(command),
+      sourceRunId: commandRunId(command),
+      ...options.continuation ? {
+        kind: "continue_task",
+        continuationChainId: options.continuation.chainId,
+        continuationIntentId: options.continuation.intentId
+      } : {},
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      expiresAt: new Date(Date.now() + CHECKPOINT_TTL_MS).toISOString(),
+      totalBytes,
+      files
+    };
+    writeFileSync11(join17(stagingDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `);
-  await ingestLog(config, command, "system", "warn", `Saved ${files.length} required deliverable(s) for continuation recovery`, manifest);
-  return manifest;
+    const replacingExistingCheckpoint = existsSync17(checkpointDir);
+    if (replacingExistingCheckpoint) renameSync10(checkpointDir, backupDir);
+    try {
+      renameSync10(stagingDir, checkpointDir);
+    } catch (err) {
+      if (replacingExistingCheckpoint && existsSync17(backupDir) && !existsSync17(checkpointDir)) {
+        renameSync10(backupDir, checkpointDir);
+      }
+      throw err;
+    }
+    rmSync9(backupDir, { recursive: true, force: true });
+    await ingestLog(config, command, "system", "info", `Saved ${files.length} issue checkpoint file(s) for continuation`, manifest);
+    return manifest;
+  } catch (err) {
+    rmSync9(stagingDir, { recursive: true, force: true });
+    throw err;
+  }
 }
 function piOutputUsageMetadataMissing(parsed) {
   const usage = parsed?.usage ?? {};
@@ -34837,7 +35188,7 @@ async function executeRunCommand(config, command) {
     agentInstructionFiles: [...finalAgentInstructionFiles.values()].sort((left, right) => left.path.localeCompare(right.path)),
     workspaceProjectInstructionProjection: workspaceProjectInstructionReceipt
   });
-  await materializeIssueCheckpoint(config, command, workspace);
+  const materializedCheckpointFiles = await materializeIssueCheckpoint(config, command, workspace);
   const requiredArtifactInputs = await materializeRequiredArtifactInputs(config, command, workspace);
   let materializedAttachments = requiredArtifactInputs;
   try {
@@ -35347,9 +35698,34 @@ async function executeRunCommand(config, command) {
       commandId: command.commandId,
       issueId: commandIssueId(command)
     }) : null;
+    let continuationCheckpoint = null;
+    if (readString(terminalRunDisposition?.disposition) === "continuation_scheduled") {
+      const continuation = asRecord(terminalRunDisposition.continuation);
+      const checkpointPaths = Array.isArray(continuation.checkpointPaths) ? continuation.checkpointPaths.map((entry) => readString(entry)).filter(Boolean) : [];
+      if (checkpointPaths.length > 0) {
+        continuationCheckpoint = await saveIssueCheckpoint(
+          config,
+          command,
+          workspace,
+          workspaceStatus.artifacts.map((artifact) => ({
+            rawPath: artifact.relativePath,
+            filePath: resolve16(cwd, artifact.relativePath)
+          })),
+          {
+            requiredPaths: checkpointPaths,
+            continuation: {
+              chainId: readString(continuation.chainId),
+              intentId: readString(continuation.intentId)
+            }
+          }
+        );
+      } else {
+        await clearIssueCheckpoint(config, command, workspace, "continue_task_without_checkpoint_paths");
+      }
+    }
     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 +35903,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",
@@ -35591,6 +35969,14 @@ async function executeRunCommand(config, command) {
       ...costUsage ? { costUsage } : {},
       ...terminalTextRepair ? { terminalTextRepair: terminalTextRepair.audit } : {},
       ...terminalRunDisposition ? { terminalRunDisposition } : {},
+      ...continuationCheckpoint ? {
+        continuationCheckpoint: {
+          fileCount: continuationCheckpoint.files.length,
+          totalBytes: continuationCheckpoint.totalBytes,
+          paths: continuationCheckpoint.files.map((file) => file.path)
+        }
+      } : {},
+      ...materializedCheckpointFiles.length > 0 ? { materializedCheckpointFiles } : {},
       ...runtimeArtifacts.length > 0 ? { runtimeArtifacts } : {},
       ...runtimeDocuments.length > 0 ? { runtimeDocuments } : {},
       outputTelemetry,
@@ -35898,10 +36284,14 @@ async function runOnce(config) {
   const polled = await postJson(config, `/api/amaster/runtime-connectors/${config.connectorId}/commands/poll`, {
     limit: Math.max(1, availableSlots),
     maxConcurrentCommands: maxConcurrentCommands(config),
+    maxConcurrentBusinessCommands: maxConcurrentBusinessCommands(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;
 }
@@ -35931,13 +36321,23 @@ async function dispatchAvailableCommands(config, options = {}) {
   const polled = await postJson(config, `/api/amaster/runtime-connectors/${config.connectorId}/commands/poll`, {
     limit: Math.max(1, availableSlots),
     maxConcurrentCommands: maxConcurrentCommands(config),
+    maxConcurrentBusinessCommands: maxConcurrentBusinessCommands(config),
     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 +36345,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.227";
 
 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.227",
   "description": "MirrorX runtime connector CLI and daemon",
   "license": "MIT",
   "type": "module",