@moretea-labs/forge 1.8.1 → 1.8.2

package/adapters/mcp/tool-mapping/post-finalize-work-attribution.ts

@@ -48,7 +48,7 @@ export async function callPostFinalizeWorkReadOnlyCommand(
   args: Record<string, unknown>,
   caller?: RepositoryToolCallerContext,
 ): Promise<CallToolResult | undefined> {
-  if (name !== 'repository_command_execute') return undefined;
+  if (name !== 'execute_command') return undefined;
   if (typeof args.workspace_root === 'string' && args.workspace_root.trim()) return undefined;
 
   const requestedWorkId = typeof args.work_id === 'string' ? args.work_id.trim() : '';

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

@@ -4,7 +4,7 @@ import { resolveEphemeralWorkspaceTarget } from '../../../src/cli/repositories/e
 import { commandExecutionScopeKey, type RepositoryCommandScopeTarget } from '../../../src/cli/repositories/command-scope';
 import { executionIdentityForWork, type ResolvedExecutionIdentity } from '../../../src/runtime/control-plane/execution/execution-identity';
 import { assertNoBoundExecutionSessionMutation, resolveClaimedRepositoryWorkId, resolveExplicitClaimedRepositoryWork, type RepositoryWorkAttributionCaller } from '../../../src/runtime/control-plane/execution/repository-work-attribution';
-import { getWorkContract, promoteWorkToRepositoryChange, semanticWorkState, type WorkContract } from '../../../packages/kernel/work/api';
+import { getWorkContract, semanticWorkState, type WorkContract } from '../../../packages/kernel/work/api';
 import { assertCanonicalRepositoryMutationWorkHandleAvailable, ensureRepositoryMutationWorkHandle, markRepositoryMutationStarted } from '../../../src/runtime/control-plane/execution/work-handle-authority';
 import { readWorkHandle } from '../../../src/runtime/control-plane/execution/work-handle-store';
 import { ensureRunningRepositoryWorkCheckout } from '../../../src/runtime/control-plane/execution/retained-work-resume';
@@ -244,25 +244,23 @@ export const repositoryToolDefinitions: McpToolDefinition[] = [
     validation_only: { type: 'boolean', description: 'When true, do not edit. Reconcile/reuse the existing session validation Processes identified by session_id/check_ids/validation_request_id.' },
     apply_mode: { type: 'string', enum: ['sync', 'async'], description: 'Defaults to sync for interactive development. Set async only for a separately durable operation.' },
   }),
-  definition('repository_command_preview', 'Preview one repository-scoped local command with classification, approval token, and Git snapshots.', {
+  definition('execute_command', 'Single terminal entry. Repository and authorized workspace commands need no Work or Plan. Explicit scope=host uses the existing ForgeInstance process:exec Grant. Process Runtime owns execution, process handles and timeouts; Git ownership checks remain mechanical.', {
     repo_id: repoId,
     checkout_id: { type: 'string', description: 'Optional checkout identity for repositories with multiple local clones.' },
-    command: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Legacy shell string or typed argv array. Typed argv executes without a shell.' },
+    work_id: { type: 'string', description: 'Optional Work provenance; ordinary commands never require a Work. Work-attributed effects require a stable request_id.' },
+    scope: { type: 'string', enum: ['repository', 'host'], description: 'Defaults to repository; host requires an explicit process:exec ForgeInstance Grant.' },
+    command: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Repository: typed argv or shell string; host: typed argv only.' },
+    shell_command: { type: 'string', description: 'Host shell only; mutually exclusive with command and requires scope=host.' },
+    request_id: { type: 'string', description: 'Stable invocation id for reconnect without duplicate effects.' },
     cwd: { type: 'string', description: 'Optional root-relative working directory.' },
     workspace_root: { type: 'string', description: 'Absolute existing local directory used as an ephemeral execution root. Mutually exclusive with repo_id/checkout_id; does not register or initialize the directory.' },
-  }, ['command'], true),
-  definition('repository_command_execute', 'Compatibility facade for commands whose domain context is a repository/workspace. Repository targeting, Git/source mutation fences, and compatibility response fields live here; Process Runtime owns command execution and process identity. New broad host-local command callers should use process_exec. Use rh_context for routine code discovery/reading; shell exploration is fallback-only.', {
-    repo_id: repoId,
-    checkout_id: { type: 'string', description: 'Optional checkout identity for repositories with multiple local clones.' },
-    work_id: { type: 'string', description: 'Optional durable Work identity. Workflow controllers should pass the exact claimed Work id so attribution survives transient MCP transport sessions.' },
-    command: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Legacy shell string or typed argv array. Typed argv executes without a shell.' },
-    cwd: { type: 'string', description: 'Optional root-relative working directory.' },
-    workspace_root: { type: 'string', description: 'Absolute existing local directory used as an ephemeral execution root. Mutually exclusive with repo_id/checkout_id; does not register or initialize the directory.' },
-    approval_token: { type: 'string', description: 'Exact approval token returned by repository_command_preview.' },
+    dry_run: { type: 'boolean', description: 'Preview without executing: returns command classification, approval token and Git snapshots for repository/workspace target.' },
+    approval_token: { type: 'string', description: 'Exact approval token returned by execute_command(dry_run=true).' },
     approval_request_id: { type: 'string', description: 'Resolved approvalRequestId returned by approval_resolve.' },
     timeout_ms: { type: 'number', description: 'Optional execution timeout in milliseconds.' },
-    max_output_bytes: { type: 'number', description: 'Optional cap for captured stdout/stderr.' },
-  }, ['command']),
+    max_output_bytes: { type: 'number', minimum: 1024, maximum: 1048576, description: 'Captured output limit 1024–1048576 bytes.' },
+    interactive_wait_ms: { type: 'number', description: 'Optional short attachment window; long-running processes return a handle.' },
+  }),
 
   // Thin Harness V1 is exposed through repository_workbench operations to keep the stable tool surface bounded.
 ];
@@ -357,11 +355,8 @@ function resolveRepositorySelectionForClaimedWork(
       allowSoleRepository: true,
     });
   }
-  let work = resolveExplicitClaimedRepositoryWork(controllerHome, repository, caller, explicitWorkId);
+  const work = resolveExplicitClaimedRepositoryWork(controllerHome, repository, caller, explicitWorkId);
   if (!work) return repository;
-  if (work.workKind !== 'repository_change') {
-    work = promoteWorkToRepositoryChange({ controllerHome, repoId: repository.repoId }, work.workId);
-  }
   const principalId = caller?.principalId?.trim();
   const sessionId = caller?.sessionId?.trim();
   const controllerInstanceId = caller?.controllerInstanceId?.trim();
@@ -591,33 +586,6 @@ function failure(error: unknown): RepositoryToolResult {
   return { ...result({ error: { code, message, ...(compactDetails !== undefined ? { details: compactDetails } : {}) } }), isError: true };
 }
 
-interface RepositoryExplorationGuidance {
-  code: 'FRAGMENTED_REPOSITORY_EXPLORATION';
-  recommendedTool: 'rh_context';
-  recommendedOperation: 'search';
-  message: string;
-}
-
-function fragmentedRepositoryExplorationGuidance(command: unknown): RepositoryExplorationGuidance | undefined {
-  if (typeof command !== 'string') return undefined;
-  const segments = command.split(/(?:&&|\|\||[;|])/g);
-  const readPrograms = new Set<string>();
-  let readStepCount = 0;
-  for (const segment of segments) {
-    const match = segment.trim().match(/^(?:(?:command|env)\s+)?(?:[A-Za-z_][A-Za-z0-9_]*=[^\s]+\s+)*(rg|grep|sed|cat|head|tail)\b/i);
-    if (!match) continue;
-    readStepCount += 1;
-    readPrograms.add(match[1]!.toLowerCase());
-  }
-  if (readStepCount < 2) return undefined;
-  return {
-    code: 'FRAGMENTED_REPOSITORY_EXPLORATION',
-    recommendedTool: 'rh_context',
-    recommendedOperation: 'search',
-    message: `Detected ${readStepCount} chained repository read steps (${[...readPrograms].join(', ')}). Prefer a broad rh_context request first, then repeat rh_context with selected paths or relationships when more evidence can improve correctness; keep shell search as fallback when the Context Plane cannot supply the needed evidence.`,
-  };
-}
-
 function compactProcessCommandPayload(input: {
   accepted?: boolean;
   mode: string;
@@ -644,7 +612,6 @@ function compactProcessCommandPayload(input: {
   /** summary (default) omits nested process / routing dumps; detail restores diagnostics. */
   detailLevel?: 'summary' | 'detail';
   includeFullProcess?: boolean;
-  guidance?: RepositoryExplorationGuidance;
 }): Record<string, unknown> {
   const output = compactCommandOutput(input.stdout, input.stderr, { ok: input.ok === true });
   const detail = input.detailLevel === 'detail' || input.includeFullProcess === true;
@@ -680,7 +647,6 @@ function compactProcessCommandPayload(input: {
       stderr: output.stderr ?? '',
       ...(output.stdoutTruncated ? { stdoutTruncated: true, stdoutBytes: output.stdoutBytes } : {}),
       ...(output.stderrTruncated ? { stderrTruncated: true, stderrBytes: output.stderrBytes } : {}),
-      ...(input.guidance ? { guidance: input.guidance, suggestedOperation: 'rh_context' } : {}),
     };
     if (completed && !ok) {
       payload.error = {
@@ -729,7 +695,6 @@ function compactProcessCommandPayload(input: {
       }
       : {}),
     durableSideEffects: effects,
-    ...(input.guidance ? { guidance: input.guidance, suggestedOperation: 'rh_context' } : {}),
     next: input.next,
     detailLevel: 'detail',
   };
@@ -771,7 +736,7 @@ export async function callRepositoryTool(
   args: Record<string, unknown>,
   caller?: RepositoryToolCallerContext,
 ): Promise<RepositoryToolResult | undefined> {
-  if (!name.startsWith('repository_') && name !== 'read_repository_file') return undefined;
+  if (!name.startsWith('repository_') && name !== 'read_repository_file' && name !== 'execute_command') return undefined;
   try {
     const repoIdValue = typeof args.repo_id === 'string' ? args.repo_id.trim() : '';
     switch (name) {
@@ -924,7 +889,7 @@ export async function callRepositoryTool(
       case 'repository_git_status': {
         const repository = resolveRepositorySelection({ repoId: repoIdValue || undefined, checkoutId: typeof args.checkout_id === 'string' ? args.checkout_id : undefined, controllerHome, allowSoleRepository: true });
         const status = args.refresh === true
-          ? writeRepositoryGitStatusSample(controllerHome, repository)
+          ? await writeRepositoryGitStatusSample(controllerHome, repository)
           : readRepositoryGitStatusSample(controllerHome, repository.repoId, repository.activeCheckoutId);
         return result({
           status: status ?? {
@@ -997,7 +962,9 @@ export async function callRepositoryTool(
                 workId: binding?.workId,
               });
             }
-            const mutationAuthority = binding?.workId
+            // A validation-only reattachment is not repository mutation admission;
+            // it must never promote a thin investigation to repository_change.
+            const mutationAuthority = binding?.workId && args.validation_only !== true
               ? ensureRepositoryMutationWorkHandle({
                   controllerHome,
                   repository,
@@ -1089,32 +1056,32 @@ export async function callRepositoryTool(
         };
         return ok ? result(payload) : { ...result(payload), isError: true };
       }
-      case 'repository_command_preview': {
-        const target = resolveRepositoryCommandTarget(controllerHome, args, repoIdValue, caller);
-        const { commandTarget } = target;
-        const execution = withControllerLock(
-          controllerHome,
-          { scope: 'repository', repoId: commandExecutionScopeKey(commandTarget) },
-          'mcp:repository_command_preview',
-          () => executeRepositoryCommand(controllerHome, commandTarget, {
-            command: args.command as string | string[],
-            cwd: typeof args.cwd === 'string' ? args.cwd : undefined,
-            dryRun: true,
-            allowNonGitWorkspace: target.workspace !== undefined,
-          }),
-          60_000,
-        );
-        // Repository targets keep repoId/checkoutId. An arbitrary workspace target
-        // reports its workspace scope id and never a repository id.
-        const { repoId: _previewRepoId, checkoutId: _previewCheckoutId, ...workspacePreviewFields } = execution as unknown as Record<string, unknown>;
-        return result({
-          ...(commandTarget.repoId ? execution as unknown as Record<string, unknown> : workspacePreviewFields),
-          ...(commandTarget.repoId ? {} : { scopeId: commandExecutionScopeKey(commandTarget) }),
-          ...(target.workspace ? { workspace: target.workspace } : {}),
-        });
-      }
-      case 'repository_command_execute': {
-        const explorationGuidance = fragmentedRepositoryExplorationGuidance(args.command);
+      case 'execute_command': {
+        if (args.scope !== undefined && args.scope !== 'repository') throw new Error('COMMAND_SCOPE_INVALID: host scope uses the authorized host command lane');
+        if (args.shell_command !== undefined) throw new Error('COMMAND_SCOPE_INVALID: shell_command requires scope=host');
+        if (args.command === undefined) throw new Error('COMMAND_REQUIRED: repository commands require command');
+        if (args.dry_run === true) {
+          const target = resolveRepositoryCommandTarget(controllerHome, args, repoIdValue, caller);
+          const { commandTarget } = target;
+          const execution = withControllerLock(
+            controllerHome,
+            { scope: 'repository', repoId: commandExecutionScopeKey(commandTarget) },
+            'mcp:execute_command:preview',
+            () => executeRepositoryCommand(controllerHome, commandTarget, {
+              command: args.command as string | string[],
+              cwd: typeof args.cwd === 'string' ? args.cwd : undefined,
+              dryRun: true,
+              allowNonGitWorkspace: target.workspace !== undefined,
+            }),
+            60_000,
+          );
+          const { repoId: _previewRepoId, checkoutId: _previewCheckoutId, ...workspacePreviewFields } = execution as unknown as Record<string, unknown>;
+          return result({
+            ...(commandTarget.repoId ? execution as unknown as Record<string, unknown> : workspacePreviewFields),
+            ...(commandTarget.repoId ? {} : { scopeId: commandExecutionScopeKey(commandTarget) }),
+            ...(target.workspace ? { workspace: target.workspace } : {}),
+          });
+        }
         let target = resolveRepositoryCommandTarget(controllerHome, args, repoIdValue, caller);
         let { repository, commandTarget, executionIdentity, historicalWorkContext } = target;
         // Repository targets keep their established identity fields. An arbitrary
@@ -1181,7 +1148,7 @@ export async function callRepositoryTool(
             mutationAuthority = withControllerLock(
               controllerHome,
               { scope: 'repository', repoId: commandExecutionScopeKey(commandTarget) },
-              'mcp:repository_command_execute:mutation-authority',
+              'mcp:execute_command:mutation-authority',
               () => ensureRepositoryMutationWorkHandle({
                 controllerHome,
                 repository: repository!,
@@ -1201,7 +1168,7 @@ export async function callRepositoryTool(
             withControllerLock(
               controllerHome,
               { scope: 'repository', repoId: commandExecutionScopeKey(commandTarget) },
-              'mcp:repository_command_execute:unattributed-mutation-authority',
+              'mcp:execute_command:unattributed-mutation-authority',
               () => assertCanonicalRepositoryMutationWorkHandleAvailable({
                 controllerHome,
                 repositoryId: commandExecutionScopeKey(commandTarget),
@@ -1219,7 +1186,7 @@ export async function callRepositoryTool(
         // external durable boundary, not as a second command classifier.
         const routingDecision = forceDurable
           ? routeExecution({
-              operation: 'repository_command_execute',
+              operation: 'execute_command',
               mode: 'durable',
               timeoutMs,
               background: args.background === true || args.async === true,
@@ -1306,7 +1273,7 @@ export async function callRepositoryTool(
                   withControllerLock(
                     controllerHome,
                     { scope: 'repository', repoId: commandExecutionScopeKey(commandTarget) },
-                    'mcp:repository_command_execute:mutation-started',
+                    'mcp:execute_command:mutation-started',
                     () => markRepositoryMutationStarted({
                       controllerHome,
                       repository,
@@ -1345,7 +1312,7 @@ export async function callRepositoryTool(
                     message: authorization.decision === 'user_confirmation_required'
                       ? authorization.humanSummary
                       : authorization.reason,
-                    suggestedOperation: 'repository_command_preview',
+                    suggestedOperation: 'execute_command(dry_run=true)',
                   });
                 }
                 const completed = directWithoutHandle || handle?.completed === true;
@@ -1374,7 +1341,6 @@ export async function callRepositoryTool(
                   stdout: processResult.stdout,
                   stderr: processResult.stderr,
                   durableSideEffects: processResult.durableSideEffects,
-                  guidance: explorationGuidance,
                   next: directWithoutHandle
                     ? processResult.reason === 'readonly_fast_path'
                       ? 'Bounded readonly execution completed without Process record / Lease / Local Job / ExecutionJob / Worker.'
@@ -1416,7 +1382,7 @@ export async function callRepositoryTool(
             // Process Runtime is authoritative. Falling through could spawn the
             // same command again through the legacy Fast/Local Job path.
             if (process.env.FORGE_DEBUG_PROCESS_RUNTIME === '1') {
-              console.error('[repository_command_execute] process runtime error', error);
+              console.error('[execute_command] process runtime error', error);
             }
             return failure(error);
           }
@@ -1486,7 +1452,7 @@ export async function callRepositoryTool(
             }
           } catch (error) {
             if (process.env.FORGE_DEBUG_PROCESS_RUNTIME === '1') {
-              console.error('[repository_command_execute] durable worker inline process runtime error', error);
+              console.error('[execute_command] durable worker inline process runtime error', error);
             }
           }
         }
@@ -1496,7 +1462,7 @@ export async function callRepositoryTool(
           path: 'external_controller_required',
           routing: compactRoutingSummary({ path: 'durable', mode: 'durable', reasons: [routingDecision.reasons.join(','), 'local_bridge_execution_retired'] }),
           message: 'This command requires explicit external Controller handling; Local Bridge Jobs are retired for repository commands.',
-          suggestedOperation: 'Create or claim WorkContract, then use rh_work.launcher_start or a Process Runtime-compatible command.',
+          next: 'This execution boundary requires separate external authority; the model chooses an authorized domain capability or alternative command based on the task.',
           externalEffect: {
             outcome: 'not_started',
             ambiguousFailureOutcome: 'outcome_unknown',

package/adapters/mcp/toolset-names.ts

@@ -4,12 +4,11 @@ import { FACADE_TOOLS } from '../../src/runtime/control-plane/facade/types';
 export const PREFERRED_FACADE_TOOL_NAMES = [...FACADE_TOOLS] as const;
 
 /**
- * Default ChatGPT-facing MCP surface. The Runtime keeps every internal atomic
- * handler and the full compatibility profile; ChatGPT only needs this bounded
- * execution surface. Atomic Git / issue-task / edit-session / plugin
- * tools remain registered and reachable through `toolset=full`.
+ * Preferred public tool names for model routing and connector freshness.
+ * Not an exposure profile: every registered MCP tool is always discoverable.
+ * Removal of an obsolete public handler is a source migration, not a toolset switch.
  */
-export const DEFAULT_CONTROLLER_TOOL_NAMES = [
+export const PREFERRED_CONTROLLER_TOOL_NAMES = [
   ...PREFERRED_FACADE_TOOL_NAMES,
 
   // Repository selection / bootstrap.
@@ -17,11 +16,11 @@ export const DEFAULT_CONTROLLER_TOOL_NAMES = [
   'repository_get',
   'repository_register',
 
-  // Generic repository-scoped command (readonly fast path, mutation, destructive gate).
-  'repository_command_execute',
+  // Unified terminal entry; scope determines its authorized execution target.
+  'execute_command',
 
   // Source inspection and bounded Direct Edit. Code location is routed through
-  // rh_context.search; the low-level search_repository handler remains in full.
+  // rh_context.search; the direct search_repository action remains available.
   'read_repository_file',
   'repository_safe_patch_apply',
 
@@ -29,51 +28,21 @@ export const DEFAULT_CONTROLLER_TOOL_NAMES = [
   'run_check',
 
   // Protected Computer preparation/input use typed direct-non-persistent actions
-  // behind the stable plugin dispatcher. Their full-profile atomic tools remain
-  // registered only for compatibility clients and are not part of this frozen ABI.
+  // behind the stable plugin dispatcher. Distinct OS actions remain public.
 
   // One typed plugin dispatcher. Plugin discovery/action schemas stay routed
   // through rh_context(capability_id=plugin.<plugin>.<action>) to avoid widening
-  // the default surface with list/get plugin atomics.
+  // the preferred list with every plugin atomic.
   'plugin_action_execute',
 
   // Managed Process Runtime lifecycle (attach / poll / cancel — never re-exec).
-  // process_exec is the canonical host-local command lane: the Forge instance is
-  // the target, cwd is an execution argument, and it is authorized by one
-  // explicit `process:exec` canonical Grant. repository_command_execute stays as
-  // translation-only compatibility over the repository target.
-  'process_exec',
+  // Host execution requires execute_command(scope=host) with explicit process:exec Grant.
   'process_get',
   'process_wait',
   'process_logs',
   'process_cancel',
 
-  // Evidence. Approval resolution is available through rh_access/rh_work and
-  // the explicit full compatibility profile; it does not need a top-level
-  // default tool.
+  // Evidence. The complete registry also exposes exact typed approval actions.
   'result_read',
   'result_search',
 ] as const;
-
-/** Minimal bootstrap subset retained for diagnostics and constrained clients. */
-export const BOOTSTRAP_CONTROLLER_TOOL_NAMES = [
-  ...PREFERRED_FACADE_TOOL_NAMES,
-  'repository_access_get',
-  'repository_list',
-  'repository_get',
-  'repository_register',
-  'repository_latest_source_diagnose',
-  'repository_bootstrap_local_project',
-] as const;
-
-/**
- * Stable ChatGPT connector schema. Keep this identical to the bounded default
- * Runtime surface so discovery never advertises atomic tools that the default
- * Forge build will reject. The exhaustive `full` profile is assembled directly
- * from registered definitions and remains available for explicit compatibility
- * clients without widening the normal connector schema.
- */
-export const STABLE_CONTROLLER_TOOL_NAMES = DEFAULT_CONTROLLER_TOOL_NAMES;
-
-/** Core is a compatibility label for the bounded default Controller surface. */
-export const CORE_CONTROLLER_TOOL_NAMES = DEFAULT_CONTROLLER_TOOL_NAMES;

package/adapters/mcp/toolset.ts

@@ -11,21 +11,18 @@ import { runtimeToolDefinitions } from './runtime-gateway/runtime-tool-definitio
 import { executionToolDefinitions } from './runtime-gateway/execution-tools';
 import { processToolDefinitions } from './runtime-gateway/process-tools';
 import { injectDurableCommandFields } from './runtime-gateway/router';
-import { injectAutomationEnvelopeFields } from './runtime-gateway/automation-receipt-adapter';
 import { injectCognitionSettlementFields } from './runtime-gateway/cognition-settlement';
-import { DEFAULT_CONTROLLER_TOOL_NAMES, PREFERRED_FACADE_TOOL_NAMES, STABLE_CONTROLLER_TOOL_NAMES } from './toolset-names';
-export { BOOTSTRAP_CONTROLLER_TOOL_NAMES, CORE_CONTROLLER_TOOL_NAMES, DEFAULT_CONTROLLER_TOOL_NAMES, PREFERRED_FACADE_TOOL_NAMES, STABLE_CONTROLLER_TOOL_NAMES } from './toolset-names';
-import type { McpToolset } from './types';
+import { PREFERRED_FACADE_TOOL_NAMES } from './toolset-names';
+export { PREFERRED_CONTROLLER_TOOL_NAMES, PREFERRED_FACADE_TOOL_NAMES } from './toolset-names';
 import { forgeToolSurfaceFingerprint } from '../../src/cli/controller/runtime-config';
 
-export type ToolExposureClass = 'facade' | 'advanced' | 'internal' | 'compatibility';
-export type ControllerToolProfile = 'facade' | 'core' | 'advanced' | 'full';
+export type ControllerToolProfile = 'full';
 
 export interface ControllerToolInventoryEntry {
   name: string;
   profile: ControllerToolProfile;
   capability: string;
-  exposedVia: 'facade' | 'core' | 'advanced' | 'full';
+  exposedVia: 'facade' | 'full';
 }
 
 /**
@@ -35,7 +32,7 @@ export interface ControllerToolInventoryEntry {
  */
 export interface ControllerExposureSnapshot {
   access: ControllerAccessState;
-  toolset: McpToolset;
+  toolset: 'full';
   profile: ControllerToolProfile;
   definitions: McpToolDefinition[];
   toolNames: string[];
@@ -66,17 +63,6 @@ export interface ControllerToolSurfaceStatus {
   ready: boolean;
 }
 
-/**
- * Core and Advanced expose the same bounded default ChatGPT surface
- * (DEFAULT_CONTROLLER_TOOL_NAMES). Full remains the exhaustive compatibility
- * surface for legacy integrations; internal atomic handlers are never deleted.
- */
-
-/** Historical Advanced name retained for compatibility. */
-export const ADVANCED_CONTROLLER_TOOL_NAMES = DEFAULT_CONTROLLER_TOOL_NAMES;
-
-const DEFAULT_CONTROLLER_TOOL_SET = new Set<string>(DEFAULT_CONTROLLER_TOOL_NAMES);
-
 interface StaticControllerExposureSnapshot {
   definitions: McpToolDefinition[];
   toolNames: string[];
@@ -101,32 +87,12 @@ function pruneStaticExposureCache(): void {
   }
 }
 
-export function normalizeMcpToolset(value: unknown): McpToolset {
-  if (value === 'full' || value === 'advanced' || value === 'core' || value === 'facade') return value;
-  return 'advanced';
-}
-
-/**
- * null means expose every registered definition. Profile membership only
- * changes schema discovery; authorization remains an independent policy.
- */
-export function controllerToolNamesForToolset(
-  toolset: McpToolset,
-  _ctx?: MultiRepositoryMcpToolContext,
-): readonly string[] | null {
-  if (toolset === 'full') return null;
-  if (toolset === 'facade') return PREFERRED_FACADE_TOOL_NAMES;
-  return DEFAULT_CONTROLLER_TOOL_NAMES;
-}
-
 export function resolveControllerAccessStateForContext(
   ctx: MultiRepositoryMcpToolContext,
 ): ControllerAccessState {
   return resolveControllerAccessState({
     controllerHome: ctx.controllerHome,
     repoRoot: ctx.explicitRepository?.canonicalRoot,
-    toolsetOverride: ctx.toolset,
-    toolsetLocked: ctx.toolsetLocked ?? false,
   });
 }
 
@@ -164,7 +130,6 @@ function staticExposureCacheKey(ctx: MultiRepositoryMcpToolContext): string {
     controllerHome: ctx.controllerHome,
     repoRoot: ctx.repoRoot,
     explicitRepositoryId: ctx.explicitRepository?.repoId,
-    toolset: ctx.toolset,
     profile: ctx.policy.profile,
     enableChatgptBrowser: ctx.enableChatgptBrowser === true,
     devAgentRunner: ctx.policy.execution.agentRunner,
@@ -183,25 +148,20 @@ function buildStaticControllerExposureSnapshot(
     accessToolDefinitions,
     repositoryToolDefinitions,
   );
-  const rawDefinitions = ctx.toolset === 'full'
-    ? currentDefinitions.concat(
-      buildMultiRepositoryToolDefinitions(ctx).filter(
-        (legacy) => !currentDefinitions.some((current) => current.name === legacy.name),
-      ),
-    )
-    : currentDefinitions;
+  const rawDefinitions = currentDefinitions.concat(
+    buildMultiRepositoryToolDefinitions(ctx).filter(
+      (legacy) => !currentDefinitions.some((current) => current.name === legacy.name),
+    ),
+  );
   const unique = uniqueDefinitions(rawDefinitions);
-  const allowed = controllerToolNamesForToolset(ctx.toolset, ctx);
-  const expectedToolNames = allowed === null
-    ? unique.definitions.map((tool) => tool.name)
-    : [...new Set(allowed)];
+  const expectedToolNames = unique.definitions.map((tool) => tool.name);
   const definitionByName = new Map(unique.definitions.map((definition) => [definition.name, definition]));
   const definitions = expectedToolNames
     .map((name) => definitionByName.get(name))
     .filter((definition): definition is McpToolDefinition => Boolean(definition))
     // Fingerprint the exact definitions that ListTools returns. Shared transport
     // contracts are injected here once rather than re-declared by domain registries.
-    .map((definition) => injectCognitionSettlementFields(injectAutomationEnvelopeFields(injectDurableCommandFields(definition))));
+    .map((definition) => injectCognitionSettlementFields(injectDurableCommandFields(definition)));
   const actualToolNames = definitions.map((tool) => tool.name);
   const actualSet = new Set(actualToolNames);
   const expectedSet = new Set(expectedToolNames);
@@ -249,15 +209,10 @@ function capabilityForToolName(name: string): string {
   return 'compatibility';
 }
 
-function profileForToolset(toolset: McpToolset): ControllerToolProfile {
-  return toolset === 'full' ? 'full' : toolset === 'facade' ? 'facade' : toolset === 'core' ? 'core' : 'advanced';
-}
-
 export function controllerToolInventory(
   toolNames: readonly string[],
-  toolset: McpToolset,
 ): ControllerToolInventoryEntry[] {
-  const profile = profileForToolset(toolset);
+  const profile = 'full' as const;
   return toolNames.map((name) => ({
     name,
     profile,
@@ -270,19 +225,13 @@ export function clearControllerExposureCacheForTest(): void {
   staticControllerExposureCache.clear();
 }
 
-export function allControllerToolDefinitions(ctx: MultiRepositoryMcpToolContext): McpToolDefinition[] {
-  return uniqueDefinitions(
-    runtimeToolDefinitions.concat(executionToolDefinitions, processToolDefinitions, accessToolDefinitions, repositoryToolDefinitions, buildMultiRepositoryToolDefinitions(ctx)),
-  ).definitions.map((definition) => injectCognitionSettlementFields(injectAutomationEnvelopeFields(injectDurableCommandFields(definition))));
-}
-
 export function controllerExposureSnapshot(ctx: MultiRepositoryMcpToolContext): ControllerExposureSnapshot {
   const staticSnapshot = staticControllerExposureSnapshot(ctx);
   return {
     access: resolveControllerAccessStateForContext(ctx),
-    toolset: ctx.toolset,
-    profile: profileForToolset(ctx.toolset),
-    inventory: controllerToolInventory(staticSnapshot.actualToolNames, ctx.toolset),
+    toolset: 'full',
+    profile: 'full',
+    inventory: controllerToolInventory(staticSnapshot.actualToolNames),
     ...staticSnapshot,
   };
 }
@@ -305,29 +254,6 @@ export function controllerExposedToolNames(ctx: MultiRepositoryMcpToolContext):
   return controllerExposureSnapshot(ctx).actualToolNames;
 }
 
-export function classifyControllerToolExposure(toolName: string): ToolExposureClass {
-  if ((PREFERRED_FACADE_TOOL_NAMES as readonly string[]).includes(toolName)) return 'facade';
-  if (toolName.startsWith('rh_')) return 'facade';
-  if (DEFAULT_CONTROLLER_TOOL_SET.has(toolName)) return 'advanced';
-  return 'compatibility';
-}
-
-export function controllerToolExposureMetadata(toolNames: readonly string[]): {
-  preferredTools: string[];
-  advancedTools: string[];
-  compatibilityTools: string[];
-  classification: Record<string, ToolExposureClass>;
-} {
-  const classification: Record<string, ToolExposureClass> = {};
-  for (const name of toolNames) classification[name] = classifyControllerToolExposure(name);
-  return {
-    preferredTools: toolNames.filter((name) => classification[name] === 'facade'),
-    advancedTools: toolNames.filter((name) => classification[name] === 'advanced'),
-    compatibilityTools: toolNames.filter((name) => classification[name] === 'compatibility'),
-    classification,
-  };
-}
-
 export function exposedControllerToolDefinitions(ctx: MultiRepositoryMcpToolContext): McpToolDefinition[] {
   return controllerExposureSnapshot(ctx).definitions;
 }

package/{src/cli → adapters}/mcp/transports/AGENTS.md

@@ -5,21 +5,21 @@ Keep this file focused on the local contract for this primary functional block.
 <!-- BEGIN ARCHITECTURE CONTRACT -->
 ## Architecture Contract
 
-- Functional block: `src/cli/mcp/transports`
+- Functional block: `adapters/mcp/transports`
 - Capability ID: `mcp-http-transport-lifecycle`
-- Matched prefix: `src/cli/mcp/transports`
+- Matched prefix: `adapters/mcp/transports`
 - Architecture domain: `controller-runtime`
 - Architecture capability: `transport-lifecycle`
 - Architecture module: `docs/architecture/modules/controller-runtime/transport-lifecycle.md`
 - Last architecture event: 2026-07-18T07:08:47.902Z
-- Last changed path: `src/cli/mcp/transports`
+- Last changed path: `adapters/mcp/transports`
 - Severity: medium
 - Change type: capability-config
 - Module responsibility: Keep this block aligned with the local boundary described by surrounding human-owned context.
-- Entrypoints: `src/cli/mcp/transports`
+- Entrypoints: `adapters/mcp/transports`
 - Allowed dependencies: Follow root `AGENTS.md` / `CLAUDE.md` and this local contract.
 - Forbidden dependencies: Do not cross sibling app/service/package boundaries without an architecture snapshot or explicit plan.
-- Runtime path: `src/cli/mcp/transports`
+- Runtime path: `adapters/mcp/transports`
 - LSP/tooling profile: `typescript-lsp`
 - Verification: Use root required checks plus local commands recorded in this capability contract.
 - Latest snapshot: `(none yet)`

package/{src/cli → adapters}/mcp/transports/CLAUDE.md

@@ -5,21 +5,21 @@ Keep this file focused on the local contract for this primary functional block.
 <!-- BEGIN ARCHITECTURE CONTRACT -->
 ## Architecture Contract
 
-- Functional block: `src/cli/mcp/transports`
+- Functional block: `adapters/mcp/transports`
 - Capability ID: `mcp-http-transport-lifecycle`
-- Matched prefix: `src/cli/mcp/transports`
+- Matched prefix: `adapters/mcp/transports`
 - Architecture domain: `controller-runtime`
 - Architecture capability: `transport-lifecycle`
 - Architecture module: `docs/architecture/modules/controller-runtime/transport-lifecycle.md`
 - Last architecture event: 2026-07-18T07:08:47.902Z
-- Last changed path: `src/cli/mcp/transports`
+- Last changed path: `adapters/mcp/transports`
 - Severity: medium
 - Change type: capability-config
 - Module responsibility: Keep this block aligned with the local boundary described by surrounding human-owned context.
-- Entrypoints: `src/cli/mcp/transports`
+- Entrypoints: `adapters/mcp/transports`
 - Allowed dependencies: Follow root `AGENTS.md` / `CLAUDE.md` and this local contract.
 - Forbidden dependencies: Do not cross sibling app/service/package boundaries without an architecture snapshot or explicit plan.
-- Runtime path: `src/cli/mcp/transports`
+- Runtime path: `adapters/mcp/transports`
 - LSP/tooling profile: `typescript-lsp`
 - Verification: Use root required checks plus local commands recorded in this capability contract.
 - Latest snapshot: `(none yet)`