@moretea-labs/forge 1.8.1 → 1.8.2

package/adapters/mcp/runtime-gateway/work-adapter.ts

@@ -5,6 +5,7 @@ import { listControllerChecks } from '../../../src/cli/controller/check-runner';
 import { repositoryGitStatus } from '../../../src/cli/repositories/structured-git';
 import { getWorkContract, updateWorkContract, workSemanticView } from '../../../packages/kernel/work/api/index';
 import { ensureRepositoryWorkHandle } from '../../../src/runtime/control-plane/execution/work-handle-authority';
+import { readWorkHandle } from '../../../src/runtime/control-plane/execution/work-handle-store';
 import { ensureManagedWorkspace } from '../../../src/runtime/execution/managed-workspace';
 import { ensureRepositoryProjectOnboarding } from '../../../src/runtime/control-plane/workspace/project-onboarding';
 import { buildFacadeResult } from '../../../src/runtime/control-plane/facade';
@@ -16,7 +17,7 @@ import { invalidFacadeOperation } from './status-inbox-adapter';
 import { normalizeRhWorkInputWireMigration } from './work-input-wire-migration';
 import { callRhWorkScheduleAdapter, isRhWorkScheduleOperation } from './scheduler-adapter';
 import { callRhWorkRequirementOperation, isRhWorkRequirementOperation } from './work-requirement-operations';
-import { callRhWorkSemanticOperation, semanticWorkId } from './work-semantic-operations';
+import { buildWorkSemanticFacadeResult, callRhWorkSemanticOperation, semanticWorkId } from './work-semantic-operations';
 import { callRhWorkListProjection } from './work-list-projection';
 import {
   callRhWorkPlanCreateOperation,
@@ -27,7 +28,6 @@ import { callRhWorkWorkflowOperation } from './work-workflow-operations';
 import { callRhWorkLearningOperation } from './work-learning-operations';
 import { callRhWorkControllerOperation } from './work-controller-operations';
 import { runFacadeRepair } from './work-repair-adapter';
-import { isAutomationReceiptCompatibilityCall } from './automation-receipt-adapter';
 import { authenticatedFacadeControllerIdentity } from './controller-authority-adapter';
 
 export { runFacadeRepair };
@@ -79,12 +79,19 @@ async function callRepositoryBoundStart(
 
   try {
     const rawConstraints = contextRecord(args.constraints);
-    // Placement is caller-owned. Legacy `auto` is a stable mechanical spelling
-    // of the durable-Work isolated/frozen-base default; it never inspects dirty
-    // paths, risk, task text, or other semantic context to choose topology.
-    const requestedWorkspaceMode: 'current' | 'isolated' = rawConstraints.workspace_mode === 'isolated' || rawConstraints.workspace_mode === 'auto'
-      ? 'isolated'
-      : 'current';
+    // Placement is caller-owned. Omitted placement and legacy `auto` are the
+    // stable mechanical spelling of the durable-Work isolated/frozen-base default;
+    // only explicit `current` may reuse the selected canonical checkout.
+    const requestedWorkspaceMode: 'current' | 'isolated' = rawConstraints.workspace_mode === 'current'
+      ? 'current'
+      : 'isolated';
+    const existingHandle = readWorkHandle(ctx.controllerHome, repository.repoId, workId);
+    if (existingHandle) {
+      const existingWorkspaceMode = existingHandle.managedWorktree ? 'isolated' : 'current';
+      if (existingWorkspaceMode !== requestedWorkspaceMode) {
+        throw new Error(`WORK_REPOSITORY_ADMISSION_PLACEMENT_CONFLICT: ${workId}; existing=${existingWorkspaceMode}; requested=${requestedWorkspaceMode}`);
+      }
+    }
     const sourceStatus = repositoryGitStatus(repository);
     const requestedSourceRevision = typeof args.source_revision === 'string' ? args.source_revision.trim() : '';
     if (requestedSourceRevision && sourceStatus.head && requestedWorkspaceMode !== 'isolated' && requestedSourceRevision !== sourceStatus.head) {
@@ -137,7 +144,7 @@ async function callRepositoryBoundStart(
       repository,
       sourceRevision: baseRevision,
     });
-    return result(buildFacadeResult({
+    return result(buildWorkSemanticFacadeResult({
       summary: `Work ${workId} admitted to repository execution on checkout ${checkoutId}.`,
       data: {
         work: workSemanticView(contract),
@@ -257,13 +264,6 @@ export async function callWorkAdapter(
   const operation = wireMigration.operation;
   if (!isRhWorkAcceptedOperation(operation)) return invalidFacadeOperation('rh_work', operation);
 
-  if (operation === 'repair' && isAutomationReceiptCompatibilityCall(args)) {
-    return result(buildFacadeResult({
-      summary: 'Workflow Supervisor automation receipt accepted for canonical persistence.',
-      data: { automationReceiptCompatibility: true },
-    }) as unknown as Record<string, unknown>);
-  }
-
   if (isRhWorkRequirementOperation(operation) && operation !== 'requirement_promote_candidate') {
     const requirement = await callRhWorkRequirementOperation(ctx, undefined, operation, args);
     if (requirement) return requirement;

package/adapters/mcp/runtime-gateway/work-input-wire-migration.ts

@@ -1,5 +1,4 @@
 import { isDeepStrictEqual } from 'node:util';
-import { AUTOMATION_RECEIPT_CAPABILITY_PREFIX } from './automation-receipt-adapter';
 
 export type RhWorkInputWireMigrationResult =
   | {
@@ -220,22 +219,6 @@ export function normalizeRhWorkInputWireMigration(input: Record<string, unknown>
     return translateFrozenSemanticV1(args, parsed.value);
   }
 
-  if (capabilityId.startsWith(AUTOMATION_RECEIPT_CAPABILITY_PREFIX)) {
-    // Frozen clients attach ordinary repository context and a reason. These are
-    // transport annotations, never receipt/task/effect authority. Strip them;
-    // the canonical Supervisor derives all causal identity from its own journal.
-    const allowed = new Set(['operation', 'capability_id', 'repo_id', 'checkout_id', 'reason']);
-    const unsupported = unsupportedInputField(args, allowed);
-    if (unsupported) return failure('FROZEN_MCP_AUTOMATION_RECEIPT_FIELD_UNSUPPORTED', { field: unsupported });
-    if (requestedOperation !== 'repair') return failure('FROZEN_MCP_AUTOMATION_RECEIPT_OPERATION_INVALID', { operation: requestedOperation });
-    for (const field of ['repo_id', 'checkout_id', 'reason']) {
-      if (args[field] !== undefined && (typeof args[field] !== 'string' || (args[field] as string).length > 2_000)) {
-        return failure('FROZEN_MCP_AUTOMATION_RECEIPT_FIELD_INVALID', { field });
-      }
-    }
-    return { ok: true, args: { operation: 'repair', capability_id: capabilityId }, operation: 'repair' };
-  }
-
   if (capabilityId.includes(':')) {
     return failure('FROZEN_MCP_LIFECYCLE_REMOVED: only bounded semantic.v1 and current-conversation enrollment carriers remain supported.', {
       carrier: capabilityId.slice(0, capabilityId.indexOf(':')),

package/adapters/mcp/runtime-gateway/work-semantic-operations.ts

@@ -12,7 +12,7 @@ import {
   semanticWorkState,
   type WorkContractStoreOptions,
 } from '../../../packages/kernel/work/api/index';
-import { buildFacadeResult } from '../../../src/runtime/control-plane/facade';
+import { buildFacadeResult, type BuildFacadeResultOptions } from '../../../src/runtime/control-plane/facade';
 import { getPlanContract, currentPlanSemanticRevision, getPlanSemanticRevisionRecord, planSemanticView } from '../../../src/runtime/control-plane/facade/plan-contract-store';
 import { readRequirement, currentRequirementSemanticRevision, getRequirementRevisionRecord, requirementSemanticView } from '../../../src/runtime/control-plane/persistence/requirement-store';
 import { buildWorkContinuationSnapshot } from '../../../src/runtime/control-plane/facade/work-continuation';
@@ -21,8 +21,61 @@ import { projectWorkExecutionEvidence } from './work-detail-projection';
 import { readWorkHandle } from '../../../src/runtime/control-plane/execution/work-handle-store';
 import { reconcileSingleTerminalWorkCleanup } from '../../../src/runtime/control-plane/execution/work-terminal-cleanup';
 
+import { existsSync } from 'node:fs';
+import { getWorkflowSupervisorTask, stopWorkflowSupervisorTask } from '../../../supervisor/client';
+import { workflowSupervisorSocketPath } from '../../../supervisor/paths';
+
+async function stopTerminalWorkSupervisor(
+  options: WorkContractStoreOptions,
+  workId: string,
+  state: 'completed' | 'cancelled',
+): Promise<{ status: 'stopped' | 'already_terminal' | 'not_enrolled' | 'pending_reconcile'; reason?: string }> {
+  const controllerHome = options.controllerHome;
+  const repoId = options.repoId?.trim();
+  if (!controllerHome || !repoId || !existsSync(workflowSupervisorSocketPath(controllerHome))) {
+    return { status: 'pending_reconcile', reason: 'Supervisor socket unavailable; native consumer will reconcile terminal Work on restart.' };
+  }
+  const taskId = `forge:${repoId}:work:${workId}`;
+  try {
+    const task = await getWorkflowSupervisorTask(controllerHome, taskId);
+    if (!task) return { status: 'not_enrolled' };
+    // Fail closed: an unrelated Requirement/standalone Goal must never be
+    // stopped by a lower-layer Work transition.
+    if (task.taskId !== taskId || task.completionContract?.work_id !== workId
+      || task.completionContract?.repo_id !== repoId
+      || task.continuationPolicy.kind === 'standalone_supervisor') {
+      return { status: 'pending_reconcile', reason: 'Supervisor task contract is not exact Work-owned.' };
+    }
+    const stopped = await stopWorkflowSupervisorTask(controllerHome, taskId, `Work ${workId} changed to ${state}; its exact Work-owned automatic continuation is closed.`);
+    return { status: stopped.deduplicated ? 'already_terminal' : 'stopped' };
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    const code = reason.split(':', 1)[0]?.trim();
+    if (code === 'WORKFLOW_SUPERVISOR_TASK_UNKNOWN') return { status: 'not_enrolled' };
+    if (code === 'WORKFLOW_SUPERVISOR_TASK_TERMINAL') return { status: 'already_terminal' };
+    return { status: 'pending_reconcile', reason };
+  }
+}
+
 const RH_WORK_SEMANTIC_OPERATIONS = new Set(['start', 'get', 'revise', 'complete']);
 
+type WorkSemanticFacadeData = Record<string, unknown> & {
+  work?: ReturnType<typeof workSemanticView>;
+  currentWork?: ReturnType<typeof workSemanticView>;
+  revisionHistory?: ReturnType<typeof listWorkSemanticRevisionRecords>;
+};
+
+export function buildWorkSemanticFacadeResult(options: BuildFacadeResultOptions<WorkSemanticFacadeData>) {
+  const facade = buildFacadeResult(options);
+  // These authored projections already have domain limits. Generic diagnostic
+  // clipping corrupts their read/revise round trip (100 refs become 50, and a
+  // valid objective becomes an ellipsis). Keep execution diagnostics bounded.
+  if (options.data.work) facade.data.work = options.data.work;
+  if (options.data.currentWork) facade.data.currentWork = options.data.currentWork;
+  if (options.data.revisionHistory) facade.data.revisionHistory = options.data.revisionHistory;
+  return facade;
+}
+
 /** Resolve semantic version references against existing canonical heads/history. */
 function workBasis(store: WorkContractStoreOptions, x: { requirementId?: string; requirementRevision?: number; planId?: string; planRevision?: number }) {
   const plan = x.planId ? getPlanContract(store, x.planId) : undefined;
@@ -118,18 +171,18 @@ export async function callRhWorkSemanticOperation(
   const workId = operation === 'start' ? semanticWorkId(store, args) : String(args.work_id ?? '').trim();
   if (operation === 'start') {
     const objective = String(args.objective ?? '').trim();
-    if (!objective) return result(buildFacadeResult({
+    if (!objective) return result(buildWorkSemanticFacadeResult({
       status: 'blocked', summary: 'WORK_OBJECTIVE_REQUIRED', data: { workId },
     }) as unknown as Record<string, unknown>, true);
     const requestId = typeof args.request_id === 'string' ? args.request_id.trim() : '';
     const existing = getWorkContract(store, workId);
     if (existing) {
-      if (!semanticCreateMatches(existing, args, requestId)) return result(buildFacadeResult({
+      if (!semanticCreateMatches(existing, args, requestId)) return result(buildWorkSemanticFacadeResult({
         status: 'blocked',
         summary: `WORK_SEMANTIC_CREATE_CONFLICT: ${workId}`,
         data: { workId, currentWork: workSemanticView(existing) },
       }) as unknown as Record<string, unknown>, true);
-      return result(buildFacadeResult({
+      return result(buildWorkSemanticFacadeResult({
         summary: `Work ${workId} already exists; semantic create was deduplicated.`,
         data: { work: workSemanticView(existing), deduplicated: true },
       }) as unknown as Record<string, unknown>);
@@ -150,17 +203,17 @@ export async function callRhWorkSemanticOperation(
         ...(Array.isArray(args.depends_on_work_ids) ? { dependsOnWorkIds: args.depends_on_work_ids.map(String) } : {}),
         ...(requestId ? { requestId } : {}),
       });
-      return result(buildFacadeResult({
+      return result(buildWorkSemanticFacadeResult({
         summary: `Work ${workId} created as semantic context.`,
         data: { work: workSemanticView(created), deduplicated: false },
       }) as unknown as Record<string, unknown>);
     } catch (error) {
       const raced = getWorkContract(store, workId);
-      if (raced && semanticCreateMatches(raced, args, requestId)) return result(buildFacadeResult({
+      if (raced && semanticCreateMatches(raced, args, requestId)) return result(buildWorkSemanticFacadeResult({
         summary: `Work ${workId} already exists; semantic create was deduplicated.`,
         data: { work: workSemanticView(raced), deduplicated: true },
       }) as unknown as Record<string, unknown>);
-      return result(buildFacadeResult({
+      return result(buildWorkSemanticFacadeResult({
         status: 'blocked',
         summary: error instanceof Error ? error.message : String(error),
         data: { workId },
@@ -169,7 +222,7 @@ export async function callRhWorkSemanticOperation(
   }
   if (operation === 'get') {
     const work = workId ? getWorkContract(store, workId) : undefined;
-    if (!work) return result(buildFacadeResult({
+    if (!work) return result(buildWorkSemanticFacadeResult({
       status: 'not_found', summary: `Work ${workId || '(missing)'} not found.`, data: { workId },
     }) as unknown as Record<string, unknown>, true);
     const semantic = workSemanticView(work);
@@ -180,7 +233,7 @@ export async function callRhWorkSemanticOperation(
       listWorkSemanticRevisionRecords(store, undefined, 200),
       semantic.workId,
     ) : undefined;
-    return result(buildFacadeResult({
+    return result(buildWorkSemanticFacadeResult({
       summary: `Work ${semantic.workId} retrieved at semantic revision ${semantic.revision}.`,
       data: {
         work: semantic,
@@ -222,9 +275,12 @@ export async function callRhWorkSemanticOperation(
       ...(Array.isArray(args.work_result_refs) ? { resultRefs: args.work_result_refs.map(String) } : {}),
     });
     const semantic = workSemanticView(revised);
+    const supervisorClosure = semantic.state !== 'open'
+      ? await stopTerminalWorkSupervisor(store, semantic.workId, semantic.state)
+      : undefined;
     let resourceReconciliation: Awaited<ReturnType<typeof reconcileSingleTerminalWorkCleanup>> | undefined;
     if (
-      operation === 'complete'
+      semantic.state !== 'open'
       && store.controllerHome
       && revised.repoId?.trim()
       && readWorkHandle(store.controllerHome, revised.repoId, revised.workId)
@@ -243,19 +299,20 @@ export async function callRhWorkSemanticOperation(
         };
       }
     }
-    return result(buildFacadeResult({
+    return result(buildWorkSemanticFacadeResult({
       summary: `Work ${semantic.workId} revised atomically to semantic revision ${semantic.revision}.`,
       data: {
         work: semantic,
         expectedRevision,
         semanticRevision: semantic.revision,
         versionBinding: versionBinding(store, revised, false),
+        ...(supervisorClosure ? { supervisorClosure } : {}),
         ...(resourceReconciliation ? { resourceReconciliation } : {}),
       },
     }) as unknown as Record<string, unknown>);
   } catch (error) {
     const current = workId ? getWorkContract(store, workId) : undefined;
-    return result(buildFacadeResult({
+    return result(buildWorkSemanticFacadeResult({
       status: 'blocked', summary: error instanceof Error ? error.message : String(error),
       data: { workId, expectedRevision, ...(current ? { currentWork: workSemanticView(current) } : {}) },
     }) as unknown as Record<string, unknown>, true);

package/adapters/mcp/runtime-gateway/workflow-supervisor-adapter.ts

@@ -5,6 +5,7 @@ import {
   getWorkflowSupervisorTask,
   getWorkflowSupervisorTaskStall,
   listWorkflowSupervisorTasks,
+  listWorkflowSupervisorTerminalTasks,
   migrateWorkflowSupervisorConversation,
   recoverWorkflowSupervisorTask,
   registerWorkflowSupervisorTask,
@@ -13,6 +14,7 @@ import {
   stopWorkflowSupervisorTask,
 } from '../../../supervisor/client';
 import { resolveWorkflowSupervisorForgeHome } from '../../../supervisor/paths';
+import { workflowSupervisorCompletionContractSha256 } from '../../../supervisor/store';
 import type { MultiRepositoryMcpToolContext } from '../multi-repository';
 import { result } from './result-adapter';
 
@@ -40,6 +42,10 @@ export async function callWorkflowSupervisorAdapter(
     const requestId = textArg(args, 'request_id');
     if (!objective) throw new Error('WORKFLOW_SUPERVISOR_OBJECTIVE_REQUIRED');
     if (!requestId) throw new Error('WORKFLOW_SUPERVISOR_REQUEST_ID_REQUIRED');
+    const workId = textArg(args, 'work_id');
+    const requirementId = textArg(args, 'requirement_id');
+    if (workId && requirementId) throw new Error('WORKFLOW_SUPERVISOR_SEMANTIC_BINDING_AMBIGUOUS');
+    if ((workId || requirementId) && !repoId) throw new Error('WORKFLOW_SUPERVISOR_SEMANTIC_BINDING_REPO_REQUIRED');
     const id = standaloneTaskId(repoId, requestId);
     const task = await registerWorkflowSupervisorTask(forgeHome, {
       taskId: id,
@@ -49,6 +55,8 @@ export async function callWorkflowSupervisorAdapter(
       completionContract: {
         kind: 'model_semantic_completion',
         ...(repoId ? { repo_id: repoId, controller_home: ctx.controllerHome } : {}),
+        ...(workId ? { work_id: workId } : {}),
+        ...(requirementId ? { requirement_id: requirementId } : {}),
       },
       continuationPolicy: { kind: 'standalone_supervisor', bootstrap: true, ...(repoId ? { repo_id: repoId } : {}) },
       userBlockerPolicy: { kind: 'model_semantic_user_blocker' },
@@ -58,6 +66,10 @@ export async function callWorkflowSupervisorAdapter(
   }
 
   if (operation === 'list') {
+    if (args.terminal_only === true) {
+      const terminalTasks = await listWorkflowSupervisorTerminalTasks(forgeHome);
+      return result({ terminalTasks, count: terminalTasks.length, terminalOnly: true, summary: `${terminalTasks.length} canonically terminal Supervisor task(s) in retained history; conversations are not archived or deleted.` });
+    }
     const activeOnly = args.active_only !== false;
     const tasks = await listWorkflowSupervisorTasks(forgeHome, activeOnly);
     return result({ tasks, count: tasks.length, activeOnly, summary: `${tasks.length} Supervisor task(s) listed.` });
@@ -67,19 +79,31 @@ export async function callWorkflowSupervisorAdapter(
     const id = textArg(args, 'task_id');
     const objective = textArg(args, 'objective');
     const expectedObjectiveSha256 = textArg(args, 'expected_objective_sha256');
+    const expectedCompletionContractSha256 = textArg(args, 'expected_completion_contract_sha256');
+    const workId = textArg(args, 'work_id');
+    const requirementId = textArg(args, 'requirement_id');
     const requestId = textArg(args, 'request_id');
     if (!id) throw new Error('WORKFLOW_SUPERVISOR_TASK_ID_REQUIRED');
     if (!objective) throw new Error('WORKFLOW_SUPERVISOR_OBJECTIVE_REQUIRED');
     if (!expectedObjectiveSha256) throw new Error('WORKFLOW_SUPERVISOR_OBJECTIVE_REVISION_EXPECTED_SHA_REQUIRED');
     if (!requestId) throw new Error('WORKFLOW_SUPERVISOR_REQUEST_ID_REQUIRED');
+    if (workId && requirementId) throw new Error('WORKFLOW_SUPERVISOR_SEMANTIC_BINDING_TARGET_INVALID');
+    if ((workId || requirementId) && !expectedCompletionContractSha256) throw new Error('WORKFLOW_SUPERVISOR_COMPLETION_CONTRACT_REVISION_EXPECTED_SHA_REQUIRED');
+    if (!(workId || requirementId) && expectedCompletionContractSha256) throw new Error('WORKFLOW_SUPERVISOR_COMPLETION_CONTRACT_REVISION_TARGET_REQUIRED');
     const revised = await reviseWorkflowSupervisorTaskObjective(forgeHome, {
       taskId: id,
       objective,
       expectedObjectiveSha256,
       requestId,
+      ...(workId ? { workId } : {}),
+      ...(requirementId ? { requirementId } : {}),
+      ...(expectedCompletionContractSha256 ? { expectedCompletionContractSha256 } : {}),
       authorizedBy: textArg(args, 'authorized_by') || 'operator',
     });
-    return result({ ...revised, summary: `Supervisor task ${id} objective ${revised.changed ? 'revised' : 'confirmed'} in place.` });
+    const bindingSummary = workId || requirementId
+      ? `; semantic completion binding ${revised.semanticBindingChanged ? 'revised' : 'confirmed'}`
+      : '';
+    return result({ ...revised, summary: `Supervisor task ${id} objective ${revised.changed ? 'revised' : 'confirmed'} in place${bindingSummary}.` });
   }
 
   if (operation === 'stop') {
@@ -138,7 +162,7 @@ export async function callWorkflowSupervisorAdapter(
     // retry/resume budget used to make the task silently leave the delivery
     // queue. The stall state names the exact operator action that can move it.
     const stall = await getWorkflowSupervisorTaskStall(forgeHome, id).catch(() => undefined);
-    return result({ task, ...(stall ? { stall } : {}), summary: `Supervisor task ${id} retrieved${stall ? ` (${stall.state})` : ''}.` });
+    return result({ task, completionContractSha256: workflowSupervisorCompletionContractSha256(task.completionContract), ...(stall ? { stall } : {}), summary: `Supervisor task ${id} retrieved${stall ? ` (${stall.state})` : ''}; canonical completion-contract CAS fingerprint included.` });
   }
 
   if (operation === 'proof') {

package/adapters/mcp/server.ts

@@ -16,7 +16,7 @@ import { callAccessTool } from './tool-mapping/access-tools';
 import { callRepositoryToolWithPostFinalizeAttribution } from './tool-mapping/post-finalize-work-attribution';
 import { callRuntimeTool } from './runtime-gateway/runtime-tools';
 import { callExecutionTool } from './runtime-gateway/execution-tools';
-import { callProcessTool } from './runtime-gateway/process-tools';
+import { callProcessTool, executeAuthorizedHostCommand } from './runtime-gateway/process-tools';
 import { injectDurableCommandFields, isGatewayIsolatedTool, routeDurableMcpCall } from './runtime-gateway/router';
 import { controllerExposureSnapshot, isControllerToolExposed } from './toolset';
 import { settleCognitionAfterTool } from './runtime-gateway/cognition-settlement';
@@ -507,7 +507,7 @@ export function sameCanonicalRuntimeProxyIdentity(
 }
 
 export function canonicalRuntimeToolCallIsReplaySafe(name: string, args: Record<string, unknown>): boolean {
-  if (name !== 'repository_command_execute') return false;
+  if (name !== 'execute_command') return false;
   const workId = typeof args.work_id === 'string' ? args.work_id.trim() : '';
   const requestId = typeof args.request_id === 'string' ? args.request_id.trim() : '';
   return Boolean(workId && requestId);
@@ -1029,7 +1029,7 @@ export function createForgeMcpServerFromContext(
     if (isMultiRepositoryContext(ctx)) {
       const rpcId = handlerContext.mcpReq.id;
       return traceControllerMcpRequest(ctx, name, args, typeof rpcId === 'string' || typeof rpcId === 'number' ? rpcId : undefined, async (requestId, _traceId, phaseTimings) => {
-        // The public Gateway only exposes its stable facade schema. It may
+        // The public Gateway serves one complete canonical tool schema. It may
         // proxy execution, but it never discovers one Runtime schema and
         // validates calls against another source checkout.
         if (!getRuntimeWriteClaim() && !runtimeSchema && !canonicalRuntimeSchemaMatchesGateway(ctx)) {
@@ -1060,6 +1060,17 @@ export function createForgeMcpServerFromContext(
           if (runtimeProxy && observeRuntimeStatus(ctx.controllerHome).ready) return runtimeProxy.callTool(ctx, name, forwardedArgs, phaseTimings);
         }
         const executeLocalTool = async (): Promise<CallToolResult> => {
+          if (name === 'execute_command' && args.scope === 'host') {
+            if (args.dry_run === true) {
+              return { content: [{ type: 'text', text: 'HOST_COMMAND_PREVIEW_UNSUPPORTED: host command preview requires a separate explicit grant-aware facility' }], structuredContent: { error: { code: 'HOST_COMMAND_PREVIEW_UNSUPPORTED' } }, isError: true };
+            }
+            if (args.repo_id !== undefined || args.checkout_id !== undefined || args.workspace_root !== undefined) {
+              return { content: [{ type: 'text', text: 'COMMAND_SCOPE_CONFLICT: host execution cannot claim repository or workspace targeting' }], structuredContent: { error: { code: 'COMMAND_SCOPE_CONFLICT', message: 'Host execution cannot claim repository or workspace targeting' } }, isError: true };
+            }
+            // One exposed command, two existing authorization targets. The host
+            // lane checks its canonical ForgeInstance process:exec Grant itself.
+            return executeAuthorizedHostCommand(ctx, args);
+          }
           const accessResult = callAccessTool(ctx, name, args);
           if (accessResult) return accessResult;
           const executionResult = await callExecutionTool(ctx, name, args);
@@ -1076,9 +1087,19 @@ export function createForgeMcpServerFromContext(
           if (durableResult) return durableResult;
           const repositoryResult = await callRepositoryToolWithPostFinalizeAttribution(ctx.controllerHome, name, args, ctx);
           if (repositoryResult) return repositoryResult;
+          if (name === 'controller_capabilities') {
+            // Legacy read-only diagnostics consume the authoritative tools/list
+            // snapshot; legacy handlers must not import Runtime registries.
+            return await callMultiRepositoryTool({
+              ...ctx,
+              publishedToolNames: controllerExposureSnapshot(ctx).actualToolNames,
+            }, name, args);
+          }
           return await callMultiRepositoryTool(ctx, name, args);
         };
         const localResult = await executeLocalTool();
+        // MCP calls are intermediate. Only the provider-observed final assistant
+        // response can close a Supervisor turn.
         return settleCognitionAfterTool(ctx, name, args, localResult) ?? localResult;
       });
     }

package/adapters/mcp/setup.ts

@@ -24,8 +24,7 @@ import {
   MAX_AGENT_TIMEOUT_MS,
 } from "../../src/cli/controller/runtime-config";
 import { ensureControllerHome, ensureRepoPreferredControllerHome } from "../../src/cli/repositories/controller-home";
-import { accessModeForLegacyToolset } from "./access-mode";
-import { migrateControllerToolsetConfig } from "./toolset-selection";
+import { configuredControllerAccessMode } from './access-mode';
 import { ensureForgeInstanceIdentity, normalizeConfiguredForgeInstanceId, readForgeInstanceIdentity } from "../../packages/kernel/identity/api/index";
 import { discoverExecutable } from "../../src/runtime/platform/executable-discovery";
 
@@ -383,8 +382,6 @@ export function runMcpSetupChatgpt(opts: {
   const oauth = ensureMcpControllerHomeOAuthPassphrase(controllerHome);
   if (token.changed) changed.push(token.path);
   if (oauth.changed) changed.push(oauth.path);
-  const migratedToolset = migrateControllerToolsetConfig(existingConfig);
-  const toolset = migratedToolset.toolset;
   const config = {
     version: Math.max(existingConfig?.version ?? 1, 3),
     identity: { forgeInstanceId: forgeInstance.instanceId },
@@ -408,10 +405,7 @@ export function runMcpSetupChatgpt(opts: {
       localEndpoint: `http://127.0.0.1:${connectorPort}/mcp`,
     },
     profile: existingConfig?.profile ?? "controller",
-    toolset,
-    toolsetExplicit: migratedToolset.toolsetExplicit,
-    accessMode: existingConfig?.accessMode
-      ?? accessModeForLegacyToolset(existingConfig?.toolset ?? toolset),
+    accessMode: configuredControllerAccessMode(existingConfig),
     accessModeUpdatedAt: existingConfig?.accessModeUpdatedAt,
     accessModeRevision: existingConfig?.accessModeRevision ?? 0,
     localController: opts.userLevel && !existingConfig?.repo
@@ -470,7 +464,7 @@ export function runMcpSetupChatgpt(opts: {
       `[forge mcp] Forge instance: ${forgeInstance.instanceId}`,
       opts.userLevel ? `[forge mcp] Scope: user (${controllerHome})` : `[forge mcp] Repo: ${repoRoot}`,
       "[forge mcp] Profile: controller",
-      `[forge mcp] Toolset: ${config.toolset}`,
+      '[forge mcp] Tools: complete Forge capability registry',
       `[forge mcp] ChatGPT MCP server name: ${serverName}`,
       `[forge mcp] Internal Runtime endpoint: http://${host}:${port}/mcp`,
       `[forge mcp] ChatGPT local OAuth endpoint: http://127.0.0.1:${connectorPort}/mcp`,
@@ -686,7 +680,7 @@ export function runMcpDoctor(opts: {
       : "not_adopted",
     repo: repoRoot,
     mcp: {
-      toolset: migrateControllerToolsetConfig(localConfig).toolset,
+      toolset: 'full',
       localConfig: existsSync(mcpControllerHomeLocalConfigPath(controllerHome)) || existsSync(
         join(repoRoot, ".forge", "mcp.local.json"),
       ),

package/adapters/mcp/tool-mapping/access-tools.ts

@@ -167,8 +167,6 @@ function accessStatePayload(
   effective = resolveControllerAccessState({
     controllerHome: ctx.controllerHome,
     repoRoot: ctx.explicitRepository?.canonicalRoot,
-    toolsetOverride: ctx.toolset,
-    toolsetLocked: ctx.toolsetLocked,
   }),
 ) {
   const repositoryPolicy = readRepositoryAccessPolicy(ctx.controllerHome, repository.repoId);
@@ -206,8 +204,6 @@ function previewPayload(
   const currentEffective = resolveControllerAccessState({
     controllerHome: ctx.controllerHome,
     repoRoot: ctx.explicitRepository?.canonicalRoot,
-    toolsetOverride: ctx.toolset,
-    toolsetLocked: ctx.toolsetLocked,
   });
   const currentPolicy = readRepositoryAccessPolicy(ctx.controllerHome, repository.repoId);
   const currentGroups = accessToolGroups(currentEffective.effectiveAccessMode);
@@ -280,8 +276,6 @@ export function callAccessTool(
       const effective = resolveControllerAccessState({
         controllerHome: ctx.controllerHome,
         repoRoot: ctx.explicitRepository?.canonicalRoot,
-        toolsetOverride: ctx.toolset,
-        toolsetLocked: ctx.toolsetLocked,
       });
       return result({
         ...accessStatePayload(ctx, repository, configured, effective),