@moretea-labs/forge 1.7.0 → 1.7.2

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

@@ -6,8 +6,10 @@ import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/
 import type { CallToolResult as SdkCallToolResult } from '@modelcontextprotocol/sdk/types.js';
 import { collectRuntimePerformanceDiagnostics, inferLocalControllerProcess } from '../../diagnostics/performance';
 import { defaultSemanticProviderRegistry, type SemanticNavigationKind, type SemanticNavigationRequest } from '../../context/semantic-navigation';
-import type { McpToolDefinition, CallToolResult } from '../../../cli/mcp/tools';
+import type { McpToolDefinition, CallToolResult } from '../../../cli/mcp/tool-contract';
 import type { MultiRepositoryMcpToolContext } from '../../../cli/mcp/multi-repository';
+import { allControllerToolDefinitions, controllerExposureSnapshot, controllerToolSurfaceStatus } from '../../../cli/mcp/toolset';
+import { legacyIosPluginInvocation } from './legacy-ios-tool-adapter';
 import { repositoryScopedToolArgs } from '../../../cli/mcp/multi-repository';
 import { resolveMcpPath } from '../../../cli/mcp/paths';
 import { freshGitIdentity } from '../../../cli/repository/inspector';
@@ -18,14 +20,19 @@ import { repositoryControllerRoot } from '../../../cli/repositories/controller-h
 import { cancelExecutionJob, findExecutionJob, getExecutionJob, getExecutionJobByRequestId, listExecutionJobs } from '../../execution/jobs/store';
 import { waitForExecutionJob } from '../../execution/jobs/wait';
 import type { ExecutionJob } from '../../execution/jobs/types';
-import { DEFAULT_WORK_CHECK_LEASE_WAIT_MS, checkRequiresDurableWorkflow, getProcessHandle, getProcessRecord, isManagedProcessActive, listProcessRecords, listRecoverableProcessRecords, processCheckCompletionReceipt, processRuntimeResourceDiagnostics, readPersistedCheckResultReceipt, runPersistedCheckViaProcessRuntime, waitForProcess } from '../../execution/process-runtime';
+import { DEFAULT_WORK_CHECK_LEASE_WAIT_MS, getProcessHandle, getProcessRecord, isManagedProcessActive, listProcessRecords, listRecoverableProcessRecords, processCheckCompletionReceipt, processRuntimeResourceDiagnostics } from '../../execution/process-runtime';
+import { classifyPersistedCheckTerminalEvidence } from '../../execution/process-runtime/check-result';
+export { classifyTerminalCheckEvidence } from '../../execution/process-runtime/check-result';
+import { listWorkBoundRepositoryProcessEvidence, listWorkBoundRepositoryRemoteEffectProcessEvidence } from '../../control-plane/execution/work-process-evidence';
+import { appendWorkEvidence, recordWorkCompletionReceipt } from '../../control-plane/facade/work-contract-store';
 import { getRepositoryCommandProcess, waitRepositoryCommandProcess } from '../../execution/process-runtime/command-facade';
 import { buildJobOperationDigest } from '../../control-plane/facade/operation-digest';
-import { readWorkHandle, transitionWorkHandle, workDeliveryBaseRevision, writeWorkHandle, type WorkHandleState } from '../../control-plane/execution/work-handle-store';
+import { readWorkHandle, transitionWorkHandle, workDeliveryBaseRevision, type WorkHandleState } from '../../control-plane/execution/work-handle-store';
+import { ensureRepositoryWorkHandle, rebindRepositoryWorkHandleControllerIdentity } from '../../control-plane/execution/work-handle-authority';
 import { recoverTerminalWorkHandle } from '../../control-plane/execution/work-terminal-cleanup';
-import { gitCommitAtRef, gitWorktreeSnapshot } from '../../control-plane/execution/work-lifecycle-audit';
-import { executionIdentityForRepository } from '../../control-plane/execution/execution-identity';
 import { commandFingerprint, verificationInputFingerprint, workspaceValidationFingerprint } from '../../control-plane/execution/verification-evidence';
+import { resolveWorkVerificationContext } from '../../control-plane/execution/work-verification-context';
+import { executeWorkVerification } from '../../control-plane/execution/work-verification-service';
 import { acceptReviewedDirectEditWorkReconciliation, reconcileFinalizedDirectEditWorksAfterCommit } from '../../control-plane/execution/direct-edit-work-completion';
 import { readJobEvents } from '../../evidence/event-ledger';
 import { readExecutionArtifact } from '../../evidence/artifact-store';
@@ -58,12 +65,6 @@ import {
   triggerWorkContinuationSchedule,
   type ContinuationControllerType,
 } from '../../workflow/schedules/work-continuation';
-import {
-  gatewayRouteBehaviorSnapshot,
-  getMcpToolDefinition,
-  RETIRED_AGENT_OPERATIONS,
-  routeDurableMcpCall,
-} from './router';
 import { assertAutomatedOperationAllowed } from '../../control-plane/governance/external-effects';
 import { ensureRepositoryRuntimeStorage } from '../../../cli/repositories/runtime-storage';
 import { assessWorkMode, parseExplicitTaskMode } from '../../../cli/controller/work-mode';
@@ -174,8 +175,6 @@ import {
   listWorkContracts,
   getWorkContract,
   getWorkContractByRequestId,
-  updateWorkContract,
-  resumeRetainedCancelledWorkContract,
   buildWorkContinuationSnapshot,
   acceptPlanStepEvidence,
   admitPlanContractAsync,
@@ -185,40 +184,48 @@ import {
   resolvePlanAdmission,
   withPrimaryWorkAdmissionLockAsync,
   repairDanglingPlanStepWorkBinding,
+  repairDraftPlanContractAsync,
   completePlanStepForWork,
   summarizePlanContract,
   supersedePlanContract,
   verifyGoalWorkloop,
   type FacadeTool,
+  bindControllerSessionToCurrentRuntime,
   claimControllerSession,
+  controllerSessionPrincipalId,
   getControllerSession,
-  releaseControllerSession,
   releaseControllerSessionWithAuthority,
+  releaseObservedControllerSession,
   resumeControllerSession,
   withControllerSessionTerminalizationFence,
   type ControllerTerminalizationAuthority,
 } from '../../control-plane/facade';
 import { currentControllerInstanceId, readExecutionSession, startExecutionSession, updateExecutionSession } from '../../control-plane/execution/session-store';
 import { changedPaths as workChangedPaths } from '../../control-plane/execution/work-task-receipt';
-import { createRequirement, readRequirement } from '../../control-plane/persistence/requirement-store';
+import { readRequirement } from '../../control-plane/persistence/requirement-store';
+import { admitRequirement } from '../../control-plane/facade/requirement-authority';
 import { ensureManagedWorkspace } from '../../execution/managed-workspace';
+import { materializeRepositoryWorkPlacement } from '../../control-plane/facade/repository-work-admission';
+import { reauthorizeRetainedCancelledRepositoryWork } from '../../control-plane/execution/retained-work-resume';
 import { currentPermissionSnapshotVersion } from '../../control-plane/execution/validation';
 import { observeRuntimeStatus } from '../../root/status';
 import { reconcileWorkValidation } from './work-validation-reconciler';
 import { callExecutionTool } from './execution-tools';
 import { launchSuperController } from '../../control-plane/launcher/thin-launcher';
 import { runStandaloneChatgptPrompt, runWorkChatgptContinuation, settleWorkChatgptAutomationTab } from '../../control-plane/launcher/chatgpt-work-continuation';
-import { getChatgptWorkConversationBinding } from '../../control-plane/launcher/chatgpt-work-binding-store';
+import { getChatgptWorkConversationBinding, hasChatgptConversationIdentity } from '../../control-plane/launcher/chatgpt-work-binding-store';
 import {
   acknowledgeControllerRoundClaim,
   beginControllerRoundRelayAfterRelease,
   beginInitialControllerRoundDispatch,
+  reconcileControllerRoundAfterAbandonedRelease,
   buildControllerRoundRelayPrompt,
   finishControllerRoundRelayDispatch,
   getControllerRoundRelay,
   parseControllerDispositionCompatibilityCapability,
   recordControllerRoundTabSettlement,
   submitControllerRoundDisposition,
+  type ControllerRoundRelayRecord,
   type ControllerRoundDisposition,
 } from '../../control-plane/facade/controller-round-relay';
 
@@ -617,30 +624,6 @@ async function callStandaloneRecoveryTool(
 
 export const RH_WORK_VERIFY_LEASE_WAIT_MS = DEFAULT_WORK_CHECK_LEASE_WAIT_MS;
 
-type TerminalCheckEvidenceState = 'matched' | 'process_runtime_failed_before_result' | 'missing' | 'mismatch';
-
-export function classifyTerminalCheckEvidence(input: {
-  processError?: { code: string; message: string };
-  structuredPresent: boolean;
-  structuredMatches: boolean;
-  legacyPresent: boolean;
-  legacyMatches: boolean;
-}): { state: TerminalCheckEvidenceState; warning?: string; infrastructureReason?: string } {
-  if (input.structuredMatches || input.legacyMatches) return { state: 'matched' };
-  if (!input.structuredPresent && !input.legacyPresent && input.processError?.message?.trim()) {
-    const reason = input.processError.message.trim().slice(0, 512);
-    return {
-      state: 'process_runtime_failed_before_result',
-      warning: `check process failed before structured result receipt: ${reason}`,
-      infrastructureReason: reason,
-    };
-  }
-  if (input.structuredPresent || input.legacyPresent) {
-    return { state: 'mismatch', warning: 'check result receipt did not match the terminal Process semantic identity' };
-  }
-  return { state: 'missing', warning: 'check result receipt is missing for the terminal Check Process' };
-}
-
 function result(value: Record<string, unknown>, isError = false): CallToolResult {
   // Compact text channel by default (no pretty-print bloat).
   return { content: [{ type: 'text', text: JSON.stringify(value) }], structuredContent: value, ...(isError ? { isError: true } : {}) };
@@ -849,6 +832,7 @@ export interface RuntimeIdentitySnapshot {
   runtimeInstanceId?: string;
   controllerInstanceId?: string;
   endpoint?: string;
+  running?: boolean;
   ready?: boolean;
   reasonCodes?: string[];
   toolset?: string;
@@ -869,6 +853,7 @@ export function runtimeIdentitySnapshot(ctx: MultiRepositoryMcpToolContext): Run
     runtimeInstanceId: snapshot?.runtimeInstanceId,
     controllerInstanceId: snapshot?.runtimeInstanceId,
     endpoint: snapshot?.endpoint,
+    running: observation.running,
     ready: observation.ready,
     reasonCodes: observation.reasonCodes,
     toolset: ctx.toolset,
@@ -1118,20 +1103,25 @@ function compactControllerContextSummaryPayload(payload: Record<string, unknown>
 function authenticatedFacadeControllerIdentity(
   ctx: MultiRepositoryMcpToolContext,
   args: Record<string, unknown>,
+  options: { allowTransportSessionRollover?: boolean } = {},
 ): { controllerId: string; principalId: string; sessionId: string; controllerInstanceId: string; controllerType: 'chatgpt' | 'codex' | 'claude' | 'grok' | 'human' } {
   const principalId = ctx.principalId?.trim();
-  const sessionId = ctx.sessionId?.trim();
-  if (!principalId || !sessionId) {
-    throw new Error('CONTROLLER_AUTHENTICATED_SESSION_REQUIRED: reconnect or call session_start through the authenticated MCP transport');
-  }
+  const transportSessionId = ctx.sessionId?.trim();
   const requestedControllerId = typeof args.controller_id === 'string' ? args.controller_id.trim() : '';
   const requestedSessionId = typeof args.session_id === 'string' ? args.session_id.trim() : '';
+  if (!principalId || (!transportSessionId && !requestedSessionId)) {
+    throw new Error('CONTROLLER_AUTHENTICATED_SESSION_REQUIRED: reconnect or provide session_id through the authenticated MCP transport');
+  }
+  // The authenticated principal proves who is calling; session_id is the
+  // Controller-owned opaque lease capability that keeps one conversation/round
+  // stable across replaceable MCP transport sessions. Prefer that explicit
+  // capability whenever supplied. A foreign same-principal conversation still
+  // cannot rebind an existing Work unless it possesses the exact opaque session
+  // (or the stronger relay-round capability checked by the caller).
+  const sessionId = requestedSessionId || transportSessionId!;
   if (requestedControllerId && requestedControllerId !== principalId) {
     throw new Error('CONTROLLER_ID_CONTEXT_MISMATCH: controller_id must match the authenticated principal');
   }
-  if (requestedSessionId && requestedSessionId !== sessionId) {
-    throw new Error('CONTROLLER_SESSION_CONTEXT_MISMATCH: session_id must match the authenticated MCP session');
-  }
   const requestedControllerType = typeof args.controller_type === 'string' && ['chatgpt', 'codex', 'claude', 'grok', 'human'].includes(args.controller_type)
     ? args.controller_type as 'chatgpt' | 'codex' | 'claude' | 'grok' | 'human'
     : undefined;
@@ -1148,245 +1138,174 @@ function authenticatedFacadeControllerIdentity(
   };
 }
 
-function ensureFacadeWorkHandle(
+export function dispatchedChatgptRelayAuthorizesStaleControllerRecovery(
+  relay: ControllerRoundRelayRecord | undefined,
+  controllerType: 'chatgpt' | 'codex' | 'claude' | 'grok' | 'human',
+): boolean {
+  if (controllerType !== 'chatgpt' || relay?.status !== 'dispatched' || !relay.browserSessionId || !relay.conversationUrl) {
+    return false;
+  }
+  try {
+    return hasChatgptConversationIdentity(relay.conversationUrl);
+  } catch {
+    return false;
+  }
+}
+
+function assertFacadeControllerRoundAuthority(
   ctx: MultiRepositoryMcpToolContext,
-  repository: ReturnType<typeof selected>,
+  store: { controllerHome: string; repoId: string },
   workId: string,
   args: Record<string, unknown>,
-): WorkHandleState | undefined {
-  const existing = readWorkHandle(ctx.controllerHome, repository.repoId, workId);
-  if (existing) return existing;
-  const contract = getWorkContract({ controllerHome: ctx.controllerHome, repoId: repository.repoId }, workId);
-  if (!contract || contract.workKind !== 'repository_change' || contract.mode !== 'goal_workloop' || !contract.checkoutId) return undefined;
-  const executionRepository = resolveRepositorySelection({ repoId: repository.repoId, checkoutId: contract.checkoutId, controllerHome: ctx.controllerHome, allowSoleRepository: false });
-  const checkout = selectRepositoryCheckout(executionRepository, contract.checkoutId, { allowArchived: true });
-  const status = repositoryGitStatus(checkout);
-  if (!status.branch) throw new Error(`WORKTREE_DETACHED: ${contract.checkoutId} has no branch`);
-  const identity = authenticatedFacadeControllerIdentity(ctx, args);
-  const at = new Date().toISOString();
-  const managedWorktree = Boolean(contract.worktreeRef) && resolve(contract.worktreeRef!) === resolve(checkout.canonicalRoot) && resolve(checkout.canonicalRoot) !== resolve(repository.canonicalRoot);
-  return writeWorkHandle(ctx.controllerHome, {
-    schemaVersion: 1,
-    workId,
-    sessionId: identity.sessionId,
-    principalId: identity.principalId,
-    repositoryId: repository.repoId,
-    checkoutId: contract.checkoutId,
-    worktreePath: checkout.canonicalRoot,
-    branch: status.branch,
-    sourceCheckoutId: repository.activeCheckoutId,
-    managedWorktree,
-    workContractId: contract.workId,
-    baseCommit: contract.baseRevision ?? status.head ?? undefined,
-    deliveryBaseCommit: contract.baseRevision ?? status.head ?? undefined,
-    expectedHead: status.head ?? contract.baseRevision,
-    permissionSnapshotVersion: currentPermissionSnapshotVersion(ctx.controllerHome, repository.repoId),
-    state: 'prepared',
-    createdAt: at,
-    updatedAt: at,
-    finalization: { validation: 'pending', commit: 'pending', merge: 'pending', branchCleanup: 'pending', worktreeCleanup: 'pending' },
-    cleanupResponsibility: { owner: 'work_finalizer', registeredAt: at },
-  });
+): ControllerRoundRelayRecord | undefined {
+  const relay = getControllerRoundRelay(store, workId);
+  if (!relay) return undefined;
+
+  const expectedAuthorityId = relay.authorityId?.trim() || '';
+  if (expectedAuthorityId) {
+    const requestedScopeId = typeof args.relay_scope_id === 'string' ? args.relay_scope_id.trim() : '';
+    const requestedAuthorityId = typeof args.controller_authority_id === 'string' ? args.controller_authority_id.trim() : '';
+    if (!requestedScopeId || requestedScopeId !== relay.relayScopeId) {
+      throw new Error(`WORK_CONTROLLER_RELAY_SCOPE_MISMATCH: ${workId}:expected=${relay.relayScopeId}`);
+    }
+    if (!requestedAuthorityId) {
+      throw new Error(`WORK_CONTROLLER_ROUND_AUTHORITY_REQUIRED: ${workId}`);
+    }
+    if (requestedAuthorityId !== expectedAuthorityId) {
+      throw new Error(`WORK_CONTROLLER_ROUND_AUTHORITY_MISMATCH: ${workId}`);
+    }
+    return relay;
+  }
+
+  // Legacy relay records predate the per-round capability. Preserve only the
+  // exact already-claimed durable epoch; never rebind a replacement transport by
+  // shared OAuth principal alone. A fresh launcher/recovery round upgrades the
+  // record and receives an opaque authority capability.
+  const owner = getControllerSession(store, workId);
+  const principalId = ctx.principalId?.trim() || '';
+  const sessionId = ctx.sessionId?.trim() || '';
+  const controllerInstanceId = ctx.controllerInstanceId?.trim() || '';
+  if (
+    owner
+    && owner.sessionId === sessionId
+    && controllerSessionPrincipalId(owner) === principalId
+    && (owner.controllerInstanceId?.trim() || '') === controllerInstanceId
+  ) return relay;
+  throw new Error(`WORK_CONTROLLER_ROUND_AUTHORITY_UPGRADE_REQUIRED: ${workId}`);
 }
 
-function materializeFacadeWorkPlacement(
+function bindFacadeControllerOwnership(
   ctx: MultiRepositoryMcpToolContext,
-  repository: ReturnType<typeof selected>,
+  store: { controllerHome: string; repoId: string },
   workId: string,
-  args: Record<string, unknown>,
+  identity: ReturnType<typeof authenticatedFacadeControllerIdentity>,
+  options: { allowClaimIfMissing?: boolean; leaseMs?: number } = {},
 ) {
-  const store = { controllerHome: ctx.controllerHome, repoId: repository.repoId };
-  const contract = getWorkContract(store, workId);
-  if (!contract || contract.worktreePolicy.required !== true || contract.worktreeRef) return contract;
-  const workspace = ensureManagedWorkspace(ctx.controllerHome, repository, {
-    requestId: workId,
-    title: contract.objective,
-    baseRef: contract.baseRevision,
-    prepareDependencies: args.needs_dependencies === true,
-  });
-  if (!workspace.managed || !workspace.checkoutId || !workspace.root || workspace.checkoutId === repository.activeCheckoutId) {
-    throw new Error('MANAGED_WORKSPACE_NOT_MATERIALIZED');
-  }
-  return updateWorkContract(store, workId, {
-    checkoutId: workspace.checkoutId,
-    baseRevision: workspace.baseRevision ?? contract.baseRevision,
-    worktreeRef: workspace.root,
-    driver: { ...contract.driver, preferred: 'isolated_worktree', allowDirectEdit: false },
+  const runtime = runtimeIdentitySnapshot(ctx);
+  return bindControllerSessionToCurrentRuntime(store, {
+    workId,
+    controllerId: identity.controllerId,
+    controllerType: identity.controllerType,
+    sessionId: identity.sessionId,
+    principalId: identity.principalId,
+    controllerInstanceId: identity.controllerInstanceId,
+    currentRuntimeInstanceId: runtime.running ? runtime.runtimeInstanceId : undefined,
+    allowClaimIfMissing: options.allowClaimIfMissing,
+    leaseMs: options.leaseMs ?? 3_600_000,
   });
 }
 
-function reauthorizeCancelledFacadeWork(
+function currentFacadeTerminalizationAuthority(
   ctx: MultiRepositoryMcpToolContext,
-  repository: ReturnType<typeof selected>,
+  store: { controllerHome: string; repoId: string },
   workId: string,
   args: Record<string, unknown>,
-): { reconstructedCheckout: boolean } {
-  const store = { controllerHome: ctx.controllerHome, repoId: repository.repoId };
-  let work = getWorkContract(store, workId);
-  if (!work || work.status !== 'cancelled') return { reconstructedCheckout: false };
-  if (args.approval_confirmed !== true || args.requested_by !== 'user') {
-    throw new Error(`WORK_CANCELLED_RESUME_REAUTHORIZATION_REQUIRED: ${workId}; use exact work_id with requested_by=user and approval_confirmed=true`);
+): ControllerTerminalizationAuthority {
+  let owner = getControllerSession(store, workId);
+  if (!owner) {
+    throw new Error(`WORK_CONTROLLER_OWNER_REQUIRED: ${workId}; terminalization requires an explicit controller_claim for this exact Work.`);
   }
   const identity = authenticatedFacadeControllerIdentity(ctx, args);
-  if (!work.principalId?.trim() || work.principalId.trim() !== identity.principalId) {
-    throw new Error(`WORK_CANCELLED_RESUME_PRINCIPAL_MISMATCH: ${workId}`);
-  }
-  const owner = getControllerSession(store, workId);
-  if (owner && (owner.principalId?.trim() || owner.controllerId) !== identity.principalId) {
-    throw new Error(`WORK_CANCELLED_RESUME_CONTROLLER_OWNERSHIP_MISMATCH: ${workId}`);
-  }
-  if (work.completionReceipt || work.completionOutcome) throw new Error(`WORK_CANCELLED_RESUME_COMPLETION_CONFLICT: ${workId}`);
-  if (work.reconciliations.length > 0) throw new Error(`WORK_CANCELLED_RESUME_DELIVERY_HISTORY_AMBIGUOUS: ${workId}`);
-  if (work.phase !== 'cleanup' || work.phaseEvidence.cleanup.state !== 'skipped' || work.phaseEvidence.cleanup.source !== 'recorded') {
-    throw new Error(`WORK_CANCELLED_RESUME_HISTORY_AMBIGUOUS: ${workId}`);
-  }
-  if (work.workKind !== 'repository_change' || work.worktreePolicy.required !== true) {
-    throw new Error(`WORK_CANCELLED_RESUME_ISOLATED_REPOSITORY_WORK_REQUIRED: ${workId}`);
-  }
-
-  let handle = readWorkHandle(ctx.controllerHome, repository.repoId, workId);
-  if (handle) {
-    if (handle.repositoryId !== repository.repoId || (handle.workContractId && handle.workContractId !== workId)) {
-      throw new Error(`WORK_CANCELLED_RESUME_HANDLE_IDENTITY_MISMATCH: ${workId}`);
-    }
-    if (handle.principalId !== identity.principalId) throw new Error(`WORK_CANCELLED_RESUME_HANDLE_PRINCIPAL_MISMATCH: ${workId}`);
-    if (['committed', 'merged', 'cleaned', 'failed_terminal_cleanup'].includes(handle.state)
-      || handle.finalization.commit === 'done'
-      || handle.finalization.merge === 'done'
-      || handle.cleanupReceipt?.complete === true) {
-      throw new Error(`WORK_CANCELLED_RESUME_DELIVERY_OR_CLEANUP_CONFLICT: ${workId}`);
-    }
-  }
-
-  const registryRepository = listRepositories(ctx.controllerHome, { includeRemoved: true })
-    .find((candidate) => candidate.repoId === repository.repoId);
-  if (!registryRepository) throw new Error(`WORK_CANCELLED_RESUME_REPOSITORY_MISSING: ${workId}`);
-  const recordedCheckoutId = work.checkoutId?.trim();
-  const recordedWorktree = work.worktreeRef?.trim();
-  const checkoutRecord = recordedCheckoutId
-    ? registryRepository.checkouts.find((candidate) => candidate.checkoutId === recordedCheckoutId)
-    : undefined;
-  const checkoutActive = checkoutRecord?.lifecycle === 'active';
-  const worktreePresent = Boolean(recordedWorktree && existsSync(recordedWorktree));
-
-  if (checkoutActive && worktreePresent && recordedCheckoutId && recordedWorktree) {
-    const retained = selectRepositoryCheckout(registryRepository, recordedCheckoutId);
-    if (resolve(retained.canonicalRoot) !== resolve(recordedWorktree)) {
-      throw new Error(`WORK_CANCELLED_RESUME_CHECKOUT_REUSED: ${workId}`);
-    }
-    if (!handle) throw new Error(`WORK_CANCELLED_RESUME_HANDLE_REQUIRED: ${workId}`);
-    if (handle.checkoutId !== recordedCheckoutId || resolve(handle.worktreePath) !== resolve(recordedWorktree)) {
-      throw new Error(`WORK_CANCELLED_RESUME_CHECKOUT_OWNERSHIP_MISMATCH: ${workId}`);
-    }
-    const status = repositoryGitStatus(retained);
-    if (!status.branch || status.branch !== handle.branch) throw new Error(`WORK_CANCELLED_RESUME_BRANCH_OWNERSHIP_MISMATCH: ${workId}`);
-    writeWorkHandle(ctx.controllerHome, {
-      ...handle,
-      principalId: identity.principalId,
-      sessionId: identity.sessionId,
-      updatedAt: new Date().toISOString(),
-    });
-    resumeRetainedCancelledWorkContract(store, workId, {
-      principalId: identity.principalId,
-      controllerInstanceId: identity.controllerInstanceId,
-      summary: 'Explicit current user re-authorized the same retained cancelled Work; exact managed checkout ownership was revalidated.',
-    });
-    return { reconstructedCheckout: false };
+  const ownerPrincipal = controllerSessionPrincipalId(owner);
+  if (owner.controllerId !== identity.controllerId) {
+    throw new Error(`WORK_CONTROLLER_OWNER_MISMATCH: ${workId} is owned by ${owner.controllerId}`);
   }
-
-  if (checkoutActive) throw new Error(`WORK_CANCELLED_RESUME_PRESERVATION_AMBIGUOUS: ${workId}`);
-  if (!recordedCheckoutId || !recordedWorktree || !handle) throw new Error(`WORK_CANCELLED_RESUME_HANDLE_REQUIRED: ${workId}`);
-
-  const actualChangedPaths = work.scopeEvidence?.actualChangedPaths;
-  if (!actualChangedPaths || actualChangedPaths.length !== 0
-    || work.checks.length !== 0
-    || work.checkRefs.length !== 0
-    || work.evidenceState !== 'none') {
-    throw new Error(`WORK_CANCELLED_RESUME_ZERO_DELTA_PROOF_REQUIRED: ${workId}`);
+  if (owner.controllerType !== identity.controllerType) {
+    throw new Error(`WORK_CONTROLLER_TYPE_MISMATCH: ${workId} is owned by ${owner.controllerType}`);
   }
-  const recordedBase = work.baseRevision?.trim();
-  if (!recordedBase) throw new Error(`WORK_CANCELLED_RESUME_BASE_REVISION_REQUIRED: ${workId}`);
-  const baseRevision = gitCommitAtRef(repository.canonicalRoot, recordedBase);
-  if (!baseRevision) throw new Error(`WORK_CANCELLED_RESUME_BASE_REVISION_MISSING: ${workId}`);
-  const handleBase = handle.baseCommit ? gitCommitAtRef(repository.canonicalRoot, handle.baseCommit) : undefined;
-  const handleHead = handle.expectedHead ? gitCommitAtRef(repository.canonicalRoot, handle.expectedHead) : undefined;
-  if ((handle.baseCommit && handleBase !== baseRevision) || (handle.expectedHead && handleHead !== baseRevision)) {
-    throw new Error(`WORK_CANCELLED_RESUME_REVISION_AMBIGUOUS: ${workId}`);
+  if (ownerPrincipal !== identity.principalId) {
+    throw new Error(`WORK_CONTROLLER_PRINCIPAL_MISMATCH: ${workId}`);
   }
-  if (handle.checkoutId !== recordedCheckoutId || resolve(handle.worktreePath) !== resolve(recordedWorktree)) {
-    throw new Error(`WORK_CANCELLED_RESUME_CHECKOUT_OWNERSHIP_MISMATCH: ${workId}`);
+  const ownerInstanceId = owner.controllerInstanceId?.trim() || '';
+  if (!ownerInstanceId) {
+    throw new Error(`WORK_CONTROLLER_INSTANCE_MISMATCH: ${workId}`);
   }
-  if (handle.branch) {
-    const historicalBranchHead = gitCommitAtRef(repository.canonicalRoot, `refs/heads/${handle.branch}`);
-    if (historicalBranchHead && historicalBranchHead !== baseRevision) {
-      throw new Error(`WORK_CANCELLED_RESUME_UNIQUE_COMMIT_CONFLICT: ${workId}`);
+  if (ownerInstanceId !== identity.controllerInstanceId || owner.sessionId !== identity.sessionId) {
+    const relay = assertFacadeControllerRoundAuthority(ctx, store, workId, args);
+    if (!relay?.authorityId?.trim()) {
+      if (ownerInstanceId !== identity.controllerInstanceId) {
+        throw new Error(`WORK_CONTROLLER_INSTANCE_MISMATCH: ${workId}`);
+      }
+      throw new Error(`WORK_CONTROLLER_SCOPE_MISMATCH: ${workId}; terminalization cannot rebind ownership implicitly. Call controller_claim for this exact Work in the current controller scope, then retry.`);
     }
+    // The opaque per-round relay capability is the durable conversation-round
+    // authority. MCP transport sessions are replaceable execution bindings, so
+    // an exact upgraded relay may reconcile the same authenticated owner onto
+    // the current canonical Runtime/session before the claim-generation fence is
+    // captured for terminalization. Foreign or legacy rounds fail above.
+    owner = bindFacadeControllerOwnership(ctx, store, workId, identity);
   }
-  if (worktreePresent) {
-    const retainedSnapshot = gitWorktreeSnapshot(recordedWorktree);
-    if (!retainedSnapshot || !retainedSnapshot.clean || retainedSnapshot.head !== baseRevision || (handle.branch && retainedSnapshot.branch !== handle.branch)) {
-      throw new Error(`WORK_CANCELLED_RESUME_ZERO_DELTA_PHYSICAL_CONFLICT: ${workId}`);
-    }
+  const reboundPrincipal = controllerSessionPrincipalId(owner);
+  const reboundInstanceId = owner.controllerInstanceId?.trim() || '';
+  if (typeof owner.claimGeneration !== 'number' || owner.claimGeneration < 1) {
+    throw new Error(`WORK_CONTROLLER_CLAIM_GENERATION_REQUIRED: ${workId}`);
   }
+  return {
+    controllerId: owner.controllerId,
+    controllerType: owner.controllerType,
+    principalId: reboundPrincipal,
+    controllerInstanceId: reboundInstanceId,
+    claimGeneration: owner.claimGeneration,
+  };
+}
 
-  const branchName = `work/resume-${workId.replace(/[^A-Za-z0-9._-]+/g, '-').slice(0, 42)}-${baseRevision.slice(0, 12)}`;
-  const existingResumeBranch = gitCommitAtRef(repository.canonicalRoot, `refs/heads/${branchName}`);
-  if (existingResumeBranch && existingResumeBranch !== baseRevision) {
-    throw new Error(`WORK_CANCELLED_RESUME_RECONSTRUCTION_BRANCH_CONFLICT: ${workId}`);
-  }
-  const workspace = ensureManagedWorkspace(ctx.controllerHome, repository, {
-    requestId: `${workId}:explicit-user-resume:${baseRevision}`,
-    title: `${work.objective} explicit user resume`,
-    branchName,
-    baseRef: baseRevision,
-    prepareDependencies: args.needs_dependencies === true,
+function ensureFacadeWorkHandle(
+  ctx: MultiRepositoryMcpToolContext,
+  repository: ReturnType<typeof selected>,
+  workId: string,
+  args: Record<string, unknown>,
+): WorkHandleState | undefined {
+  const identity = authenticatedFacadeControllerIdentity(ctx, args);
+  return ensureRepositoryWorkHandle({
+    controllerHome: ctx.controllerHome,
+    repository,
+    workId,
+    identity: { sessionId: identity.sessionId, principalId: identity.principalId },
   });
-  if (!workspace.managed || !workspace.checkoutId || !workspace.root || !workspace.branch) {
-    throw new Error(`WORK_CANCELLED_RESUME_RECONSTRUCTION_FAILED: ${workId}`);
-  }
-  const refreshedRepository = listRepositories(ctx.controllerHome, { includeRemoved: true })
-    .find((candidate) => candidate.repoId === repository.repoId);
-  if (!refreshedRepository) throw new Error(`WORK_CANCELLED_RESUME_REPOSITORY_MISSING: ${workId}`);
-  const reconstructed = selectRepositoryCheckout(refreshedRepository, workspace.checkoutId);
-  const reconstructedStatus = repositoryGitStatus(reconstructed);
-  if (!reconstructedStatus.clean || reconstructedStatus.head !== baseRevision || reconstructedStatus.branch !== workspace.branch) {
-    throw new Error(`WORK_CANCELLED_RESUME_RECONSTRUCTION_REVISION_MISMATCH: ${workId}`);
-  }
+}
 
-  work = updateWorkContract(store, workId, {
-    checkoutId: workspace.checkoutId,
-    worktreeRef: workspace.root,
-    baseRevision,
-    controllerInstanceId: identity.controllerInstanceId,
-  });
-  const now = new Date().toISOString();
-  handle = writeWorkHandle(ctx.controllerHome, {
-    ...handle,
-    principalId: identity.principalId,
-    sessionId: identity.sessionId,
-    checkoutId: workspace.checkoutId,
-    worktreePath: workspace.root,
-    branch: workspace.branch,
-    sourceCheckoutId: repository.activeCheckoutId,
-    managedWorktree: true,
-    baseCommit: baseRevision,
-    deliveryBaseCommit: baseRevision,
-    expectedHead: baseRevision,
-    state: 'prepared',
-    validatedInputFingerprint: undefined,
-    failureReason: undefined,
-    cleanupReceipt: undefined,
-    finalization: { validation: 'pending', commit: 'pending', merge: 'pending', branchCleanup: 'pending', worktreeCleanup: 'pending' },
-    updatedAt: now,
-  });
-  resumeRetainedCancelledWorkContract(store, workId, {
-    principalId: identity.principalId,
-    controllerInstanceId: identity.controllerInstanceId,
-    summary: 'Explicit current user re-authorized the same cancelled Work; prior managed checkout was absent and a fresh isolated checkout was reconstructed at the exact zero-delta base revision.',
-    checkoutId: workspace.checkoutId,
-    worktreeRef: workspace.root,
-  });
-  return { reconstructedCheckout: true };
+function materializeFacadeWorkPlacement(
+  ctx: MultiRepositoryMcpToolContext,
+  repository: ReturnType<typeof selected>,
+  workId: string,
+  args: Record<string, unknown>,
+) {
+  return materializeRepositoryWorkPlacement(
+    { controllerHome: ctx.controllerHome, repoId: repository.repoId },
+    workId,
+    (contract) => {
+      const workspace = ensureManagedWorkspace(ctx.controllerHome, repository, {
+        requestId: workId,
+        title: contract.objective,
+        baseRef: contract.baseRevision,
+        prepareDependencies: args.needs_dependencies === true,
+      });
+      if (workspace.checkoutId === repository.activeCheckoutId) {
+        throw new Error('MANAGED_WORKSPACE_NOT_MATERIALIZED');
+      }
+      return workspace;
+    },
+  );
 }
 
 function claimNewFacadeWork(
@@ -1465,11 +1384,42 @@ async function finalizeFacadeWorkHandle(
     });
   }
 
-  const worktree = selectRepositoryCheckout(repository, handle.checkoutId, { allowArchived: true });
+  let worktree: ReturnType<typeof selectRepositoryCheckout>;
+  try {
+    worktree = selectRepositoryCheckout(repository, handle.checkoutId, { allowArchived: true });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const exactChangedHead = Boolean(handle.managedWorktree
+      && handle.expectedHead
+      && handle.baseCommit
+      && handle.expectedHead !== handle.baseCommit);
+    if (
+      !exactChangedHead
+      || args.cleanup === false
+      || (!message.startsWith('CHECKOUT_NOT_ACTIVE:') && !message.startsWith('checkout not found for '))
+    ) throw error;
+    // Physical cleanup can succeed before the Work completion receipt is
+    // persisted. Retry through the lower finalizer's exact target-containment
+    // reconciliation instead of requiring a checkout that is already gone.
+    // commit/merge are intentionally disabled here: the missing checkout may
+    // never become permission to replay mutation. If expectedHead is not
+    // already contained by targetBranch, work_finalize fails closed.
+    return callExecutionTool(ctx, 'work_finalize', {
+      ...common,
+      commit: false,
+      merge: false,
+      completion_outcome: 'completed_changed',
+    });
+  }
   const status = repositoryGitStatus(worktree);
   const head = status.head ?? handle.expectedHead ?? handle.baseCommit;
   const committedDelta = Boolean(head && handle.baseCommit && head !== handle.baseCommit);
-  const commit = typeof args.commit === 'boolean' ? args.commit : !status.clean;
+  const requestedCommit = typeof args.commit === 'boolean' ? args.commit : !status.clean;
+  // A clean checkout whose HEAD already differs from base is already committed.
+  // Treat commit=true as satisfied by that exact candidate instead of trying to
+  // manufacture an empty commit and recording GIT_NOTHING_STAGED as a delivery
+  // failure. The candidate is still adopted/revalidated and merge-fenced below.
+  const commit = status.clean && committedDelta ? false : requestedCommit;
   const workContract = getWorkContract({ controllerHome: ctx.controllerHome, repoId: repository.repoId }, workId);
   if (
     status.clean
@@ -1585,29 +1535,22 @@ function pluginRepository(
     : selected(ctx, args);
 }
 
-function definedArguments(value: Record<string, unknown>): Record<string, unknown> {
-  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
-}
-
-function legacyIosPluginAction(
+async function legacyIosPluginAction(
   ctx: MultiRepositoryMcpToolContext,
   legacyTool: string,
   args: Record<string, unknown>,
-  actionId: string,
-  actionArgs: Record<string, unknown>,
 ): Promise<CallToolResult | undefined> {
   const repository = selected(ctx, args);
-  const requestId = typeof args.request_id === 'string' && args.request_id.trim()
-    ? args.request_id.trim()
-    : `legacy-${legacyTool}-${Date.now()}`;
+  const invocation = legacyIosPluginInvocation(legacyTool, args);
+  if (!invocation) return undefined;
   return callRuntimeTool(ctx, 'plugin_action_execute', {
     repo_id: repository.repoId,
     checkout_id: repository.activeCheckoutId,
     plugin_id: 'ios',
-    action_id: actionId,
-    request_id: requestId,
-    arguments: definedArguments(actionArgs),
-    ...(args.confirm_authorization === true ? { confirm_authorization: true } : {}),
+    action_id: invocation.actionId,
+    request_id: invocation.requestId,
+    arguments: invocation.arguments,
+    ...(invocation.confirmAuthorization ? { confirm_authorization: true } : {}),
   });
 }
 
@@ -1817,6 +1760,111 @@ export async function controllerReadinessEvidence(
   };
 }
 
+/**
+ * Runtime Source drift for MCP readiness.
+ *
+ * `currentRuntimeRoot` is only for tests that pin a Controller Runtime Source
+ * fixture. Callers must never pass an execution repository canonicalRoot here.
+ */
+export function runtimeSourceSnapshotStatus(
+  active: RuntimeSourceIdentity | undefined,
+  currentRuntimeRoot?: string,
+) {
+  const drift = evaluateActiveRuntimeSourceDrift(active, {
+    currentRuntimeRoot,
+  });
+  return {
+    current: drift.current,
+    restartRequired: drift.restartRequired,
+    reasons: drift.reasons,
+    code: drift.code,
+  };
+}
+
+export function repositoryExecutionReadiness(
+  repoRoot: string,
+  availableChecks: ReturnType<typeof listControllerChecks>,
+  requestedCheckIds: string[] = [],
+  schedulingScope: { repoId?: string; checkoutId?: string } = {},
+): Record<string, unknown> {
+  const git = gitSnapshot(repoRoot);
+  const registeredCheckIds = availableChecks.map((check) => check.id);
+  const normalizedChecks = normalizeCheckIds(requestedCheckIds, availableChecks);
+  const hasPackageJson = existsSync(join(repoRoot, 'package.json'));
+  const nodeModulesReady = !hasPackageJson || existsSync(join(repoRoot, 'node_modules'));
+  const lockCandidates = [
+    ['bun', 'bun.lock'],
+    ['bun', 'bun.lockb'],
+    ['pnpm', 'pnpm-lock.yaml'],
+    ['npm', 'package-lock.json'],
+    ['yarn', 'yarn.lock'],
+  ] as const;
+  const detectedLock = lockCandidates.find(([, path]) => existsSync(join(repoRoot, path)));
+  const packageManager = detectedLock?.[0];
+  const bootstrapCommand = hasPackageJson && !nodeModulesReady
+    ? packageManager === 'bun' ? ['bun', 'install', '--frozen-lockfile']
+      : packageManager === 'pnpm' ? ['pnpm', 'install', '--frozen-lockfile']
+        : packageManager === 'npm' ? ['npm', 'ci']
+          : packageManager === 'yarn' ? ['yarn', 'install', '--frozen-lockfile']
+            : undefined
+    : undefined;
+  const hasPythonManifest = existsSync(join(repoRoot, 'pyproject.toml'))
+    || existsSync(join(repoRoot, 'requirements.txt'))
+    || existsSync(join(repoRoot, 'requirements-dev.txt'));
+  const localPythonReady = !hasPythonManifest
+    || existsSync(join(repoRoot, '.venv', 'bin', 'python'))
+    || existsSync(join(repoRoot, '.venv', 'Scripts', 'python.exe'));
+  const checkScheduling = buildCheckExecutionSchedule({
+    checks: availableChecks,
+    requestedCheckIds,
+    repoId: schedulingScope.repoId?.trim() || 'selected-repository',
+    checkoutId: schedulingScope.checkoutId?.trim() || 'active',
+  });
+  const blockers = [
+    ...(!nodeModulesReady ? [{ code: 'NODE_DEPENDENCIES_MISSING', message: 'package.json is present but node_modules is not materialized in this checkout.' }] : []),
+    ...normalizedChecks.invalidCheckIds.map((checkId) => ({ code: 'CHECK_NOT_REGISTERED', message: `Requested check is not registered: ${checkId}`, checkId })),
+  ];
+  return {
+    readyForFocusedExecution: blockers.length === 0,
+    git: { head: git.head, branch: git.branch, dirty: git.dirty },
+    checks: {
+      registeredCount: registeredCheckIds.length,
+      registeredCheckIds: registeredCheckIds.slice(0, 80),
+      requestedCheckIds: requestedCheckIds.slice(0, 40),
+      normalized: normalizedChecks,
+    },
+    checkScheduling: {
+      waveCount: checkScheduling.waves.length,
+      maxParallel: checkScheduling.maxParallel,
+      waveSummaries: checkScheduling.waves.map((wave) => `wave ${wave.wave}: ${wave.checkIds.join(', ')}`),
+      conflictSummaries: checkScheduling.conflicts.map((conflict) => {
+        const resources = [...new Set(conflict.resources.flatMap(({ left, right }) => [left.resourceKey, right.resourceKey]))];
+        return `${conflict.leftCheckId} <> ${conflict.rightCheckId}: ${resources.join(', ')}`;
+      }),
+      invalidCheckIds: checkScheduling.invalidCheckIds,
+      guidance: checkScheduling.guidance,
+    },
+    dependencies: {
+      node: {
+        applicable: hasPackageJson,
+        ready: nodeModulesReady,
+        packageManager: packageManager ?? null,
+        lockfile: detectedLock?.[1] ?? null,
+        ...(bootstrapCommand ? { bootstrapCommand } : {}),
+      },
+      python: {
+        applicable: hasPythonManifest,
+        localVirtualEnvReady: localPythonReady,
+        advisoryOnly: true,
+      },
+    },
+    blockers,
+    guidance: bootstrapCommand
+      ? [`Materialize checkout dependencies before tests/builds: ${bootstrapCommand.join(' ')}`]
+      : [],
+  };
+}
+
 export async function controllerReadiness(
   ctx: MultiRepositoryMcpToolContext,
   repository = ctx.explicitRepository,
@@ -2308,11 +2356,85 @@ async function runFacadeRepair(
   const planId = typeof args.plan_id === 'string' ? args.plan_id.trim() : '';
   const planStepId = typeof args.plan_step_id === 'string' ? args.plan_step_id.trim() : '';
 
-  if (planId || planStepId) {
-    if (!planId || !planStepId) {
-      const facade = buildFacadeResult({ status: 'blocked', summary: 'PLAN_STEP_REPAIR_CONTEXT_REQUIRED: plan_id and plan_step_id are both required.', data: { operation: repairOperation, dryRun, repaired: false } });
+  if (planId && !planStepId) {
+    const plan = getPlanContract(store, planId);
+    if (!plan) {
+      const facade = buildFacadeResult({ status: 'not_found', summary: `PlanContract ${planId} not found.`, data: { operation: repairOperation, dryRun, planId, repaired: false } });
+      return result(facade as unknown as Record<string, unknown>, true);
+    }
+    if (plan.status !== 'draft') {
+      const facade = buildFacadeResult({ status: 'blocked', summary: `PLAN_DRAFT_REPAIR_STATUS_INVALID: ${plan.planId}:${plan.status}`, data: { operation: repairOperation, dryRun, planId, repaired: false } });
+      return result(facade as unknown as Record<string, unknown>, true);
+    }
+    if (repairOperation !== 'repair' || dryRun) {
+      const facade = buildFacadeResult({
+        summary: `PlanContract ${plan.planId} is a draft. Exact in-place repair is available; the Plan identity and Requirement authority are preserved and only a fully valid draft may be persisted.`,
+        data: { operation: repairOperation, dryRun, plan: summarizePlanContract(plan), repaired: false, repairRequired: true },
+        suggestedNextActions: [{ label: 'Repair this exact draft Plan', tool: 'rh_work', operation: 'repair', payload: { plan_id: plan.planId, repair_operation: 'repair', dry_run: false }, risk: 'workspace_write', confidence: 'high' }],
+      });
+      return result(facade as unknown as Record<string, unknown>);
+    }
+    const rawSteps = Array.isArray(args.plan_steps)
+      ? args.plan_steps
+      : plan.steps.map((step) => ({
+          id: step.id, objective: step.objective, dependencies: step.dependencies, authoritative_files: step.authoritativeFiles,
+          allowed_paths: step.allowedPaths, forbidden_paths: step.forbiddenPaths, check_ids: step.checks, acceptance_criteria: step.acceptanceCriteria,
+        }));
+    const steps = rawSteps
+      .filter((step): step is Record<string, unknown> => Boolean(step) && typeof step === 'object' && !Array.isArray(step))
+      .map((step) => ({
+        id: String(step.id ?? ''),
+        objective: String(step.objective ?? ''),
+        dependencies: Array.isArray(step.dependencies) ? step.dependencies.map(String) : [],
+        authoritativeFiles: Array.isArray(step.authoritative_files) ? step.authoritative_files.map(String) : [],
+        allowedPaths: Array.isArray(step.allowed_paths) ? step.allowed_paths.map(String) : [],
+        forbiddenPaths: Array.isArray(step.forbidden_paths) ? step.forbidden_paths.map(String) : [],
+        checks: Array.isArray(step.check_ids) ? step.check_ids.map(String) : [],
+        acceptanceCriteria: Array.isArray(step.acceptance_criteria) ? step.acceptance_criteria.map(String) : [],
+      }));
+    const availableChecks = listControllerChecks(repository.canonicalRoot);
+    const normalizedPlanChecks = normalizeCheckIds(steps.flatMap((step) => step.checks), availableChecks);
+    if (normalizedPlanChecks.invalidCheckIds.length > 0) {
+      const facade = buildFacadeResult({
+        status: 'failed',
+        summary: `PLAN_CHECKS_INVALID: ${normalizedPlanChecks.invalidCheckIds.join(', ')}. Draft repair was not persisted.`,
+        data: { operation: repairOperation, dryRun: false, planId, repaired: false, normalizedChecks: normalizedPlanChecks, registeredCheckIds: availableChecks.map((check) => check.id).slice(0, 80) },
+        suggestedNextActions: [],
+      });
+      return result(facade as unknown as Record<string, unknown>, true);
+    }
+    try {
+      const repaired = await repairDraftPlanContractAsync(store, planId, {
+        expectedSourceRevision: plan.sourceRevision,
+        scopeKey: typeof args.scope_key === 'string' ? args.scope_key : plan.scopeKey,
+        sourceRevision: typeof args.source_revision === 'string' ? args.source_revision : plan.sourceRevision,
+        goal: typeof args.objective === 'string' ? args.objective : plan.goal,
+        nonGoals: Array.isArray(args.non_goals) ? args.non_goals.map(String) : plan.nonGoals,
+        assumptions: Array.isArray(args.assumptions) ? args.assumptions.map(String) : plan.assumptions,
+        resolvedDecisions: Array.isArray(args.resolved_decisions) ? args.resolved_decisions.map(String) : plan.resolvedDecisions,
+        stopConditions: Array.isArray(args.stop_conditions) ? args.stop_conditions.map(String) : plan.stopConditions,
+        replanConditions: Array.isArray(args.replan_conditions) ? args.replan_conditions.map(String) : plan.replanConditions,
+        integrationStrategy: typeof args.integration_strategy === 'string' ? args.integration_strategy : plan.integrationStrategy,
+        steps,
+      });
+      const facade = buildFacadeResult({
+        summary: `PlanContract ${repaired.planId} draft repaired in place; identity and Requirement authority were preserved.`,
+        data: { operation: repairOperation, dryRun: false, plan: summarizePlanContract(repaired), repaired: true, replacementPlanCreated: false },
+        suggestedNextActions: [{ label: 'Approve reviewed plan', tool: 'rh_work', operation: 'plan_approve', payload: { plan_id: repaired.planId }, risk: 'workspace_write', confidence: 'medium' }],
+      });
+      return result(facade as unknown as Record<string, unknown>);
+    } catch (error) {
+      const facade = buildFacadeResult({ status: 'blocked', summary: error instanceof Error ? error.message : 'PLAN_DRAFT_REPAIR_FAILED', data: { operation: repairOperation, dryRun: false, planId, repaired: false } });
       return result(facade as unknown as Record<string, unknown>, true);
     }
+  }
+
+  if (planStepId && !planId) {
+    const facade = buildFacadeResult({ status: 'blocked', summary: 'PLAN_STEP_REPAIR_CONTEXT_REQUIRED: plan_id and plan_step_id are both required.', data: { operation: repairOperation, dryRun, repaired: false } });
+    return result(facade as unknown as Record<string, unknown>, true);
+  }
+
+  if (planId && planStepId) {
     const plan = getPlanContract(store, planId);
     const step = plan?.steps.find((candidate) => candidate.id === planStepId);
     if (!plan || !step) {
@@ -2496,26 +2618,85 @@ async function runFacadeRepair(
   return result(facade as unknown as Record<string, unknown>, facade.status === 'blocked' || facade.status === 'approval_required' || facade.status === 'failed');
 }
 
-function reconcileTerminalFacadeWorkVerifications(
+function repositoryWorkHandleHasSourceDelta(
+  repository: ReturnType<typeof selected>,
+  handle: WorkHandleState,
+): boolean {
+  try {
+    const checkout = selectRepositoryCheckout(repository, handle.checkoutId, { allowArchived: true });
+    const status = repositoryGitStatus(checkout);
+    const head = status.head ?? handle.expectedHead ?? handle.baseCommit;
+    return !status.clean || Boolean(head && handle.baseCommit && head !== handle.baseCommit);
+  } catch (_error) {
+    // A checkout may already have been removed by an earlier bounded cleanup
+    // attempt. The WorkHandle's fenced expectedHead remains authoritative for
+    // whether repository delivery existed and must not be downgraded to an
+    // effect-only semantic completion.
+    return Boolean(handle.expectedHead && handle.baseCommit && handle.expectedHead !== handle.baseCommit);
+  }
+}
+
+function finalizeRemoteEffectWorkFromRepositoryProcessReceipt(
   ctx: MultiRepositoryMcpToolContext,
   repository: ReturnType<typeof selected>,
   workId: string,
-): { sourceRevision?: string; workspaceFingerprint?: string; workspaceChangedPaths?: string[]; reconciledProcessIds: string[] } {
+  checkoutId: string,
+) {
   const store = { controllerHome: ctx.controllerHome, repoId: repository.repoId };
-  const workContract = getWorkContract(store, workId);
-  if (!workContract || workContract.completionReceipt) return { reconciledProcessIds: [] };
-
-  let verificationRepository: ReturnType<typeof selectRepositoryCheckout>;
-  try {
-    verificationRepository = workContract.checkoutId
-      ? selectRepositoryCheckout(repository, workContract.checkoutId, { allowArchived: true })
-      : repository;
-  } catch {
-    return { reconciledProcessIds: [] };
+  const work = getWorkContract(store, workId);
+  if (!work) throw new Error(`WORK_REMOTE_EFFECT_PROCESS_BINDING_NOT_FOUND: ${workId}`);
+  if (work.workKind !== 'remote_effect') {
+    throw new Error(`WORK_REMOTE_EFFECT_PROCESS_KIND_MISMATCH: ${workId} is ${work.workKind}, expected remote_effect`);
+  }
+  if (work.status === 'completed' && work.completionReceipt?.source === 'remote_effect') return work;
+  const evidence = listWorkBoundRepositoryRemoteEffectProcessEvidence({
+    controllerHome: ctx.controllerHome,
+    repoId: repository.repoId,
+    checkoutId,
+    workId,
+  })[0];
+  if (!evidence) return undefined;
+  if (!work.evidenceRefs.some((candidate) => candidate.evidenceId === evidence.processId)) {
+    appendWorkEvidence(store, workId, {
+      evidenceId: evidence.processId,
+      title: 'trusted repository remote effect completed',
+      summary: `Trusted Work-attributed git push completed with durable Process ${evidence.processId}.`,
+      detailLevel: 'summary',
+    });
   }
+  return recordWorkCompletionReceipt(
+    store,
+    workId,
+    {
+      schemaVersion: 1,
+      receiptId: evidence.processId,
+      source: 'remote_effect',
+      workId,
+      authority: 'repository_process',
+      actionId: evidence.actionId,
+      requestId: evidence.requestId,
+      semanticKey: evidence.semanticKey,
+      resultDigest: evidence.resultDigest,
+      processId: evidence.processId,
+      recordedAt: evidence.finishedAt ?? new Date().toISOString(),
+    },
+    'completed_remote',
+    'remote_effect',
+  );
+}
+
+function reconcileTerminalFacadeWorkVerifications(
+  ctx: MultiRepositoryMcpToolContext,
+  repository: ReturnType<typeof selected>,
+  workId: string,
+): { sourceRevision?: string; workspaceFingerprint?: string; workspaceChangedPaths?: string[]; reconciledProcessIds: string[]; workBoundProcessEvidenceIds: string[] } {
+  const resolvedVerification = resolveWorkVerificationContext({ controllerHome: ctx.controllerHome, repository, workId });
+  if (!resolvedVerification.ok) return { reconciledProcessIds: [], workBoundProcessEvidenceIds: [] };
+  const { store, workContract, repository: verificationRepository, checks: availableChecks } = resolvedVerification.context;
+  if (!workContract || workContract.completionReceipt) return { reconciledProcessIds: [], workBoundProcessEvidenceIds: [] };
   const verificationStatus = repositoryGitStatus(verificationRepository);
   const sourceRevision = verificationStatus.head ?? undefined;
-  if (!sourceRevision) return { reconciledProcessIds: [] };
+  if (!sourceRevision) return { reconciledProcessIds: [], workBoundProcessEvidenceIds: [] };
   const verificationHandle = readWorkHandle(ctx.controllerHome, repository.repoId, workId);
   const deliveryBaseRevision = verificationHandle
     ? workDeliveryBaseRevision(verificationHandle)
@@ -2530,7 +2711,22 @@ function reconcileTerminalFacadeWorkVerifications(
     ...verificationStatus.untracked,
   ])].sort();
   const workspaceFingerprint = workspaceValidationFingerprint(verificationRepository.canonicalRoot, verificationStatus);
-  const availableChecks = listControllerChecks(repository.canonicalRoot);
+  // Work-bound repository Process evidence remains semantic/result evidence,
+  // never a typed check receipt. repository_change may use it only when no
+  // checks are declared. local_effect may bind the same exact durable Process
+  // ids for Controller semantic review even when checks are declared; the
+  // normal missing-check gate below still requires typed verification receipts.
+  const workBoundProcessEvidenceIds = (
+    workContract.workKind === 'local_effect'
+    || (workContract.workKind === 'repository_change' && workContract.checks.length === 0)
+  )
+    ? listWorkBoundRepositoryProcessEvidence({
+        controllerHome: ctx.controllerHome,
+        repoId: repository.repoId,
+        checkoutId: verificationRepository.activeCheckoutId,
+        workId,
+      }).map((evidence) => evidence.processId)
+    : [];
   const workloopCtx = {
     workStore: store,
     handoffStore: store,
@@ -2585,29 +2781,11 @@ function reconcileTerminalFacadeWorkVerifications(
       const latestContract = getWorkContract(store, workId);
       if (latestContract?.checkRefs.some((entry) => entry.receipt?.receiptId === receipt.receiptId)) continue;
 
-      const structuredCheckResult = readPersistedCheckResultReceipt(record.origin?.checkResultReceiptPath);
-      const structuredResultMatchesProcess = Boolean(
-        structuredCheckResult
-        && structuredCheckResult.checkId === normalizedCheckId
-        && structuredCheckResult.cacheKey === record.checkExecution.cacheKey,
-      );
       const legacyEvidence = record.origin?.checkResultReceiptPath
         ? undefined
         : readLatestControllerCheckEvidence(verificationRepository.canonicalRoot, normalizedCheckId);
-      const legacyEvidenceMatchesProcess = Boolean(
-        legacyEvidence?.cacheKey
-        && legacyEvidence.cacheKey === record.checkExecution.cacheKey,
-      );
-      const evidenceState = classifyTerminalCheckEvidence({
-        processError: record.error,
-        structuredPresent: Boolean(structuredCheckResult),
-        structuredMatches: structuredResultMatchesProcess,
-        legacyPresent: Boolean(legacyEvidence),
-        legacyMatches: legacyEvidenceMatchesProcess,
-      });
-      const failureClass = structuredResultMatchesProcess
-        ? structuredCheckResult?.failureClass
-        : legacyEvidenceMatchesProcess ? legacyEvidence?.failureClass : undefined;
+      const evidenceState = classifyPersistedCheckTerminalEvidence(record, normalizedCheckId, { legacyEvidence });
+      const failureClass = evidenceState.failureClass;
       const infrastructureFailed = receipt.timedOut
         || receipt.cancelled
         || evidenceState.state !== 'matched'
@@ -2619,500 +2797,59 @@ function reconcileTerminalFacadeWorkVerifications(
         sourceRevision,
         workspaceFingerprint,
         verificationInputFingerprint: currentFingerprint,
-        commandFingerprint: commandFingerprint(normalizedCheckId, receipt.commandId),
-        receipt,
-        infrastructureFailed,
-        checkFailed,
-      });
-      reconciledProcessIds.push(record.processId);
-    } catch {
-      // Exact receipt/process identity is mandatory. Any malformed, stale, or
-      // mismatched terminal Process remains non-authoritative and is ignored.
-    }
-  }
-
-  return { sourceRevision, workspaceFingerprint, workspaceChangedPaths, reconciledProcessIds };
-}
-
-async function runFacadeVerify(
-  ctx: MultiRepositoryMcpToolContext,
-  repository: ReturnType<typeof selected>,
-  args: Record<string, unknown>,
-): Promise<CallToolResult> {
-  const store = { controllerHome: ctx.controllerHome, repoId: repository.repoId };
-  const checks = listControllerChecks(repository.canonicalRoot);
-  const workloopCtx = {
-    workStore: store,
-    handoffStore: store,
-    repoId: repository.repoId,
-    availableChecks: checks,
-  };
-  const workId = typeof args.work_id === 'string' ? args.work_id : '';
-  const checkId = String(args.check_id ?? args.checkId ?? '').trim();
-  if (!checkId) {
-    return result(buildFacadeResult({
-      status: 'blocked',
-      summary: 'rh_work verify requires a registered check_id.',
-      data: {
-        verification: {
-          outcome: 'check_id_required',
-          isAcceptanceFailure: false,
-          isInfrastructureIssue: true,
-          doesNotRequestTaskChanges: true,
-        },
-        registeredCheckCount: checks.length,
-      },
-      warnings: ['CHECK_ID_REQUIRED: pass check_id for one registered repository check.'],
-      suggestedNextActions: normalizeCheckIds(checks.slice(0, 3).map((check) => check.id), checks).suggestedNextActions,
-    }) as unknown as Record<string, unknown>, true);
-  }
-  const workContract = workId ? getWorkContract(store, workId) : undefined;
-  if (workId && (!workContract || workContract.status === 'completed' || workContract.status === 'cancelled' || workContract.status === 'failed')) {
-    const facade = verifyGoalWorkloop(workloopCtx, { workId, checkId });
-    return result(facade as unknown as Record<string, unknown>, facade.status === 'failed');
-  }
-
-  const classified = classifyVerificationOutcome({
-    checkId,
-    available: checks,
-  });
-
-  if (classified.outcome === 'invalid_check_id') {
-    if (workId) {
-      const facade = verifyGoalWorkloop(workloopCtx, { workId, checkId });
-      return result(facade as unknown as Record<string, unknown>);
-    }
-    return result(buildFacadeResult({
-      status: 'ok',
-      summary: classified.summary,
-      data: {
-        verification: {
-          checkId,
-          outcome: 'invalid_check_id',
-          isAcceptanceFailure: false,
-          isInfrastructureIssue: true,
-          doesNotRequestTaskChanges: true,
-        },
-        registeredCheckCount: checks.length,
-      },
-      warnings: classified.warnings,
-      suggestedNextActions: normalizeCheckIds(checks.slice(0, 3).map((check) => check.id), checks).suggestedNextActions,
-    }) as unknown as Record<string, unknown>);
-  }
-
-  // Simulation path for unit tests / explicit dry verification without process execution.
-  if (args.simulate_check === true || args.infrastructure_failed === true || args.check_failed === true || args.skipped === true) {
-    if (!workId) {
-      return result(buildFacadeResult({
-        status: args.check_failed === true ? 'failed' : 'ok',
-        summary: 'Simulated verification without WorkContract.',
-        data: {
-          verification: {
-            checkId: classified.normalizedCheckId,
-            outcome: args.skipped ? 'skipped' : args.infrastructure_failed ? 'infrastructure_failure' : args.check_failed ? 'valid_fail' : 'valid_pass',
-            isAcceptanceFailure: args.check_failed === true,
-            simulated: true,
-          },
-        },
-      }) as unknown as Record<string, unknown>, args.check_failed === true);
-    }
-    const facade = verifyGoalWorkloop(workloopCtx, {
-      workId,
-      checkId: classified.normalizedCheckId ?? checkId,
-      infrastructureFailed: args.infrastructure_failed === true,
-      checkFailed: args.check_failed === true,
-      skipped: args.skipped === true,
-    });
-    return result(facade as unknown as Record<string, unknown>, facade.status === 'failed');
-  }
-
-  // Real checks share the same persisted Process Runtime path as run_check and
-  // work_validate. Never synchronously block the MCP facade on long native tests.
-  try {
-    const normalizedCheckId = classified.normalizedCheckId!;
-    const requestId = typeof args.request_id === 'string' && args.request_id.trim()
-      ? args.request_id.trim()
-      : undefined;
-    const verificationRepository = workContract?.checkoutId
-      ? selectRepositoryCheckout(repository, workContract.checkoutId, { allowArchived: true })
-      : repository;
-    const verificationStatus = repositoryGitStatus(verificationRepository);
-    const observedGitHead = verificationStatus.head;
-    const workspaceFingerprint = workspaceValidationFingerprint(verificationRepository.canonicalRoot, verificationStatus);
-    const requestedChecks = workContract?.checks.length ? workContract.checks : [normalizedCheckId];
-    const verificationRequestFingerprint = observedGitHead ? verificationInputFingerprint({
-      sourceRevision: observedGitHead,
-      workspaceFingerprint,
-      checkId: normalizedCheckId,
-      requestedChecks,
-    }) : undefined;
-    const registeredCheck = checks.find((entry) => entry.id === normalizedCheckId);
-    const durableClassCheck = checkRequiresDurableWorkflow(normalizedCheckId, registeredCheck);
-    let allowDurableCheckExecution = false;
-    if (durableClassCheck && workContract?.checks.includes(normalizedCheckId) && !workContract.completionReceipt && workContract.status === 'running') {
-      try {
-        const identity = authenticatedFacadeControllerIdentity(ctx, args);
-        const owner = getControllerSession(store, workId);
-        const ownerPrincipal = owner?.principalId?.trim() || owner?.controllerId;
-        allowDurableCheckExecution = Boolean(
-          owner
-          && owner.controllerId === identity.controllerId
-          && ownerPrincipal === identity.principalId
-          && owner.controllerInstanceId === identity.controllerInstanceId,
-        );
-      } catch {
-        // Durable-class checks remain deferred when the authenticated claim cannot
-        // be proven exactly. The lower Process Runtime never infers authority.
-        allowDurableCheckExecution = false;
-      }
-    }
-    const executed = await runPersistedCheckViaProcessRuntime({
-      controllerHome: ctx.controllerHome,
-      repoId: verificationRepository.repoId,
-      checkoutId: verificationRepository.activeCheckoutId,
-      repoRoot: verificationRepository.canonicalRoot,
-      executionIdentity: executionIdentityForRepository(verificationRepository, workId ? { workId } : {}),
-      checkId: normalizedCheckId,
-      timeoutMs: typeof args.timeout_ms === 'number' ? args.timeout_ms : undefined,
-      // rh_work.verify is a control-plane continuation primitive: callers should
-      // be able to keep working and later reattach to the exact same Process.
-      // Absorb brief shared build-cache/resource contention during admission so
-      // a lifecycle verification does not turn a few seconds of contention into
-      // a terminal failed Check that the controller must manually retry.
-      interactiveWaitMs: 0,
-      leaseWaitMs: RH_WORK_VERIFY_LEASE_WAIT_MS,
-      requestId,
-      requestSemanticFingerprint: verificationRequestFingerprint,
-      workId: workId || undefined,
-      commandId: requestId,
-      verificationSnapshot: workContract ? {
-        workId: workContract.workId,
-        allowedPaths: workContract.allowedPaths,
-        forbiddenPaths: workContract.forbiddenPaths,
-      } : undefined,
-      allowDurableCheckExecution,
-    });
-
-    if (executed.mode === 'durable') {
-      return result(buildFacadeResult({
-        status: 'blocked',
-        summary: `Check ${normalizedCheckId} requires an explicit durable workflow; no acceptance result was recorded.`,
-        data: {
-          verification: {
-            checkId: normalizedCheckId,
-            outcome: 'deferred',
-            isAcceptanceFailure: false,
-            isInfrastructureIssue: false,
-            durable: executed.durable,
-            observedGitHead,
-          },
-        },
-        suggestedNextActions: [{
-          label: 'Continue Work with the durable check requirement',
-          tool: 'rh_work',
-          operation: 'continue',
-          payload: { work_id: workId || undefined },
-          risk: 'workspace_write',
-          confidence: 'high',
-        }],
-      }) as unknown as Record<string, unknown>, true);
-    }
-
-    const handle = executed.process;
-    if (!handle) throw new Error(`PROCESS_CHECK_HANDLE_MISSING: ${normalizedCheckId}`);
-    const record = getProcessRecord(ctx.controllerHome, verificationRepository.repoId, handle.processId);
-    const checkContentRevision = record?.checkExecution?.revision;
-
-    if (!handle.completed) {
-      return result(buildFacadeResult({
-        status: 'ok',
-        summary: `Check ${normalizedCheckId} is running through Process Runtime; continue other work and reattach to ${handle.processId}.`,
-        data: {
-          verification: {
-            checkId: normalizedCheckId,
-            outcome: 'running',
-            isAcceptanceFailure: false,
-            isInfrastructureIssue: false,
-            executed: true,
-            completed: false,
-            processId: handle.processId,
-            processStatus: handle.status,
-            deduplicated: handle.deduplicated === true,
-            semanticDeduplicated: handle.semanticDeduplicated === true,
-            checkContentRevision,
-            observedGitHead,
-            verificationIsolation: workContract ? 'work_snapshot' : 'shared_checkout',
-            revisionSemantics: 'checkContentRevision is a content-bound Check identity; observedGitHead is Git HEAD and is not interchangeable.',
-          },
-        },
-        rawAvailable: false,
-      }) as unknown as Record<string, unknown>);
-    }
-
-    if (!record) throw new Error(`PROCESS_CHECK_RECORD_MISSING: ${handle.processId}`);
-    const receipt = processCheckCompletionReceipt(record, {
-      repoId: verificationRepository.repoId,
-      checkId: normalizedCheckId,
-      processId: handle.processId,
-      ...(record.checkExecution ? {
-        checkoutId: verificationRepository.activeCheckoutId,
-        workId: workId || undefined,
-        requestId,
-        checkExecution: {
-          cacheKey: record.checkExecution.cacheKey,
-          revision: record.checkExecution.revision,
-          definitionDigest: record.checkExecution.definitionDigest,
-          environmentFingerprint: record.checkExecution.environmentFingerprint,
-          timeoutMs: record.checkExecution.timeoutMs,
-          scopeKey: record.checkExecution.scopeKey,
-        },
-      } : {}),
-    });
-    const structuredCheckResult = readPersistedCheckResultReceipt(record.origin?.checkResultReceiptPath);
-    const structuredResultMatchesProcess = Boolean(
-      structuredCheckResult
-      && record.checkExecution?.cacheKey
-      && structuredCheckResult.checkId === normalizedCheckId
-      && structuredCheckResult.cacheKey === record.checkExecution.cacheKey,
-    );
-    const legacyEvidence = record.origin?.checkResultReceiptPath
-      ? undefined
-      : readLatestControllerCheckEvidence(verificationRepository.canonicalRoot, normalizedCheckId);
-    const legacyEvidenceMatchesProcess = Boolean(
-      legacyEvidence?.cacheKey
-      && record.checkExecution?.cacheKey
-      && legacyEvidence.cacheKey === record.checkExecution.cacheKey,
-    );
-    const evidenceState = classifyTerminalCheckEvidence({
-      processError: record.error,
-      structuredPresent: Boolean(structuredCheckResult),
-      structuredMatches: structuredResultMatchesProcess,
-      legacyPresent: Boolean(legacyEvidence),
-      legacyMatches: legacyEvidenceMatchesProcess,
-    });
-    const resultMatchesProcess = evidenceState.state === 'matched';
-    const failureClass = structuredResultMatchesProcess
-      ? structuredCheckResult?.failureClass
-      : legacyEvidenceMatchesProcess ? legacyEvidence?.failureClass : undefined;
-    const infrastructureFailed = receipt.timedOut
-      || receipt.cancelled
-      || !resultMatchesProcess
-      || (!receipt.ok && failureClass !== 'acceptance_failure');
-    const checkFailed = !receipt.ok && !infrastructureFailed;
-    const boundedStatus = receipt.ok ? 'pass' : infrastructureFailed ? 'infrastructure_failure' : 'fail';
-    const commonVerification = {
-      checkId: normalizedCheckId,
-      outcome: infrastructureFailed ? 'infrastructure_failure' : receipt.ok ? 'valid_pass' : 'valid_fail',
-      isAcceptanceFailure: checkFailed,
-      isInfrastructureIssue: infrastructureFailed,
-      executed: true,
-      completed: true,
-      processId: receipt.processId,
-      processStatus: receipt.runtimeStatus,
-      ok: receipt.ok,
-      timedOut: receipt.timedOut,
-      cancelled: receipt.cancelled,
-      failureClass: infrastructureFailed ? 'infrastructure_failure' : failureClass,
-      deduplicated: handle.deduplicated === true,
-      semanticDeduplicated: handle.semanticDeduplicated === true,
-      checkContentRevision: receipt.checkRevision,
-      observedGitHead,
-      revisionSemantics: 'checkContentRevision is a content-bound Check identity; observedGitHead is Git HEAD and is not interchangeable.',
-      evidenceArtifactPath: record.origin?.workVerificationSnapshot ? undefined : receipt.artifactPath,
-      evidenceReceiptId: receipt.receiptId,
-      checkResultReceiptId: structuredCheckResult?.receiptId,
-      verificationIsolation: record.origin?.workVerificationSnapshot ? 'work_snapshot' : 'shared_checkout',
-      boundedStatus,
-      evidenceState: evidenceState.state,
-      ...(evidenceState.infrastructureReason ? { infrastructureReason: evidenceState.infrastructureReason } : {}),
-      ...(record.error?.code ? { processErrorCode: record.error.code } : {}),
-    };
-
-    if (workId) {
-      const sourceRevision = observedGitHead ?? undefined;
-      const facade = verifyGoalWorkloop(workloopCtx, {
-        workId,
-        checkId: normalizedCheckId,
-        sourceRevision,
-        workspaceFingerprint,
-        verificationInputFingerprint: sourceRevision ? verificationRequestFingerprint : undefined,
-        commandFingerprint: commandFingerprint(normalizedCheckId, receipt.commandId),
-        receipt,
-        infrastructureFailed,
-        checkFailed,
-      });
-      const data = facade.data as Record<string, unknown>;
-      return result({
-        ...facade,
-        data: {
-          ...data,
-          verification: {
-            ...(typeof data.verification === 'object' && data.verification ? data.verification as Record<string, unknown> : {}),
-            ...commonVerification,
-          },
-        },
-        warnings: infrastructureFailed
-          ? [...facade.warnings, evidenceState.warning ?? 'infrastructure_failure is distinct from acceptance failure']
-          : facade.warnings,
-      } as unknown as Record<string, unknown>, facade.status === 'failed');
-    }
-
-    return result(buildFacadeResult({
-      status: checkFailed ? 'failed' : 'ok',
-      summary: infrastructureFailed
-        ? `Infrastructure failure while running ${normalizedCheckId}; not an acceptance failure.`
-        : receipt.ok
-          ? `Check ${normalizedCheckId} passed with persisted Process evidence.`
-          : `Check ${normalizedCheckId} failed acceptance.`,
-      data: { verification: commonVerification },
-      warnings: infrastructureFailed
-        ? [evidenceState.warning ?? 'infrastructure_failure is distinct from acceptance failure']
-        : [],
-      rawAvailable: false,
-    }) as unknown as Record<string, unknown>, checkFailed);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (workId) {
-      const facade = verifyGoalWorkloop(workloopCtx, {
-        workId,
-        checkId: classified.normalizedCheckId ?? checkId,
-        infrastructureFailed: true,
+        commandFingerprint: commandFingerprint(normalizedCheckId, receipt.commandId),
+        receipt,
+        infrastructureFailed,
+        checkFailed,
       });
-      return result({
-        ...facade,
-        warnings: [...facade.warnings, `check_runner_error: ${message.slice(0, 200)}`],
-        data: {
-          ...(facade.data as Record<string, unknown>),
-          isAcceptanceFailure: false,
-        },
-      } as unknown as Record<string, unknown>);
+      reconciledProcessIds.push(record.processId);
+    } catch {
+      // Exact receipt/process identity is mandatory. Any malformed, stale, or
+      // mismatched terminal Process remains non-authoritative and is ignored.
     }
-    return result(buildFacadeResult({
-      status: 'ok',
-      summary: `Infrastructure failure invoking Process Runtime for ${classified.normalizedCheckId}; not acceptance failure.`,
-      data: {
-        verification: {
-          checkId: classified.normalizedCheckId,
-          outcome: 'infrastructure_failure',
-          isAcceptanceFailure: false,
-          isInfrastructureIssue: true,
-        },
-      },
-      warnings: [`check_runner_error: ${message.slice(0, 200)}`],
-      suggestedNextActions: [{
-        label: 'Diagnose runtime (dry-run)',
-        tool: 'rh_work',
-        operation: 'repair',
-        payload: { repair_operation: 'diagnose', dry_run: true },
-        risk: 'readonly',
-      }],
-    }) as unknown as Record<string, unknown>);
   }
-}
 
-/**
- * Runtime Source drift for MCP readiness.
- *
- * `currentRuntimeRoot` is only for tests that pin a Controller Runtime Source
- * fixture. Callers must never pass an execution repository canonicalRoot here.
- */
-export function runtimeSourceSnapshotStatus(
-  active: RuntimeSourceIdentity | undefined,
-  currentRuntimeRoot?: string,
-) {
-  const drift = evaluateActiveRuntimeSourceDrift(active, {
-    currentRuntimeRoot,
-  });
-  return {
-    current: drift.current,
-    restartRequired: drift.restartRequired,
-    reasons: drift.reasons,
-    code: drift.code,
-  };
+  return { sourceRevision, workspaceFingerprint, workspaceChangedPaths, reconciledProcessIds, workBoundProcessEvidenceIds };
 }
 
-export function repositoryExecutionReadiness(
-  repoRoot: string,
-  availableChecks: ReturnType<typeof listControllerChecks>,
-  requestedCheckIds: string[] = [],
-  schedulingScope: { repoId?: string; checkoutId?: string } = {},
-): Record<string, unknown> {
-  const git = gitSnapshot(repoRoot);
-  const registeredCheckIds = availableChecks.map((check) => check.id);
-  const normalizedChecks = normalizeCheckIds(requestedCheckIds, availableChecks);
-  const hasPackageJson = existsSync(join(repoRoot, 'package.json'));
-  const nodeModulesReady = !hasPackageJson || existsSync(join(repoRoot, 'node_modules'));
-  const lockCandidates = [
-    ['bun', 'bun.lock'],
-    ['bun', 'bun.lockb'],
-    ['pnpm', 'pnpm-lock.yaml'],
-    ['npm', 'package-lock.json'],
-    ['yarn', 'yarn.lock'],
-  ] as const;
-  const detectedLock = lockCandidates.find(([, path]) => existsSync(join(repoRoot, path)));
-  const packageManager = detectedLock?.[0];
-  const bootstrapCommand = hasPackageJson && !nodeModulesReady
-    ? packageManager === 'bun' ? ['bun', 'install', '--frozen-lockfile']
-      : packageManager === 'pnpm' ? ['pnpm', 'install', '--frozen-lockfile']
-        : packageManager === 'npm' ? ['npm', 'ci']
-          : packageManager === 'yarn' ? ['yarn', 'install', '--frozen-lockfile']
-            : undefined
-    : undefined;
-  const hasPythonManifest = existsSync(join(repoRoot, 'pyproject.toml'))
-    || existsSync(join(repoRoot, 'requirements.txt'))
-    || existsSync(join(repoRoot, 'requirements-dev.txt'));
-  const localPythonReady = !hasPythonManifest
-    || existsSync(join(repoRoot, '.venv', 'bin', 'python'))
-    || existsSync(join(repoRoot, '.venv', 'Scripts', 'python.exe'));
-  const checkScheduling = buildCheckExecutionSchedule({
-    checks: availableChecks,
-    requestedCheckIds,
-    repoId: schedulingScope.repoId?.trim() || 'selected-repository',
-    checkoutId: schedulingScope.checkoutId?.trim() || 'active',
+async function runFacadeVerify(
+  ctx: MultiRepositoryMcpToolContext,
+  repository: ReturnType<typeof selected>,
+  args: Record<string, unknown>,
+): Promise<CallToolResult> {
+  const workId = typeof args.work_id === 'string' ? args.work_id.trim() : '';
+  const verification = await executeWorkVerification({
+    controllerHome: ctx.controllerHome,
+    repository,
+    workId: workId || undefined,
+    checkId: String(args.check_id ?? args.checkId ?? '').trim(),
+    requestId: typeof args.request_id === 'string' && args.request_id.trim() ? args.request_id.trim() : undefined,
+    timeoutMs: typeof args.timeout_ms === 'number' ? args.timeout_ms : undefined,
+    interactiveWaitMs: 0,
+    leaseWaitMs: RH_WORK_VERIFY_LEASE_WAIT_MS,
+    simulate: args.simulate_check === true || args.infrastructure_failed === true || args.check_failed === true || args.skipped === true
+      ? {
+          infrastructureFailed: args.infrastructure_failed === true,
+          checkFailed: args.check_failed === true,
+          skipped: args.skipped === true,
+        }
+      : undefined,
+    allowDurableCheckExecution: workId ? ({ work }) => {
+      try {
+        const identity = authenticatedFacadeControllerIdentity(ctx, args);
+        const owner = getControllerSession({ controllerHome: ctx.controllerHome, repoId: repository.repoId }, work.workId);
+        return Boolean(
+          owner
+          && owner.controllerId === identity.controllerId
+          && controllerSessionPrincipalId(owner) === identity.principalId
+          && owner.controllerInstanceId === identity.controllerInstanceId,
+        );
+      } catch {
+        return false;
+      }
+    } : undefined,
   });
-  const blockers = [
-    ...(!nodeModulesReady ? [{ code: 'NODE_DEPENDENCIES_MISSING', message: 'package.json is present but node_modules is not materialized in this checkout.' }] : []),
-    ...normalizedChecks.invalidCheckIds.map((checkId) => ({ code: 'CHECK_NOT_REGISTERED', message: `Requested check is not registered: ${checkId}`, checkId })),
-  ];
-  return {
-    readyForFocusedExecution: blockers.length === 0,
-    git: { head: git.head, branch: git.branch, dirty: git.dirty },
-    checks: {
-      registeredCount: registeredCheckIds.length,
-      registeredCheckIds: registeredCheckIds.slice(0, 80),
-      requestedCheckIds: requestedCheckIds.slice(0, 40),
-      normalized: normalizedChecks,
-    },
-    checkScheduling: {
-      waveCount: checkScheduling.waves.length,
-      maxParallel: checkScheduling.maxParallel,
-      waveSummaries: checkScheduling.waves.map((wave) => `wave ${wave.wave}: ${wave.checkIds.join(', ')}`),
-      conflictSummaries: checkScheduling.conflicts.map((conflict) => {
-        const resources = [...new Set(conflict.resources.flatMap(({ left, right }) => [left.resourceKey, right.resourceKey]))];
-        return `${conflict.leftCheckId} <> ${conflict.rightCheckId}: ${resources.join(', ')}`;
-      }),
-      invalidCheckIds: checkScheduling.invalidCheckIds,
-      guidance: checkScheduling.guidance,
-    },
-    dependencies: {
-      node: {
-        applicable: hasPackageJson,
-        ready: nodeModulesReady,
-        packageManager: packageManager ?? null,
-        lockfile: detectedLock?.[1] ?? null,
-        ...(bootstrapCommand ? { bootstrapCommand } : {}),
-      },
-      python: {
-        applicable: hasPythonManifest,
-        localVirtualEnvReady: localPythonReady,
-        advisoryOnly: true,
-      },
-    },
-    blockers,
-    guidance: bootstrapCommand
-      ? [`Materialize checkout dependencies before tests/builds: ${bootstrapCommand.join(' ')}`]
-      : [],
-  };
+  return result(verification.facade as unknown as Record<string, unknown>, verification.isError);
 }
 
 export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name: string, args: Record<string, unknown>): Promise<CallToolResult | undefined> {
@@ -3142,8 +2879,7 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
             ctx.runtimeSourceRoot,
           );
           const sourceSnapshotStale = runtimeSource.restartRequired;
-          const toolset = await import('../../../cli/mcp/toolset');
-          const exposure = toolset.controllerToolSurfaceStatus(ctx);
+          const exposure = controllerToolSurfaceStatus(ctx);
           const toolSurfaceReady = exposure.ready && exposure.missingToolNames.length === 0;
           const ready = observation.ready && toolSurfaceReady && !sourceSnapshotStale;
           const reasonCodes = [...observation.reasonCodes];
@@ -3284,10 +3020,8 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
         // never against the selected execution repository.
         const runtimeSource = runtimeSourceSnapshotStatus(readiness.daemon.source, ctx.runtimeSourceRoot);
         const sourceSnapshotStale = runtimeSource.restartRequired;
-        // Dynamic import avoids a static cycle: toolset.ts composes runtimeToolDefinitions.
-        const toolset = await import('../../../cli/mcp/toolset');
-        const exposure = toolset.controllerExposureSnapshot(ctx);
-        const localRegisteredToolNames = toolset.allControllerToolDefinitions(ctx).map((tool) => tool.name).sort();
+        const exposure = controllerExposureSnapshot(ctx);
+        const localRegisteredToolNames = allControllerToolDefinitions(ctx).map((tool) => tool.name).sort();
         markDetailPhase('tool_surface');
         const toolSurfaceReady = exposure.ready && exposure.missingToolNames.length === 0;
         // Ordinary interactive execution depends on the execution axis only.
@@ -3526,8 +3260,12 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
           if (item.workId && ctx.principalId?.trim() && ctx.sessionId?.trim()) {
             const owner = getControllerSession(store, item.workId);
             if (owner && owner.controllerId === ctx.principalId.trim() && owner.sessionId === ctx.sessionId.trim()) {
-              releaseControllerSession(store, item.workId, owner.controllerId);
-              ownershipReleased = true;
+              const released = releaseObservedControllerSession(store, {
+                workId: item.workId,
+                actor: `handoff-create:${ctx.principalId.trim()}`,
+                owner,
+              });
+              ownershipReleased = released.allowed;
             }
           }
           return result(buildFacadeResult({ summary: `Created handoff ${item.id}.`, data: { item: summarizeHandoffItem(item), ownershipReleased } }) as unknown as Record<string, unknown>);
@@ -4190,13 +3928,28 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
             const work = getWorkContract(store, workId);
             if (!work) throw new Error(`WORK_NOT_FOUND: ${workId}`);
             const identity = authenticatedFacadeControllerIdentity(ctx, args);
+            assertFacadeControllerRoundAuthority(ctx, store, workId, args);
+            const observedOwner = getControllerSession(store, workId);
+            const dispatchedRelay = getControllerRoundRelay(store, workId);
+            const crossOwnerRecovery = Boolean(observedOwner)
+              && (
+                observedOwner!.controllerId !== identity.controllerId
+                || controllerSessionPrincipalId(observedOwner!) !== identity.principalId
+              )
+              && dispatchedChatgptRelayAuthorizesStaleControllerRecovery(dispatchedRelay, identity.controllerType);
             const session = resumeControllerSession(store, {
               workId,
               controllerId: identity.controllerId,
-              controllerType: ['chatgpt', 'codex', 'grok', 'claude', 'human'].includes(String(args.controller_type)) ? String(args.controller_type) as 'chatgpt' | 'codex' | 'grok' | 'claude' | 'human' : 'chatgpt',
+              controllerType: identity.controllerType,
               sessionId: identity.sessionId,
               principalId: identity.principalId,
               controllerInstanceId: identity.controllerInstanceId,
+              ...(crossOwnerRecovery
+                ? {
+                    expectedClaimGeneration: observedOwner!.claimGeneration,
+                    allowStaleRecovery: true,
+                  }
+                : {}),
               leaseMs: typeof args.lease_ms === 'number' ? args.lease_ms : undefined,
             });
             const permissionSnapshotVersion = currentPermissionSnapshotVersion(ctx.controllerHome, repository.repoId);
@@ -4238,7 +3991,7 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
             if (!['continue_immediately', 'wait', 'wait_for_user', 'goal_complete'].includes(disposition)) {
               throw new Error('CONTROLLER_RELAY_DISPOSITION_INVALID');
             }
-            const identity = authenticatedFacadeControllerIdentity(ctx, args);
+            const identity = authenticatedFacadeControllerIdentity(ctx, args, { allowTransportSessionRollover: true });
             const work = getWorkContract(store, workId);
             if (!work) throw new Error(`WORK_NOT_FOUND: ${workId}`);
             const terminalGoalComplete = work.status === 'completed' && disposition === 'goal_complete';
@@ -4252,7 +4005,7 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
             if (currentOwner) {
               if (currentOwner.controllerType !== 'chatgpt') throw new Error(`CONTROLLER_RELAY_CHATGPT_ONLY: ${workId}`);
               if (currentOwner.controllerId !== identity.controllerId) throw new Error(`WORK_CONTROLLER_OWNER_MISMATCH: ${workId}`);
-              if ((currentOwner.principalId?.trim() || currentOwner.controllerId) !== identity.principalId) {
+              if ((controllerSessionPrincipalId(currentOwner)) !== identity.principalId) {
                 throw new Error(`WORK_CONTROLLER_PRINCIPAL_MISMATCH: ${workId}`);
               }
               // Finalization may terminalize the Work before the prompt-required
@@ -4261,21 +4014,7 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
               // rewrite a terminal Work lease here; terminal authorization is fenced
               // by the already-claimed relay lineage in submitControllerRoundDisposition.
               if (!terminalGoalComplete) {
-                if (!currentOwner.controllerInstanceId?.trim() || currentOwner.controllerInstanceId.trim() !== identity.controllerInstanceId) {
-                  throw new Error(`WORK_CONTROLLER_INSTANCE_MISMATCH: ${workId}`);
-                }
-                if (currentOwner.sessionId !== identity.sessionId) {
-                  resumeControllerSession(store, {
-                    workId,
-                    controllerId: identity.controllerId,
-                    controllerType: 'chatgpt',
-                    sessionId: identity.sessionId,
-                    principalId: identity.principalId,
-                    controllerInstanceId: identity.controllerInstanceId,
-                    expectedClaimGeneration: currentOwner.claimGeneration,
-                    leaseMs: 3_600_000,
-                  });
-                }
+                bindFacadeControllerOwnership(ctx, store, workId, { ...identity, controllerType: 'chatgpt' });
               }
             }
             const chatgptBinding = getChatgptWorkConversationBinding(store, workId);
@@ -4308,20 +4047,42 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
         if (operation === 'controller_release') {
           try {
             const workId = String(args.work_id ?? '').trim();
-            const identity = authenticatedFacadeControllerIdentity(ctx, args);
-            const owner = getControllerSession(store, workId);
+            const identity = authenticatedFacadeControllerIdentity(ctx, args, { allowTransportSessionRollover: true });
+            assertFacadeControllerRoundAuthority(ctx, store, workId, args);
+            const observedOwner = getControllerSession(store, workId);
+            const work = getWorkContract(store, workId);
+            const terminalWork = work ? ['completed', 'failed', 'cancelled'].includes(work.status) : false;
+            const owner = observedOwner
+              ? terminalWork
+                ? (() => {
+                    // A terminal Work cannot be rebound to a replacement MCP transport.
+                    // Authenticate the caller against the observed durable controller epoch
+                    // without mutating it; releaseControllerSessionWithAuthority remains the
+                    // exact claim-generation CAS authority for physical lease release.
+                    const ownerPrincipal = observedOwner.principalId?.trim() || observedOwner.controllerId;
+                    const ownerInstanceId = observedOwner.controllerInstanceId?.trim() || '';
+                    if (observedOwner.controllerId !== identity.controllerId) {
+                      throw new Error(`WORK_CONTROLLER_OWNER_MISMATCH: ${workId}`);
+                    }
+                    if (observedOwner.controllerType !== identity.controllerType) {
+                      throw new Error(`WORK_CONTROLLER_TYPE_MISMATCH: ${workId}`);
+                    }
+                    if (ownerPrincipal !== identity.principalId) {
+                      throw new Error(`WORK_CONTROLLER_PRINCIPAL_MISMATCH: ${workId}`);
+                    }
+                    if (!ownerInstanceId || ownerInstanceId !== identity.controllerInstanceId) {
+                      throw new Error(`WORK_CONTROLLER_INSTANCE_MISMATCH: ${workId}`);
+                    }
+                    if (typeof observedOwner.claimGeneration !== 'number' || observedOwner.claimGeneration < 1) {
+                      throw new Error(`WORK_CONTROLLER_CLAIM_GENERATION_REQUIRED: ${workId}`);
+                    }
+                    return observedOwner;
+                  })()
+                : bindFacadeControllerOwnership(ctx, store, workId, identity)
+              : undefined;
             if (owner) {
-              const ownerPrincipal = owner.principalId?.trim() || owner.controllerId;
+              const ownerPrincipal = controllerSessionPrincipalId(owner);
               const ownerInstanceId = owner.controllerInstanceId?.trim() || '';
-              if (owner.controllerId !== identity.controllerId) {
-                throw new Error(`WORK_CONTROLLER_OWNER_MISMATCH: ${workId} is owned by ${owner.controllerId}`);
-              }
-              if (ownerPrincipal !== identity.principalId) {
-                throw new Error(`WORK_CONTROLLER_PRINCIPAL_MISMATCH: ${workId}`);
-              }
-              if (!ownerInstanceId || ownerInstanceId !== identity.controllerInstanceId) {
-                throw new Error(`WORK_CONTROLLER_INSTANCE_MISMATCH: ${workId}`);
-              }
               if (typeof owner.claimGeneration !== 'number' || owner.claimGeneration < 1) {
                 throw new Error(`WORK_CONTROLLER_CLAIM_GENERATION_REQUIRED: ${workId}`);
               }
@@ -4349,6 +4110,9 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
               relayStore,
               { workId, releasedSession: owner },
             ) : undefined;
+            const abandonedRelay = owner && !relay
+              ? reconcileControllerRoundAfterAbandonedRelease(relayStore, { workId, releasedSession: owner })
+              : undefined;
             if (relay?.status === 'dispatching') {
               try {
                 assertAutomatedOperationAllowed('external_controller_wake', {
@@ -4418,8 +4182,10 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
               }
             }
             return result(buildFacadeResult({
-              summary: 'Controller lease released.',
-              data: { relay: getControllerRoundRelay(relayStore, workId) ?? relay, tabSettlement },
+              summary: abandonedRelay
+                ? 'Controller lease released; the claimed round was mechanically marked abandoned without semantic completion and can be relaunched through the bounded launcher path.'
+                : 'Controller lease released.',
+              data: { relay: getControllerRoundRelay(relayStore, workId) ?? abandonedRelay ?? relay, tabSettlement },
             }) as unknown as Record<string, unknown>);
           } catch (error) {
             return result(buildFacadeResult({ status: 'blocked', summary: error instanceof Error ? error.message : 'Controller release failed.', data: {} }) as unknown as Record<string, unknown>, true);
@@ -4576,57 +4342,46 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
         };
 
         if (operation === 'requirement_create') {
-          const requirementId = typeof args.requirement_id === 'string' ? args.requirement_id.trim() : '';
-          const title = typeof args.requirement_title === 'string' ? args.requirement_title.trim().slice(0, 500) : '';
-          const outcomeStatement = typeof args.requirement_outcome === 'string' ? args.requirement_outcome.trim().slice(0, 2_000) : '';
-          const acceptanceCriteria = Array.isArray(args.requirement_acceptance_criteria)
-            ? args.requirement_acceptance_criteria.map((value) => String(value).trim()).filter(Boolean).slice(0, 50).map((value) => value.slice(0, 500))
-            : [];
-          const requiredDeliveryReferences = Array.isArray(args.requirement_delivery_references)
-            ? args.requirement_delivery_references.map((value) => String(value).trim()).filter(Boolean).slice(0, 50).map((value) => value.slice(0, 500))
-            : [];
-          const legacyAliases = Array.isArray(args.requirement_legacy_aliases)
-            ? args.requirement_legacy_aliases.map((value) => String(value).trim()).filter(Boolean).slice(0, 20).map((value) => value.slice(0, 160))
-            : [];
-          if (!requirementId || !title || !outcomeStatement) {
+          const requirementId = typeof args.requirement_id === 'string' ? args.requirement_id : '';
+          const title = typeof args.requirement_title === 'string' ? args.requirement_title : '';
+          const outcomeStatement = typeof args.requirement_outcome === 'string' ? args.requirement_outcome : '';
+          if (!requirementId.trim() || !title.trim() || !outcomeStatement.trim()) {
             return result(buildFacadeResult({
               status: 'blocked',
               summary: 'REQUIREMENT_CREATE_INPUT_REQUIRED: requirement_id, requirement_title, and requirement_outcome are required.',
               data: { requirementCreated: false },
             }) as unknown as Record<string, unknown>, true);
           }
-          const existing = readRequirement({ controllerHome: ctx.controllerHome }, requirementId)?.value;
-          if (existing) {
-            const identical = existing.title === title
-              && existing.outcomeStatement === outcomeStatement
-              && JSON.stringify(existing.acceptanceCriteria) === JSON.stringify(acceptanceCriteria)
-              && JSON.stringify(existing.requiredDeliveryReferences) === JSON.stringify(requiredDeliveryReferences)
-              && JSON.stringify(existing.legacyAliases) === JSON.stringify(legacyAliases);
-            if (!identical) {
-              return result(buildFacadeResult({
-                status: 'blocked',
-                summary: `REQUIREMENT_ALREADY_EXISTS_CONFLICT: ${requirementId}. Existing Requirement authority was not changed.`,
-                data: { requirement: existing, requirementCreated: false, admissionDecision: 'existing_conflict' },
-                suggestedNextActions: [],
-              }) as unknown as Record<string, unknown>, true);
-            }
+          let admission;
+          try {
+            admission = admitRequirement({ controllerHome: ctx.controllerHome }, {
+              requirementId,
+              title,
+              outcomeStatement,
+              acceptanceCriteria: Array.isArray(args.requirement_acceptance_criteria) ? args.requirement_acceptance_criteria.map(String) : [],
+              requiredDeliveryReferences: Array.isArray(args.requirement_delivery_references) ? args.requirement_delivery_references.map(String) : [],
+              legacyAliases: Array.isArray(args.requirement_legacy_aliases) ? args.requirement_legacy_aliases.map(String) : [],
+            });
+          } catch (error) {
+            return result(buildFacadeResult({
+              status: 'blocked',
+              summary: error instanceof Error ? error.message : String(error),
+              data: { requirementCreated: false },
+            }) as unknown as Record<string, unknown>, true);
+          }
+          if (admission.decision === 'existing_conflict') {
             return result(buildFacadeResult({
-              summary: `REQUIREMENT_AUTHORITY_REUSED: ${requirementId}. Requirement authority does not imply a Plan; Controller chooses the next action.`,
-              data: { requirement: existing, requirementCreated: false, admissionDecision: 'reuse_existing' },
+              status: 'blocked',
+              summary: `REQUIREMENT_ALREADY_EXISTS_CONFLICT: ${admission.requirement.requirementId}. Existing Requirement authority was not changed.`,
+              data: { requirement: admission.requirement, requirementCreated: false, admissionDecision: admission.decision },
               suggestedNextActions: [],
-            }) as unknown as Record<string, unknown>);
+            }) as unknown as Record<string, unknown>, true);
           }
-          const requirement = createRequirement({ controllerHome: ctx.controllerHome }, {
-            requirementId,
-            title,
-            outcomeStatement,
-            acceptanceCriteria,
-            requiredDeliveryReferences,
-            legacyAliases,
-          });
           return result(buildFacadeResult({
-            summary: `Requirement ${requirementId} created. Requirement authority does not imply a Plan; Controller chooses the next action.`,
-            data: { requirement, requirementCreated: true, admissionDecision: 'created' },
+            summary: admission.decision === 'created'
+              ? `Requirement ${admission.requirement.requirementId} created. Requirement authority does not imply a Plan; Controller chooses the next action.`
+              : `REQUIREMENT_AUTHORITY_REUSED: ${admission.requirement.requirementId}. Requirement authority does not imply a Plan; Controller chooses the next action.`,
+            data: { requirement: admission.requirement, requirementCreated: admission.created, admissionDecision: admission.decision },
             suggestedNextActions: [],
           }) as unknown as Record<string, unknown>);
         }
@@ -4635,6 +4390,7 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
           try {
             if (operation === 'plan_create') {
               const rawSteps = Array.isArray(args.plan_steps) ? args.plan_steps : [];
+              const requestedPlanId = String(args.plan_id ?? '').trim();
               const requestedRequirementId = typeof args.requirement_id === 'string' && args.requirement_id.trim() ? args.requirement_id.trim() : undefined;
               const requestedPlanRelation: 'extend' | 'parallel' | undefined = args.plan_relation === 'extend' || args.plan_relation === 'parallel'
                 ? args.plan_relation
@@ -4657,16 +4413,43 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
               const renderPlanAdmission = (admission: ReturnType<typeof resolvePlanAdmission>): CallToolResult | undefined => {
                 if (admission.admissionDecision === 'create_new') return undefined;
                 if (admission.reason === 'exact_scope_authority' && admission.plan) {
+                  const exactDraftRepair = admission.plan.status === 'draft' && requestedPlanId === admission.plan.planId;
                   const facade = buildFacadeResult({
-                    summary: `PLAN_AUTHORITY_REUSED: active Plan ${admission.plan.planId} already owns scope ${admission.normalizedScopeKey}; no duplicate draft was created.`,
+                    summary: exactDraftRepair
+                      ? `PLAN_DRAFT_REPAIR_REQUIRED: draft Plan ${admission.plan.planId} already owns scope ${admission.normalizedScopeKey}; preserve that authority and amend it through rh_work repair.`
+                      : `PLAN_AUTHORITY_REUSED: active Plan ${admission.plan.planId} already owns scope ${admission.normalizedScopeKey}; no duplicate draft was created.`,
                     data: {
                       plan: summarizePlanContract(admission.plan),
                       executionStarted: false,
                       planContractCreated: false,
                       admissionDecision: 'reuse_existing',
                       resolutionRequired: false,
+                      ...(exactDraftRepair ? { repairRequired: true } : {}),
                     },
-                    suggestedNextActions: [{ label: 'Read active Plan', tool: 'rh_work', operation: 'plan_get', payload: { plan_id: admission.plan.planId }, risk: 'readonly', confidence: 'high' }],
+                    suggestedNextActions: exactDraftRepair
+                      ? [{
+                          label: 'Repair this exact draft Plan',
+                          tool: 'rh_work',
+                          operation: 'repair',
+                          payload: {
+                            plan_id: admission.plan.planId,
+                            repair_operation: 'repair',
+                            dry_run: false,
+                            scope_key: args.scope_key,
+                            source_revision: args.source_revision,
+                            objective: args.objective,
+                            plan_steps: args.plan_steps,
+                            non_goals: args.non_goals,
+                            assumptions: args.assumptions,
+                            resolved_decisions: args.resolved_decisions,
+                            stop_conditions: args.stop_conditions,
+                            replan_conditions: args.replan_conditions,
+                            integration_strategy: args.integration_strategy,
+                          },
+                          risk: 'workspace_write',
+                          confidence: 'high',
+                        }]
+                      : [{ label: 'Read active Plan', tool: 'rh_work', operation: 'plan_get', payload: { plan_id: admission.plan.planId }, risk: 'readonly', confidence: 'high' }],
                   });
                   return result(facade as unknown as Record<string, unknown>);
                 }
@@ -4828,41 +4611,23 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
 
         if (operation === 'stop') {
           const workId = String(args.work_id ?? '').trim();
-          const currentOwner = workId ? getControllerSession(store, workId) : undefined;
-          let terminalizationAuthority: ControllerTerminalizationAuthority | undefined;
-          if (currentOwner) {
-            try {
-              const identity = authenticatedFacadeControllerIdentity(ctx, args);
-              const ownerPrincipal = currentOwner.principalId?.trim() || currentOwner.controllerId;
-              const ownerInstanceId = currentOwner.controllerInstanceId?.trim() || '';
-              if (currentOwner.controllerId !== identity.controllerId || ownerPrincipal !== identity.principalId) {
-                throw new Error(`WORK_CONTROLLER_OWNER_MISMATCH: ${workId}`);
-              }
-              if (!ownerInstanceId || ownerInstanceId !== identity.controllerInstanceId) {
-                throw new Error(`WORK_CONTROLLER_INSTANCE_MISMATCH: ${workId}`);
-              }
-              if (typeof currentOwner.claimGeneration !== 'number' || currentOwner.claimGeneration < 1) {
-                throw new Error(`WORK_CONTROLLER_CLAIM_GENERATION_REQUIRED: ${workId}`);
-              }
-              terminalizationAuthority = {
-                controllerId: currentOwner.controllerId,
-                controllerType: currentOwner.controllerType,
-                principalId: ownerPrincipal,
-                controllerInstanceId: ownerInstanceId,
-                claimGeneration: currentOwner.claimGeneration,
-              };
-            } catch (error) {
-              const blocked = buildFacadeResult({
-                status: 'blocked',
-                summary: error instanceof Error ? error.message : `Work ${workId} terminalization authority check failed.`,
-                data: { workId, terminalizationApplied: false },
-              });
-              return result(blocked as unknown as Record<string, unknown>, true);
-            }
-          } else if (!['user', 'system'].includes(String(args.requested_by ?? ''))) {
+          try {
+            if (workId) assertFacadeControllerRoundAuthority(ctx, store, workId, args);
+          } catch (error) {
+            const blocked = buildFacadeResult({
+              status: 'blocked',
+              summary: error instanceof Error ? error.message : `Work ${workId} controller-round authority check failed.`,
+              data: { workId, terminalizationApplied: false },
+            });
+            return result(blocked as unknown as Record<string, unknown>, true);
+          }
+          let terminalizationAuthority: ControllerTerminalizationAuthority;
+          try {
+            terminalizationAuthority = currentFacadeTerminalizationAuthority(ctx, store, workId, args);
+          } catch (error) {
             const blocked = buildFacadeResult({
               status: 'blocked',
-              summary: `WORK_CONTROLLER_OWNER_REQUIRED: ${workId}; unclaimed stop requires explicit requested_by=user or requested_by=system authority.`,
+              summary: error instanceof Error ? error.message : `Work ${workId} terminalization authority check failed.`,
               data: { workId, terminalizationApplied: false },
             });
             return result(blocked as unknown as Record<string, unknown>, true);
@@ -4934,13 +4699,41 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
 
         if (operation === 'finalize') {
           const workId = String(args.work_id ?? '').trim();
-          if (workId) reconcileTerminalFacadeWorkVerifications(ctx, repository, workId);
+          try {
+            if (workId) assertFacadeControllerRoundAuthority(ctx, store, workId, args);
+          } catch (error) {
+            const blocked = buildFacadeResult({ status: 'blocked', summary: error instanceof Error ? error.message : `Work ${workId} controller-round authority check failed.`, data: { workId, lifecycleClosed: false } });
+            return result(blocked as unknown as Record<string, unknown>, true);
+          }
+          const finalizeReconciliation = workId
+            ? reconcileTerminalFacadeWorkVerifications(ctx, repository, workId)
+            : undefined;
+          const semanticFinalizeContext = {
+            ...workloopCtx,
+            sourceRevision: finalizeReconciliation?.sourceRevision ?? workloopCtx.sourceRevision ?? undefined,
+            workspaceFingerprint: finalizeReconciliation?.workspaceFingerprint,
+            workspaceChangedPaths: finalizeReconciliation?.workspaceChangedPaths,
+            workBoundProcessEvidenceIds: finalizeReconciliation?.workBoundProcessEvidenceIds,
+          };
           let before = workId ? getWorkContract(store, workId) : undefined;
+          let terminalizationAuthority: ControllerTerminalizationAuthority | undefined;
+          // Finalize may commit, merge, clean resources, and complete the Work.
+          // It therefore shares the same exact-claim authority as stop. Transport
+          // or Runtime recovery remains an explicit controller_claim operation;
+          // terminalization itself must never rebind an unrelated controller scope.
+          if (before && !['completed', 'failed', 'cancelled'].includes(before.status)) {
+            try {
+              terminalizationAuthority = currentFacadeTerminalizationAuthority(ctx, store, workId, args);
+            } catch (error) {
+              const blocked = buildFacadeResult({ status: 'blocked', summary: error instanceof Error ? error.message : `Work ${workId} terminalization authority check failed.`, data: { workId, terminalizationApplied: false, lifecycleClosed: false } });
+              return result(blocked as unknown as Record<string, unknown>, true);
+            }
+          }
           if (before && !before.completionReceipt && args.reconcile_historical_delivery === true) {
             try {
               const identity = authenticatedFacadeControllerIdentity(ctx, args);
               const owner = getControllerSession(store, workId);
-              if (!owner || (owner.principalId?.trim() || owner.controllerId) !== identity.principalId) {
+              if (!owner || (controllerSessionPrincipalId(owner)) !== identity.principalId) {
                 throw new Error(`DIRECT_EDIT_WORK_RECONCILIATION_CONTROLLER_CLAIM_REQUIRED: ${workId}`);
               }
               const historicalHandle = readWorkHandle(ctx.controllerHome, repository.repoId, workId);
@@ -4973,31 +4766,60 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
                   : transitionWorkHandle(ctx.controllerHome, historicalHandle, 'committed', { expectedHead: reconciliation.receipt.targetRevision, finalization, failureReason: undefined });
                 transitionWorkHandle(ctx.controllerHome, delivered, 'cleaned', { expectedHead: reconciliation.receipt.targetRevision, finalization, failureReason: undefined });
               }
-              releaseControllerSession(store, workId, owner.controllerId);
+              const released = releaseObservedControllerSession(store, {
+                workId,
+                actor: `direct-edit-reconciliation:${identity.principalId}`,
+                owner,
+              });
+              if (!released.allowed) {
+                throw new Error(`DIRECT_EDIT_WORK_RECONCILIATION_CONTROLLER_RELEASE_FENCED: ${workId}:${released.reason}`);
+              }
               before = getWorkContract(store, workId);
             } catch (error) {
               const blocked = buildFacadeResult({ status: 'blocked', summary: error instanceof Error ? error.message : 'Historical Work delivery reconciliation failed.', data: { workId, lifecycleClosed: false } });
               return result(blocked as unknown as Record<string, unknown>, true);
             }
           }
-          // Legacy callers could classify repository mutation + Git remote delivery
-          // as remote_effect. A physical WorkHandle proves this is repository delivery,
-          // so keep it on work_finalize instead of demanding a plugin action receipt.
-          // Pure plugin remote effects have no repository WorkHandle and retain the
-          // action-receipt finalization contract.
           const repositoryDeliveryHandle = workId
             ? readWorkHandle(ctx.controllerHome, repository.repoId, workId)
             : undefined;
-          if (before?.workKind === 'remote_effect' && !before.completionReceipt && !repositoryDeliveryHandle) {
+          const effectHasRepositoryDelta = Boolean(
+            before
+            && ['local_effect', 'remote_effect'].includes(before.workKind)
+            && (
+              (repositoryDeliveryHandle && repositoryWorkHandleHasSourceDelta(repository, repositoryDeliveryHandle))
+              || (finalizeReconciliation?.workspaceChangedPaths?.length ?? 0) > 0
+            )
+          );
+          if (effectHasRepositoryDelta && !repositoryDeliveryHandle) {
+            const blocked = buildFacadeResult({
+              status: 'blocked',
+              summary: `WORK_EFFECT_REPOSITORY_DELIVERY_HANDLE_REQUIRED: ${workId} has repository source delta and cannot use effect-only terminalization without a physical WorkHandle.`,
+              data: { workId, lifecycleClosed: false },
+            });
+            return result(blocked as unknown as Record<string, unknown>, true);
+          }
+          // Pure remote effects may complete from either the canonical plugin
+          // action receipt or the deliberately narrow trusted repository
+          // Process authority (`git push` + exact remote lease). A remote_effect
+          // that acquired source delta is no longer pure and must use physical
+          // repository delivery instead.
+          if (before?.workKind === 'remote_effect' && !before.completionReceipt && !effectHasRepositoryDelta) {
             try {
               before = finalizeRemoteEffectWorkFromActionReceipt(ctx.controllerHome, repository.repoId, workId);
-            } catch (error) {
-              const blocked = buildFacadeResult({
-                status: 'blocked',
-                summary: error instanceof Error ? error.message : 'Remote-effect semantic finalization failed.',
-                data: { workId, lifecycleClosed: false },
-              });
-              return result(blocked as unknown as Record<string, unknown>, true);
+            } catch (pluginError) {
+              const checkoutId = before.checkoutId ?? repositoryDeliveryHandle?.checkoutId ?? repository.activeCheckoutId;
+              const processCompleted = finalizeRemoteEffectWorkFromRepositoryProcessReceipt(ctx, repository, workId, checkoutId);
+              if (processCompleted) {
+                before = processCompleted;
+              } else {
+                const blocked = buildFacadeResult({
+                  status: 'blocked',
+                  summary: pluginError instanceof Error ? pluginError.message : 'Remote-effect semantic finalization failed.',
+                  data: { workId, lifecycleClosed: false },
+                });
+                return result(blocked as unknown as Record<string, unknown>, true);
+              }
             }
           }
           const completedCleanupPending = Boolean(
@@ -5006,7 +4828,15 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
             && before.worktreeRef?.trim()
             && existsSync(before.worktreeRef),
           );
-          if (before && before.workKind !== 'local_effect' && (!before.completionReceipt || completedCleanupPending)) {
+          const repositoryDeliveryRequired = Boolean(
+            before
+            && before.workKind !== 'read_only_review'
+            && (
+              !['local_effect', 'remote_effect'].includes(before.workKind)
+              || effectHasRepositoryDelta
+            )
+          );
+          if (before && ((repositoryDeliveryRequired && !before.completionReceipt) || completedCleanupPending)) {
             try {
               const physical = await finalizeFacadeWorkHandle(ctx, repository, args, 'finalize');
               if (physical?.isError === true) return physical;
@@ -5025,40 +4855,15 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
           let facade;
           if (semanticWork && !['completed', 'failed', 'cancelled'].includes(semanticWork.status)) {
             try {
-              const identity = authenticatedFacadeControllerIdentity(ctx, args);
-              let owner = getControllerSession(store, workId);
-              if (!owner) {
-                owner = claimControllerSession(store, {
-                  workId,
-                  controllerId: identity.controllerId,
-                  controllerType: identity.controllerType,
-                  sessionId: identity.sessionId,
-                  principalId: identity.principalId,
-                  controllerInstanceId: identity.controllerInstanceId,
-                  expectedClaimGeneration: 0,
-                  leaseMs: 3_600_000,
-                });
-              }
-              const ownerPrincipal = owner.principalId?.trim() || owner.controllerId;
-              const ownerInstanceId = owner.controllerInstanceId?.trim() || '';
-              if (owner.controllerId !== identity.controllerId) throw new Error(`WORK_CONTROLLER_OWNER_MISMATCH: ${workId}`);
-              if (ownerPrincipal !== identity.principalId) throw new Error(`WORK_CONTROLLER_PRINCIPAL_MISMATCH: ${workId}`);
-              if (!ownerInstanceId || ownerInstanceId !== identity.controllerInstanceId) throw new Error(`WORK_CONTROLLER_INSTANCE_MISMATCH: ${workId}`);
-              if (typeof owner.claimGeneration !== 'number' || owner.claimGeneration < 1) throw new Error(`WORK_CONTROLLER_CLAIM_GENERATION_REQUIRED: ${workId}`);
+              const authority = terminalizationAuthority ?? currentFacadeTerminalizationAuthority(ctx, store, workId, args);
               const fenced = withControllerSessionTerminalizationFence(
                 store,
                 {
                   workId,
-                  actor: `rh-work-finalize:${identity.controllerId}:${identity.controllerInstanceId}`,
-                  authority: {
-                    controllerId: owner.controllerId,
-                    controllerType: owner.controllerType,
-                    principalId: ownerPrincipal,
-                    controllerInstanceId: ownerInstanceId,
-                    claimGeneration: owner.claimGeneration,
-                  },
+                  actor: `rh-work-finalize:${authority.controllerId}:${authority.controllerInstanceId}`,
+                  authority,
                 },
-                () => runGoalWorkloop({ ...workloopCtx, sourceRevision: workloopCtx.sourceRevision ?? undefined }, 'finalize', args),
+                () => runGoalWorkloop(semanticFinalizeContext, 'finalize', args),
               );
               if (!fenced.allowed) {
                 throw new Error(`WORK_TERMINALIZATION_AUTHORITY_FENCED: ${workId}:${fenced.reason}`);
@@ -5073,9 +4878,29 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
               return result(blocked as unknown as Record<string, unknown>, true);
             }
           } else {
-            facade = runGoalWorkloop({ ...workloopCtx, sourceRevision: workloopCtx.sourceRevision ?? undefined }, 'finalize', args);
+            facade = runGoalWorkloop(semanticFinalizeContext, 'finalize', args);
+          }
+          let completed = getWorkContract(store, workId);
+          const postSemanticCleanupPending = Boolean(
+            completed?.completionReceipt
+            && args.cleanup !== false
+            && completed.worktreeRef?.trim()
+            && existsSync(completed.worktreeRef),
+          );
+          if (postSemanticCleanupPending) {
+            try {
+              const physical = await finalizeFacadeWorkHandle(ctx, repository, { ...args, commit: false, merge: false }, 'finalize');
+              if (physical?.isError === true) return physical;
+              completed = getWorkContract(store, workId);
+            } catch (error) {
+              const blocked = buildFacadeResult({
+                status: 'blocked',
+                summary: error instanceof Error ? error.message : `Work ${workId} terminal cleanup reconciliation failed.`,
+                data: { workId, terminalizationApplied: true, lifecycleClosed: false },
+              });
+              return result(blocked as unknown as Record<string, unknown>, true);
+            }
           }
-          const completed = getWorkContract(store, workId);
           // Finalizing a Work proves the Work lifecycle only. A Plan step may aggregate
           // acceptance criteria that are broader than this Work (for example, a canary
           // plus a later stabilization soak), so finalize must never synthesize semantic
@@ -5100,12 +4925,23 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
         let continuationSourceRevision = workloopCtx.sourceRevision;
         let continuationWorkspaceFingerprint: string | undefined;
         let continuationWorkspaceChangedPaths: string[] | undefined;
+        let continuationWorkBoundProcessEvidenceIds: string[] | undefined;
         if (operation === 'continue') {
           try {
             const workId = String(args.work_id ?? '').trim();
+            if (workId) assertFacadeControllerRoundAuthority(ctx, store, workId, args);
             let work = getWorkContract(store, workId);
             if (work?.status === 'cancelled') {
-              const resumed = reauthorizeCancelledFacadeWork(ctx, repository, workId, args);
+              const identity = authenticatedFacadeControllerIdentity(ctx, args);
+              const resumed = reauthorizeRetainedCancelledRepositoryWork({
+                controllerHome: ctx.controllerHome,
+                repository,
+                workId,
+                identity,
+                requestedBy: typeof args.requested_by === 'string' ? args.requested_by : undefined,
+                approvalConfirmed: args.approval_confirmed === true,
+                prepareDependencies: args.needs_dependencies === true,
+              });
               cancelledWorkReauthorized = true;
               reconstructedCancelledCheckout = resumed.reconstructedCheckout;
               work = getWorkContract(store, workId);
@@ -5121,14 +4957,12 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
                 controllerInstanceId: identity.controllerInstanceId,
                 leaseMs: 3_600_000,
               });
-              const existingHandle = readWorkHandle(ctx.controllerHome, repository.repoId, workId);
-              if (existingHandle && (existingHandle.principalId !== identity.principalId || existingHandle.sessionId !== identity.sessionId)) {
-                writeWorkHandle(ctx.controllerHome, {
-                  ...existingHandle,
-                  principalId: identity.principalId,
-                  sessionId: identity.sessionId,
-                });
-              }
+              rebindRepositoryWorkHandleControllerIdentity({
+                controllerHome: ctx.controllerHome,
+                repositoryId: repository.repoId,
+                workId,
+                identity: { sessionId: identity.sessionId, principalId: identity.principalId },
+              });
               if (work.worktreePolicy.required === true && !work.worktreeRef) {
                 materializeFacadeWorkPlacement(ctx, repository, workId, args);
               }
@@ -5138,6 +4972,7 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
               continuationSourceRevision = reconciled.sourceRevision ?? continuationSourceRevision;
               continuationWorkspaceFingerprint = reconciled.workspaceFingerprint ?? continuationWorkspaceFingerprint;
               continuationWorkspaceChangedPaths = reconciled.workspaceChangedPaths ?? continuationWorkspaceChangedPaths;
+              continuationWorkBoundProcessEvidenceIds = reconciled.workBoundProcessEvidenceIds;
             }
           } catch (error) {
             const facade = buildFacadeResult({ status: 'blocked', summary: error instanceof Error ? error.message : 'Controller resume failed.', data: { operation, executionStarted: false, ownershipResumed: false } });
@@ -5157,6 +4992,7 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
           sourceRevision: continuationSourceRevision ?? undefined,
           workspaceFingerprint: continuationWorkspaceFingerprint,
           workspaceChangedPaths: continuationWorkspaceChangedPaths,
+          workBoundProcessEvidenceIds: continuationWorkBoundProcessEvidenceIds,
           semanticAdmissionLocked: semanticAdmissionRequired,
         };
         const facade = semanticAdmissionRequired
@@ -6130,8 +5966,7 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
           ? selected(ctx, args)
           : (ctx.explicitRepository ?? (registered.length === 1 ? registered[0] : undefined));
         const readiness = await controllerReadiness(ctx, repository);
-        const toolset = await import('../../../cli/mcp/toolset');
-        const exposure = toolset.controllerExposureSnapshot(ctx);
+        const exposure = controllerExposureSnapshot(ctx);
         const toolSurfaceReady = exposure.ready && exposure.missingToolNames.length === 0;
         const reasonCodes = new Set(readiness.reasonCodes);
         if (!toolSurfaceReady) reasonCodes.add('MCP_TOOL_SURFACE_INCOMPLETE');
@@ -6511,52 +6346,14 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
         return result(buildWorkflowWatchdogReport(ctx.controllerHome, repository, { staleMinutes: args.stale_minutes, includeProcesses: args.include_processes }) as unknown as Record<string, unknown>);
       }
       case 'ios_xcode_status':
-        return legacyIosPluginAction(ctx, name, args, 'xcode_status', {});
       case 'ios_simulators_list':
-        return legacyIosPluginAction(ctx, name, args, 'list_simulators', {
-          runtime: typeof args.runtime === 'string' ? args.runtime : undefined,
-          name: typeof args.name === 'string' ? args.name : undefined,
-        });
       case 'ios_project_discover':
-        return legacyIosPluginAction(ctx, name, args, 'discover_project', {});
       case 'ios_schemes_list':
-        return legacyIosPluginAction(ctx, name, args, 'list_schemes', {
-          workspace: typeof args.workspace === 'string' ? args.workspace : undefined,
-          project: typeof args.project === 'string' ? args.project : undefined,
-        });
       case 'ios_simulator_boot':
-        return legacyIosPluginAction(ctx, name, args, 'launch_simulator', {
-          udid: String(args.udid ?? '').trim(),
-          open_simulator: args.open_simulator !== false,
-          timeout_ms: typeof args.timeout_ms === 'number' ? args.timeout_ms : undefined,
-        });
       case 'ios_app_build':
-        return legacyIosPluginAction(ctx, name, args, 'build', {
-          scheme: String(args.scheme ?? '').trim(),
-          udid: typeof args.udid === 'string' ? args.udid : undefined,
-          simulator_name: typeof args.simulator_name === 'string' ? args.simulator_name : undefined,
-          workspace: typeof args.workspace === 'string' ? args.workspace : undefined,
-          project: typeof args.project === 'string' ? args.project : undefined,
-          configuration: typeof args.configuration === 'string' ? args.configuration : undefined,
-          timeout_ms: typeof args.timeout_ms === 'number' ? args.timeout_ms : undefined,
-        });
       case 'ios_simulator_screenshot':
-        return legacyIosPluginAction(ctx, name, args, 'capture_screenshot', {
-          udid: String(args.udid ?? '').trim(),
-          label: typeof args.label === 'string' ? args.label : undefined,
-        });
       case 'ios_ui_smoke_test':
-        return legacyIosPluginAction(ctx, name, args, 'smoke_review', {
-          scheme: typeof args.scheme === 'string' ? args.scheme : undefined,
-          bundle_id: typeof args.bundle_id === 'string' ? args.bundle_id : undefined,
-          udid: typeof args.udid === 'string' ? args.udid : undefined,
-          simulator_name: typeof args.simulator_name === 'string' ? args.simulator_name : undefined,
-          workspace: typeof args.workspace === 'string' ? args.workspace : undefined,
-          project: typeof args.project === 'string' ? args.project : undefined,
-          configuration: typeof args.configuration === 'string' ? args.configuration : undefined,
-          app_path: typeof args.app_path === 'string' ? args.app_path : undefined,
-          screenshot_label: typeof args.screenshot_label === 'string' ? args.screenshot_label : undefined,
-        });
+        return legacyIosPluginAction(ctx, name, args);
       case 'ios_app_install':
       case 'ios_app_launch':
       case 'ios_simulator_log_tail':
@@ -6595,7 +6392,9 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
       }
       case 'plugin_action_execute': {
         const pluginId = String(args.plugin_id ?? '').trim();
+        const workId = typeof args.work_id === 'string' && args.work_id.trim() ? args.work_id.trim() : undefined;
         const repository = pluginRepository(ctx, args, pluginId);
+        const workRepository = workId ? selected(ctx, args) : undefined;
         const actionId = String(args.action_id ?? '').trim();
         const requestId = String(args.request_id ?? '').trim();
         const actionArguments = args.arguments && typeof args.arguments === 'object' && !Array.isArray(args.arguments)
@@ -6605,7 +6404,8 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
           pluginId,
           actionId,
           requestId,
-          workId: typeof args.work_id === 'string' && args.work_id.trim() ? args.work_id.trim() : undefined,
+          workId,
+          ...(workId && workRepository ? { workRepoId: workRepository.repoId } : {}),
           args: actionArguments,
           timeoutMs: typeof args.timeout_ms === 'number' ? args.timeout_ms : undefined,
           signal: ctx.signal,