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

package/dist/amaster-runtime-daemon.mjs

@@ -4314,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)
 });
@@ -23820,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";
   }
@@ -23850,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);
@@ -24748,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 ? "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."
+    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.",
@@ -25094,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",
@@ -25433,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));
@@ -25486,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 }] : [],
@@ -26986,6 +27035,17 @@ 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) => {
@@ -27049,7 +27109,8 @@ function governedMcpToolResult(structuredContent) {
   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 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";
@@ -27071,7 +27132,8 @@ function governedMcpToolResult(structuredContent) {
         wakeId: continuationWakeId,
         executionEpoch: continuationExecutionEpoch,
         count: continuationCount,
-        max: maxContinuations
+        max: maxContinuations,
+        ...continuationCheckpointPathList.length > 0 ? { checkpointPaths: continuationCheckpointPathList } : {}
       }
     } : {},
     ...exactQueuedWakeHandoff ? {
@@ -27162,7 +27224,8 @@ function piTerminatingRunDispositionEvidence(results, expected = {}) {
         wakeId: readString(continuation.wakeId),
         executionEpoch: readNumber(continuation.executionEpoch, 0),
         count: readNumber(continuation.count, 0),
-        max: readNumber(continuation.max, 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) ? {
@@ -27841,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;
@@ -27857,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;
@@ -27898,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",
@@ -27912,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;
     }
@@ -27931,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",
@@ -27949,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,
@@ -29943,7 +30043,7 @@ function assertRequiredTaskAttachmentMaterialized(input, materialized) {
 }
 
 // src/amaster-runtime-daemon.mjs
-var CONNECTOR_VERSION = "0.1.1-beta.226";
+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;
@@ -30783,6 +30883,10 @@ function maxConcurrentCommands(config) {
     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));
   const commandIds = new Set([
@@ -31034,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
   });
@@ -34762,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")));
@@ -34776,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 = [];
@@ -34809,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) {
@@ -34846,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 ?? {};
@@ -34960,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 {
@@ -35470,6 +35698,31 @@ 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 === "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.";
@@ -35716,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,
@@ -36023,6 +36284,7 @@ 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
   });
@@ -36059,6 +36321,7 @@ 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
   });

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