@moretea-labs/forge 1.5.1 → 1.7.0

package/src/runtime/gateway/mcp/process-tools.ts

@@ -1,22 +1,20 @@
 /**
- * Repository-scoped Managed Process lifecycle MCP tools.
+ * Repository-scoped Lightweight/Durable Process lifecycle MCP tools.
  *
  * process_get / process_wait / process_logs / process_cancel
  *
- * These tools attach to an existing Process Runtime handle — they never
- * re-execute the original command.
+ * These tools attach to an existing in-memory lightweight or persisted durable
+ * handle. They never re-execute the original command.
  */
 
 import type { McpToolDefinition, CallToolResult } from '../../../cli/mcp/tools';
 import type { MultiRepositoryMcpToolContext } from '../../../cli/mcp/multi-repository';
-import { getRepository } from '../../../cli/repositories/registry';
 import {
-  cancelProcess,
-  getProcessHandle,
-  readProcessLogs,
-  waitForProcess,
+  cancelRepositoryCommandProcess,
+  getRepositoryCommandProcess,
+  readRepositoryCommandProcessLogs,
+  waitRepositoryCommandProcess,
 } from '../../execution/process-runtime';
-import { getProcessRecord } from '../../execution/process-runtime/store';
 import { redactSensitiveText, redactSensitiveValue } from '../../evidence/sensitive-output';
 
 function definition(
@@ -42,17 +40,36 @@ function definition(
 
 const repoIdProp = {
   type: 'string',
-  description: 'Stable repository id. Process must belong to this repository.',
+  description: 'Repository or ephemeral workspace scope id returned by the originating command. Process must belong to this scope.',
 };
 const processIdProp = {
   type: 'string',
-  description: 'Managed process id returned by Process Runtime (e.g. from run_check / repository_command).',
+  description: 'Lightweight or durable process id returned by run_check / repository_command_execute.',
 };
 
 export const processToolDefinitions: McpToolDefinition[] = [
+  definition(
+    'run_check',
+    'Run one focused repository check, or launch one resource-compatible check wave, through Process Runtime. Use check_id for the existing single-check behavior or check_ids for a batch; do not send both. Batch mode validates the existing check-scheduling resource model and starts every check in one compatible wave concurrently without waiting for completion or creating a second scheduler. Cross-wave, invalid, release, and multi-phase batches fail closed. Long ordinary checks return managed handles; attach only at a real dependency boundary.',
+    {
+      repo_id: repoIdProp,
+      checkout_id: { type: 'string' },
+      check_id: { type: 'string', description: 'Single check id. Mutually exclusive with check_ids.' },
+      check_ids: { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 32, uniqueItems: true, description: 'Batch check ids. All requested checks must fit one resource-compatible execution wave; mutually exclusive with check_id.' },
+      timeout_ms: { type: 'number' },
+      request_id: { type: 'string' },
+      issue_id: { type: 'string' },
+      task_id: { type: 'string' },
+      mode: { type: 'string', enum: ['direct', 'async', 'durable'] },
+      apply_mode: { type: 'string', enum: ['sync', 'async'] },
+      force_durable: { type: 'boolean' },
+    },
+    [],
+    false,
+  ),
   definition(
     'process_get',
-    'Get the current status of a managed process without re-executing the command. Readonly.',
+    'Non-blocking observation of a lightweight or durable process; never re-executes. Use only when the observation can change the next decision. It is not a synchronization join.',
     {
       repo_id: repoIdProp,
       process_id: processIdProp,
@@ -62,7 +79,7 @@ export const processToolDefinitions: McpToolDefinition[] = [
   ),
   definition(
     'process_wait',
-    'Wait for a managed process to complete or until timeout_ms. Does not re-execute the command. Readonly attach/poll.',
+    'Explicit dependency synchronization for one lightweight or durable process. Call only when the next decision or acceptance boundary is blocked on this exact result; do not use as periodic polling. Waits never re-execute the command.',
     {
       repo_id: repoIdProp,
       process_id: processIdProp,
@@ -73,7 +90,7 @@ export const processToolDefinitions: McpToolDefinition[] = [
   ),
   definition(
     'process_logs',
-    'Read a bounded tail of managed process stdout/stderr. Never loads unbounded logs. Readonly.',
+    'Read a bounded tail of lightweight or durable process stdout/stderr. Never loads unbounded logs. Readonly.',
     {
       repo_id: repoIdProp,
       process_id: processIdProp,
@@ -84,7 +101,7 @@ export const processToolDefinitions: McpToolDefinition[] = [
   ),
   definition(
     'process_cancel',
-    'Cancel a managed process. Requires verified PID identity (start time + executable fingerprint). Untrusted PIDs are refused. Classified as workspace-write / process-control.',
+    'Cancel a lightweight or durable process through its owning runtime handle. Classified as workspace-write / process-control.',
     {
       repo_id: repoIdProp,
       process_id: processIdProp,
@@ -96,10 +113,36 @@ export const processToolDefinitions: McpToolDefinition[] = [
 ];
 
 const processToolNames = new Set(processToolDefinitions.map((tool) => tool.name));
-// Public MCP clients commonly detach around one minute. Return a normal attach
-// snapshot before that deadline rather than allowing transport timeout to turn
-// a healthy Process into an error-shaped response.
-export const DEFAULT_PROCESS_WAIT_ATTACH_BUDGET_MS = 55_000;
+const processAttachmentToolNames = new Set(['process_get', 'process_wait', 'process_logs', 'process_cancel']);
+// A long-lived MCP wait can monopolize shared Runtime request/transport capacity
+// even though the underlying Process wait is asynchronous. Keep public waits
+// short and return a normal running snapshot; the Process continues unchanged
+// and callers can attach again only when the result is a real dependency.
+export const DEFAULT_PROCESS_WAIT_ATTACH_BUDGET_MS = 5_000;
+
+/**
+ * Stable controller-facing continuation semantics for a returned Process.
+ * This is deliberately response-only: Process Runtime remains the sole owner
+ * of execution and no polling scheduler or second state authority is created.
+ */
+export function managedProcessContinuation(handle: { completed?: boolean }): Record<string, string> {
+  if (handle.completed === true) {
+    return {
+      state: 'terminal',
+      nextAction: 'consume_terminal_result',
+      join: 'complete',
+      reexecution: 'forbidden',
+    };
+  }
+  return {
+    state: 'background',
+    nextAction: 'continue_independent_work',
+    join: 'required_at_dependency_boundary',
+    observation: 'process_get_if_it_can_change_the_next_decision',
+    repeatedWait: 'not_recommended',
+    reexecution: 'forbidden',
+  };
+}
 
 function result(value: Record<string, unknown>, isError = false): CallToolResult {
   const safe = redactSensitiveValue(value).value;
@@ -125,24 +168,18 @@ function requireRepoAndProcess(
   if (!repoId) throw new Error('REPOSITORY_ID_REQUIRED: repo_id is required for process tools');
   if (!processId) throw new Error('PROCESS_ID_REQUIRED: process_id is required for process tools');
 
-  // Force repo scope: repository must exist under this controller home.
-  const repository = getRepository(repoId, ctx.controllerHome);
-  if (!repository) {
-    throw new Error(`REPOSITORY_NOT_FOUND: ${repoId}`);
-  }
-
-  // Process must belong to the requested repo.
-  const record = getProcessRecord(ctx.controllerHome, repoId, processId);
-  if (!record) {
+  // The Process handle is the scope authority. Ephemeral workspace targets are
+  // intentionally not registered in Repository Registry, so requiring a live
+  // repository record here would make their returned managed handles impossible
+  // to resume. Exact repo/workspace scope + process id still fails closed.
+  const handle = getRepositoryCommandProcess(ctx.controllerHome, repoId, processId);
+  if (!handle) {
     throw new Error(`PROCESS_NOT_FOUND: process ${processId} is not registered under repo ${repoId}`);
   }
-  if (record.repoId !== repoId) {
-    throw new Error(`PROCESS_REPO_MISMATCH: process ${processId} belongs to ${record.repoId}, not ${repoId}`);
-  }
   return { repoId, processId };
 }
 
-function handleToPayload(handle: NonNullable<ReturnType<typeof getProcessHandle>>): Record<string, unknown> {
+function handleToPayload(handle: NonNullable<ReturnType<typeof getRepositoryCommandProcess>>): Record<string, unknown> {
   return {
     processId: handle.processId,
     workId: handle.workId,
@@ -161,8 +198,13 @@ function handleToPayload(handle: NonNullable<ReturnType<typeof getProcessHandle>
     cancelled: handle.cancelled,
     stdout: handle.stdout,
     stderr: handle.stderr,
+    // Keep the bounded tail available after completion for callers that use it
+    // as their compact log view. Lightweight terminal receipts bound this tail
+    // separately, so retaining the established field does not restore the
+    // previous full-output duplication in persisted state.
     stdoutTail: handle.stdoutTail,
     stderrTail: handle.stderrTail,
+    continuation: managedProcessContinuation(handle),
     durableSideEffects: handle.durableSideEffects,
   };
 }
@@ -172,12 +214,15 @@ export async function callProcessTool(
   name: string,
   args: Record<string, unknown>,
 ): Promise<CallToolResult | undefined> {
-  if (!processToolNames.has(name)) return undefined;
+  // run_check shares this module's public schema, but its execution authority is
+  // the Gateway check facade in router.ts. Only attachment/lifecycle operations
+  // consume an existing process_id here.
+  if (!processAttachmentToolNames.has(name)) return undefined;
   try {
     const { repoId, processId } = requireRepoAndProcess(ctx, args);
     switch (name) {
       case 'process_get': {
-        const handle = getProcessHandle(ctx.controllerHome, repoId, processId);
+        const handle = getRepositoryCommandProcess(ctx.controllerHome, repoId, processId);
         if (!handle) throw new Error(`PROCESS_NOT_FOUND: ${processId}`);
         return result({
           repoId,
@@ -193,12 +238,13 @@ export async function callProcessTool(
           ? Math.max(1, Math.trunc(testBudget))
           : DEFAULT_PROCESS_WAIT_ATTACH_BUDGET_MS;
         const startedAt = Date.now();
-        const handle = await waitForProcess(ctx.controllerHome, repoId, processId, {
+        const handle = await waitRepositoryCommandProcess(ctx.controllerHome, repoId, processId, {
           timeoutMs: Math.min(requestedWaitMs, attachBudgetMs),
         });
         return result({
           repoId,
           process: handleToPayload(handle),
+          synchronization: handle.completed === true ? 'terminal_result_available' : 'continue_independent_work',
           waitedMs: Date.now() - startedAt,
           requestedWaitMs,
           attachBudgetMs,
@@ -209,7 +255,7 @@ export async function callProcessTool(
         const maxBytes = typeof args.max_bytes === 'number' && Number.isFinite(args.max_bytes)
           ? Math.max(256, Math.trunc(args.max_bytes))
           : 32 * 1024;
-        const logs = readProcessLogs(ctx.controllerHome, repoId, processId, maxBytes);
+        const logs = readRepositoryCommandProcessLogs(ctx.controllerHome, repoId, processId, maxBytes);
         if (!logs) throw new Error(`PROCESS_NOT_FOUND: ${processId}`);
         return result({
           repoId,
@@ -223,7 +269,7 @@ export async function callProcessTool(
         });
       }
       case 'process_cancel': {
-        const handle = await cancelProcess(ctx.controllerHome, repoId, processId);
+        const handle = await cancelRepositoryCommandProcess(ctx.controllerHome, repoId, processId);
         return result({
           repoId,
           process: handleToPayload(handle),

package/src/runtime/gateway/mcp/router.ts

@@ -4,19 +4,24 @@ import {
   buildMultiRepositoryToolDefinitions,
   type MultiRepositoryMcpToolContext,
 } from '../../../cli/mcp/multi-repository';
-import { callRepositoryTool, repositoryToolDefinitions } from '../../../cli/mcp/repository-tools';
+import {
+  callRepositoryTool,
+  claimedSessionEditBinding,
+  repositoryToolDefinitions,
+} from '../../../cli/mcp/repository-tools';
 import { runtimeToolDefinitions } from './runtime-tools';
 import { executionToolDefinitions } from './execution-tools';
 import { processToolDefinitions } from './process-tools';
 import { resolveRepositorySelection } from '../../../cli/repositories/registry';
+import { listControllerChecks } from '../../../cli/controller/check-runner';
 import { executionIdentityForRepository } from '../../control-plane/execution/execution-identity';
-import { startOrJoinEditValidation } from '../../control-plane/execution/edit-validation-coordinator';
-import type {
-  ExecutionOperationMetadata,
-  ExecutionTimeoutPolicy,
-} from '../../execution/jobs/types';
-import { claimsForMcpOperation } from './resource-policy';
-import { classifyRepositoryCommand, classifyRepositoryCommandReplay } from '../../../cli/repositories/command-classifier';
+import {
+  resolveEditValidationRepository,
+  startOrJoinEditValidation,
+} from '../../control-plane/execution/edit-validation-coordinator';
+import { assertEditSessionDurableBinding } from '../../../cli/editing/edit-session';
+import type { ExecutionTimeoutPolicy } from '../../execution/jobs/types';
+import { classifyRepositoryCommand } from '../../../cli/repositories/command-classifier';
 import {
   isFastEligibleTool,
   routeExecution,
@@ -27,6 +32,7 @@ import {
   classifyRepositoryCommandRoute,
 } from '../../execution/process-runtime';
 import { runPersistedCheckViaProcessRuntime } from './persisted-check-process';
+import { buildCheckExecutionSchedule } from '../../execution/process-runtime/check-scheduling';
 import {
   isProcessIsolatedReadDiagnostic,
   runReadOnlyDiagnosticViaProcessRuntime,
@@ -93,8 +99,17 @@ export function isGatewayIsolatedTool(name: string): boolean {
   return GATEWAY_ISOLATED_TOOLS.has(name);
 }
 
-/** Tools that already own their direct-read versus durable-write boundary. */
-const SELF_MANAGED_DURABLE_TOOLS = new Set(['plugin_action_execute']);
+/**
+ * Tools that own their execution boundary and must never fall through to
+ * retired generic ExecutionJob creation. Legacy iOS atomics are compatibility
+ * adapters over the typed iOS plugin authority.
+ */
+const SELF_MANAGED_DURABLE_TOOLS = new Set([
+  'plugin_action_execute',
+  'ios_xcode_status', 'ios_simulators_list', 'ios_project_discover', 'ios_schemes_list',
+  'ios_simulator_boot', 'ios_app_build', 'ios_app_install', 'ios_app_launch',
+  'ios_simulator_screenshot', 'ios_simulator_log_tail', 'ios_ui_smoke_test',
+]);
 
 export function isSelfManagedDurableTool(name: string): boolean {
   return SELF_MANAGED_DURABLE_TOOLS.has(name);
@@ -106,7 +121,6 @@ const DIRECT_HOT_READ_TOOLS = new Set([
   'work_get', 'work_list', 'work_status_digest', 'work_result_summary',
   'controller_ready', 'repository_runtime_snapshot',
   'rh_status', 'rh_context', 'rh_inbox',
-  'controller_context_pack',
   'repository_git_status', 'repository_git_diff', 'git_diff_paths',
 ]);
 
@@ -145,7 +159,6 @@ const EXPLICIT_EXTERNAL_CONTROLLER_TOOLS = new Set([
   'publish_issue_to_github',
   'close_github_issue',
   'request_release_gate',
-  'promote_candidate_finding',
 ]);
 
 const GATEWAY_ROUTE_BEHAVIOR_PROBES: ReadonlyArray<{
@@ -296,8 +309,9 @@ function result(value: Record<string, unknown>, isError = false): CallToolResult
 }
 
 export function getMcpToolDefinition(ctx: MultiRepositoryMcpToolContext, name: string): McpToolDefinition | undefined {
-  return [...runtimeToolDefinitions, ...executionToolDefinitions, ...processToolDefinitions, ...repositoryToolDefinitions, ...buildMultiRepositoryToolDefinitions(ctx)]
-    .find((tool) => tool.name === name);
+  const currentDefinitions = [...runtimeToolDefinitions, ...executionToolDefinitions, ...processToolDefinitions, ...repositoryToolDefinitions];
+  if (ctx.toolset !== 'full') return currentDefinitions.find((tool) => tool.name === name);
+  return [...currentDefinitions, ...buildMultiRepositoryToolDefinitions(ctx)].find((tool) => tool.name === name);
 }
 
 /**
@@ -370,10 +384,16 @@ export function classifyGatewayExecutionPath(
   // run_check: Process Runtime for ordinary checks; Durable only for release/multi-phase.
   if (name === 'run_check') {
     const checkId = String(args.check_id ?? args.checkId ?? '').trim();
+    const batchCheckIds = Array.isArray(args.check_ids)
+      ? args.check_ids.map((value) => String(value).trim()).filter(Boolean)
+      : [];
     if (args.mode === 'durable' || args.force_durable === true) {
       return { path: 'durable', reasons: ['caller_requested_durable_check'] };
     }
-    if (checkId && checkRequiresDurableWorkflow(checkId)) {
+    // A batch containing release/multi-phase checks is routed through the fast
+    // facade only so the batch validator can fail closed with structured
+    // scheduling evidence. It must never create a partial Durable workflow.
+    if (batchCheckIds.length === 0 && checkId && checkRequiresDurableWorkflow(checkId)) {
       return { path: 'durable', reasons: ['multi_phase_or_release_check'] };
     }
     // Route as "fast" so shouldCreateDurableJob returns false; actual execution
@@ -578,68 +598,6 @@ export function validateMcpToolArguments(name: string, definition: McpToolDefini
   }
 }
 
-export function operationMetadataForTool(
-  name: string,
-  definition: McpToolDefinition,
-  claims: ReturnType<typeof claimsForMcpOperation>,
-  timeoutMs: number,
-  args: Record<string, unknown> = {},
-  defaultBranch?: string,
-  timeoutPolicy?: ExecutionTimeoutPolicy,
-): ExecutionOperationMetadata {
-  if (name === 'repository_command_execute' && args.command !== undefined) {
-    const classification = classifyRepositoryCommand(args.command as string | string[], defaultBranch);
-    const replay = classifyRepositoryCommandReplay(args.command as string | string[], defaultBranch);
-    const mode = classification.risk === 'readonly'
-      ? 'readonly'
-      : classification.risk === 'remote_write'
-        ? 'remote_write'
-        : classification.risk === 'destructive'
-          ? 'destructive'
-          : 'mutating';
-    return {
-      mode,
-      idempotent: replay.idempotent,
-      replayable: replay.replayable,
-      timeoutMs,
-      admissionTimeoutMs: timeoutPolicy?.admissionTimeoutMs,
-      queueTimeoutMs: timeoutPolicy?.queueTimeoutMs,
-      executionTimeoutMs: timeoutPolicy?.executionTimeoutMs,
-      interactiveWaitMs: timeoutPolicy?.interactiveWaitMs,
-      retryPolicy: replay.retryPolicy,
-      approvalPolicy: classification.risk === 'readonly'
-        ? 'none'
-        : classification.risk === 'destructive' ? 'required' : 'request',
-      lockScope: claims.map((claim) => claim.resourceKey),
-      resourceClaims: claims,
-    };
-  }
-  const destructive = definition.annotations?.destructiveHint === true;
-  const remoteWrite = claims.some((claim) => claim.resourceKey.startsWith('remote:'));
-  const readOnly = definition.annotations?.readOnlyHint === true || claims.length === 0;
-  const mode = destructive
-    ? 'destructive'
-    : remoteWrite
-      ? 'remote_write'
-      : readOnly
-        ? 'readonly'
-        : 'mutating';
-  return {
-    mode,
-    idempotent: readOnly,
-    replayable: readOnly,
-    timeoutMs,
-    admissionTimeoutMs: timeoutPolicy?.admissionTimeoutMs,
-    queueTimeoutMs: timeoutPolicy?.queueTimeoutMs,
-    executionTimeoutMs: timeoutPolicy?.executionTimeoutMs,
-    interactiveWaitMs: timeoutPolicy?.interactiveWaitMs,
-    retryPolicy: readOnly ? 'safe_retry' : 'idempotent_request',
-    approvalPolicy: destructive ? 'required' : remoteWrite || !readOnly ? 'request' : 'none',
-    lockScope: claims.map((claim) => claim.resourceKey),
-    resourceClaims: claims,
-  };
-}
-
 export function injectDurableCommandFields(tool: McpToolDefinition): McpToolDefinition {
   const schema = tool.inputSchema as { type?: unknown; properties?: Record<string, unknown>; [key: string]: unknown };
   if (schema.type !== 'object') return tool;
@@ -693,7 +651,14 @@ async function runEditSessionValidationViaProcessRuntime(
   editSessionId: string,
   args: Record<string, unknown>,
 ): Promise<CallToolResult> {
-  const validation = await startOrJoinEditValidation(ctx.controllerHome, repository, {
+  const resolved = resolveEditValidationRepository(repository, editSessionId);
+  const binding = claimedSessionEditBinding(ctx.controllerHome, resolved.repository, {
+    sessionId: ctx.sessionId,
+    principalId: ctx.principalId,
+    controllerInstanceId: ctx.controllerInstanceId,
+  }, args.work_id);
+  assertEditSessionDurableBinding(resolved.session, binding, { requireBoundIdentity: true });
+  const validation = await startOrJoinEditValidation(ctx.controllerHome, resolved.repository, {
     editSessionId,
     checkIds: Array.isArray(args.check_ids) ? args.check_ids.map(String) : undefined,
     requestId: typeof args.request_id === 'string' ? args.request_id : undefined,
@@ -775,7 +740,11 @@ export async function routeDurableMcpCall(
     }, true);
   }
 
-  if (classification.path === 'durable' && executionJobCreationRetired()) {
+  // repository_command_execute has its own durable boundary: non-destructive
+  // remote writes run through the durable Process Runtime, while destructive or
+  // explicitly delegated commands are refused by the repository facade itself.
+  // Do not intercept that tool with the retired ExecutionJob gate here.
+  if (classification.path === 'durable' && executionJobCreationRetired() && name !== 'repository_command_execute') {
     return result({
       accepted: false,
       mode: 'external_controller_required',
@@ -898,7 +867,7 @@ export async function routeDurableMcpCall(
       }, validation.isError === true);
     }
 
-    const applied = await callRepositoryTool(ctx.controllerHome, name, args);
+    const applied = await callRepositoryTool(ctx.controllerHome, name, args, ctx);
     if (!applied || applied.isError === true) return applied;
     const patchPayload = (applied.structuredContent ?? {}) as Record<string, unknown>;
     if (patchPayload.status !== 'applied') return applied;
@@ -947,12 +916,145 @@ export async function routeDurableMcpCall(
       });
     }
     const checkId = String(args.check_id ?? '').trim();
-    if (!checkId) {
+    const rawBatchCheckIds = args.check_ids;
+    const hasBatchInput = Array.isArray(rawBatchCheckIds);
+    const batchCheckIds: string[] = hasBatchInput
+      ? [...new Set(rawBatchCheckIds.map((value: unknown) => String(value).trim()).filter(Boolean))]
+      : [];
+    if (checkId && hasBatchInput) {
       return result({
         accepted: false,
         mode: 'reject',
         path: 'reject',
-        message: 'run_check requires check_id',
+        message: 'run_check accepts either check_id or check_ids, not both',
+      }, true);
+    }
+    if (!checkId && batchCheckIds.length === 0) {
+      return result({
+        accepted: false,
+        mode: 'reject',
+        path: 'reject',
+        message: 'run_check requires check_id or a non-empty check_ids array',
+      }, true);
+    }
+    if (hasBatchInput) {
+      const availableChecks = listControllerChecks(repository.canonicalRoot);
+      const availableChecksById = new Map(availableChecks.map((check) => [check.id, check]));
+      const checkScheduling = buildCheckExecutionSchedule({
+        checks: availableChecks,
+        requestedCheckIds: batchCheckIds,
+        repoId: repository.repoId,
+        checkoutId: repository.activeCheckoutId,
+      });
+      const schedulePayload = {
+        waveCount: checkScheduling.waves.length,
+        maxParallel: checkScheduling.maxParallel,
+        waves: checkScheduling.waves,
+        conflicts: checkScheduling.conflicts,
+        invalidCheckIds: checkScheduling.invalidCheckIds,
+        guidance: checkScheduling.guidance,
+      };
+      if (checkScheduling.invalidCheckIds.length > 0) {
+        return result({
+          accepted: false,
+          mode: 'reject',
+          path: 'reject',
+          reason: 'invalid_check_ids',
+          checkIds: batchCheckIds,
+          checkScheduling: schedulePayload,
+          message: `run_check batch contains unregistered checks: ${checkScheduling.invalidCheckIds.join(', ')}`,
+        }, true);
+      }
+      const durableCheckIds = batchCheckIds.filter((id) => checkRequiresDurableWorkflow(id, availableChecksById.get(id)));
+      if (durableCheckIds.length > 0) {
+        return result({
+          accepted: false,
+          mode: 'reject',
+          path: 'reject',
+          reason: 'batch_contains_durable_check',
+          checkIds: batchCheckIds,
+          durableCheckIds,
+          checkScheduling: schedulePayload,
+          message: 'Batch run_check only launches ordinary focused checks; run release or multi-phase checks through an explicit durable workflow.',
+        }, true);
+      }
+      if (checkScheduling.waves.length !== 1 || checkScheduling.waves[0]?.checkIds.length !== batchCheckIds.length) {
+        return result({
+          accepted: false,
+          mode: 'reject',
+          path: 'reject',
+          reason: 'batch_spans_multiple_check_waves',
+          checkIds: batchCheckIds,
+          checkScheduling: schedulePayload,
+          message: 'Requested checks span multiple resource-conflicting waves. Launch one returned wave per run_check call; Forge will not hide serial waiting inside a batch.',
+        }, true);
+      }
+      const baseRequestId = typeof args.request_id === 'string' ? args.request_id.trim() : '';
+      const facades = await Promise.all(batchCheckIds.map((batchCheckId, index) => {
+        const suffix = createHash('sha256').update(batchCheckId).digest('hex').slice(0, 8);
+        return runPersistedCheckViaProcessRuntime({
+          controllerHome: ctx.controllerHome,
+          repoId: repository.repoId,
+          checkoutId: repository.activeCheckoutId,
+          repoRoot: repository.canonicalRoot,
+          executionIdentity: executionIdentityForRepository(repository),
+          checkId: batchCheckId,
+          timeoutMs: typeof args.timeout_ms === 'number' ? args.timeout_ms : undefined,
+          interactiveWaitMs: 0,
+          requestId: baseRequestId ? `${baseRequestId}:batch:${index + 1}:${suffix}` : undefined,
+          forceDurable: false,
+        });
+      }));
+      const unexpectedDurable = facades.filter((facade) => facade.mode === 'durable');
+      if (unexpectedDurable.length > 0) {
+        return result({
+          accepted: false,
+          mode: 'reject',
+          path: 'reject',
+          reason: 'batch_check_escalated_to_durable',
+          checkIds: batchCheckIds,
+          checkScheduling: schedulePayload,
+          message: 'At least one batch check unexpectedly requires Durable execution; no further batch orchestration will be created.',
+        }, true);
+      }
+      const processes = facades.map((facade) => ({
+        checkId: facade.checkId,
+        processId: facade.process?.processId,
+        status: facade.process?.status,
+        completed: facade.process?.completed === true,
+        ok: facade.process?.ok,
+        exitCode: facade.process?.exitCode,
+        timedOut: facade.process?.timedOut,
+        deduplicated: facade.process?.deduplicated === true,
+        semanticDeduplicated: facade.process?.semanticDeduplicated === true,
+        durableSideEffects: facade.durableSideEffects,
+      }));
+      const completed = processes.every((process) => process.completed);
+      const mode = processes.every((process) => process.completed) ? 'direct' : 'managed';
+      const durableSideEffects = facades.reduce((total, facade) => ({
+        executionJobCount: total.executionJobCount + facade.durableSideEffects.executionJobCount,
+        localJobCount: total.localJobCount + facade.durableSideEffects.localJobCount,
+        workerSpawnCount: total.workerSpawnCount + facade.durableSideEffects.workerSpawnCount,
+        projectionUpdateCount: total.projectionUpdateCount + facade.durableSideEffects.projectionUpdateCount,
+      }), { executionJobCount: 0, localJobCount: 0, workerSpawnCount: 0, projectionUpdateCount: 0 });
+      return result({
+        accepted: true,
+        batch: true,
+        mode,
+        path: mode === 'direct' ? 'process_batch_direct' : 'process_batch_managed',
+        routing: { path: 'fast', reasons: ['run_check_batch_process_runtime'] },
+        repoId: repository.repoId,
+        checkoutId: repository.activeCheckoutId,
+        checkIds: batchCheckIds,
+        checkScheduling: schedulePayload,
+        processes,
+        processIds: processes.map((process) => process.processId).filter(Boolean),
+        completed,
+        ...(completed ? { ok: processes.every((process) => process.ok === true) } : {}),
+        durableSideEffects,
+        next: completed
+          ? 'Batch check wave finished on Process Runtime without ExecutionJob / LocalBridgeJob / Worker.'
+          : 'Batch check wave is running concurrently. Continue independent work. Attach to each returned process only when that result becomes a real dependency; do not poll or re-run the checks.',
       });
     }
     const facade = await runPersistedCheckViaProcessRuntime({
@@ -1012,7 +1114,7 @@ export async function routeDurableMcpCall(
       durableSideEffects: facade.durableSideEffects,
       next: handle?.completed
         ? 'Check finished on Process Runtime without ExecutionJob / LocalBridgeJob / Worker.'
-        : `Check still running as managed process ${handle?.processId}. Continue independent work; use process_wait once when this result becomes a real dependency. Do not re-run or repeatedly poll the same check.`,
+        : `Check still running as managed process ${handle?.processId}. Continue independent work; attach with process_wait only when this exact result becomes a real dependency. An attach may return a running handle because transport time is bounded; continue useful work and attach again only at a later dependency boundary. Do not re-run or periodically poll the same check.`,
     });
   }