@moretea-labs/forge 1.7.2 → 1.8.1

package/src/runtime/control-plane/facade/capability-registry.ts

@@ -1,5 +1,11 @@
+import {
+  COMPUTER_CAPTURE_CAPABILITY,
+  COMPUTER_INPUT_CAPABILITY,
+  COMPUTER_OBSERVE_CAPABILITY,
+} from '../../../../packages/protocols/computer/index';
 import type { AssistantPluginManifest } from '../../plugins/types';
-import type { CapabilityDescriptor, CapabilityDomain, CapabilityExecutionSurface, CapabilityGroupSummary, CapabilityOperationClass, CapabilityRisk, FacadeTool } from './types';
+import { EDIT_OPERATION_INPUT_SCHEMA } from '../../../cli/editing/edit-operation-contract';
+import { FACADE_TOOLS, type CapabilityDescriptor, type CapabilityDomain, type CapabilityExecutionSurface, type CapabilityGroupSummary, type CapabilityOperationClass, type CapabilityRisk, type FacadeTool } from './types';
 
 const CORE_CAPABILITIES: CapabilityDescriptor[] = [
   {
@@ -8,19 +14,9 @@ const CORE_CAPABILITIES: CapabilityDescriptor[] = [
     group: 'repository-core',
     operationClass: 'write',
     risk: 'local_repo_write',
-    exposedVia: 'rh_work',
-    schemaExposure: 'stable_static',
-    summary: 'Apply bounded direct edits, patches, selected-path staging, selected commits, and targeted checks for small supervised tasks.',
-  },
-  {
-    capabilityId: 'controller.goal_workloop',
-    domain: 'controller',
-    group: 'controller',
-    operationClass: 'execute',
-    risk: 'workspace_write',
-    exposedVia: 'rh_work',
+    exposedVia: 'capability_execute',
     schemaExposure: 'stable_static',
-    summary: 'Run a recoverable multi-step work contract through isolated worktree, worker, approval, verification, and continuation handoff.',
+    summary: 'Plan and apply bounded repository edits through the existing Safe Patch/EditSession authority, with optional targeted validation and no second editing engine.',
   },
   {
     capabilityId: 'controller.handoff_inbox',
@@ -42,6 +38,26 @@ const CORE_CAPABILITIES: CapabilityDescriptor[] = [
     schemaExposure: 'stable_static',
     summary: 'Read bounded controller, queue, worker, projection, plugin, and readiness status.',
   },
+  {
+    capabilityId: 'controller.connection',
+    domain: 'controller',
+    group: 'controller',
+    operationClass: 'execute',
+    risk: 'workspace_write',
+    exposedVia: 'capability_execute',
+    schemaExposure: 'stable_static',
+    summary: 'Read product-safe controller and tunnel connection state, and refresh the existing Forge Connector through setup authority without creating another configuration owner.',
+  },
+  {
+    capabilityId: 'controller.local_conversation',
+    domain: 'controller',
+    group: 'controller',
+    operationClass: 'execute',
+    risk: 'workspace_write',
+    exposedVia: 'capability_execute',
+    schemaExposure: 'stable_static',
+    summary: 'Run one Work-independent local controller conversation through the existing Codex provider and current Forge Runtime MCP capabilities; conversation transport never creates semantic Work implicitly.',
+  },
   {
     capabilityId: 'repository.context',
     domain: 'repository',
@@ -50,7 +66,7 @@ const CORE_CAPABILITIES: CapabilityDescriptor[] = [
     risk: 'readonly',
     exposedVia: 'rh_context',
     schemaExposure: 'stable_static',
-    summary: 'Read bounded repository context, checks, project state, and execution-mode recommendations.',
+    summary: 'Read bounded repository context, checks, project state, source structure, and execution evidence without choosing the model workflow.',
   },
   {
     capabilityId: 'evidence.read',
@@ -90,7 +106,27 @@ const CORE_CAPABILITIES: CapabilityDescriptor[] = [
     risk: 'workspace_write',
     exposedVia: 'rh_work',
     schemaExposure: 'stable_static',
-    summary: 'Claim Work ownership and start an external Codex, Claude, or ChatGPT controller through controller_claim and launcher_start, with handoff decisions coordinated through rh_inbox; deprecated delegate is not an execution path.',
+    summary: 'Start an explicitly requested external Codex, Claude, or ChatGPT controller through launcher_start; provider identity, transport recovery, and mechanical binding remain internal.',
+  },
+  {
+    capabilityId: 'controller.workflow_supervisor',
+    domain: 'controller',
+    group: 'controller',
+    operationClass: 'execute',
+    risk: 'workspace_write',
+    exposedVia: 'capability_execute',
+    schemaExposure: 'stable_static',
+    summary: 'Start, inspect, revise, recover, stop, and verify standalone Workflow Supervisor tasks through the existing Supervisor single-writer authority; used for bounded cross-turn continuation and release-bound live proof without creating semantic Work or another public facade tool.',
+  },
+  {
+    capabilityId: 'controller.round_recovery',
+    domain: 'controller',
+    group: 'controller',
+    operationClass: 'execute',
+    risk: 'workspace_write',
+    exposedVia: 'capability_execute',
+    schemaExposure: 'stable_static',
+    summary: 'Recover one exact orphaned ControllerRound through the existing authority-rekey transaction, claim it with the authenticated current Runtime, apply only the caller-explicit disposition, and never replay the confirmed provider dispatch effect.',
   },
   {
     capabilityId: 'controller.work_contract',
@@ -100,7 +136,7 @@ const CORE_CAPABILITIES: CapabilityDescriptor[] = [
     risk: 'workspace_write',
     exposedVia: 'rh_work',
     schemaExposure: 'stable_static',
-    summary: 'Persist and advance WorkContract records for goal workloop start, continue, verify, finalize, and stop.',
+    summary: 'Persist optional semantic Work context with stable identity, CAS revision, objective, result references, and open/completed/cancelled state.',
   },
   {
     capabilityId: 'controller.plan_contract',
@@ -110,37 +146,37 @@ const CORE_CAPABILITIES: CapabilityDescriptor[] = [
     risk: 'readonly',
     exposedVia: 'rh_work',
     schemaExposure: 'stable_static',
-    summary: 'Persist bounded pre-execution plans with frozen revisions, step acceptance criteria, explicit approval, and supersession before complex work creates an execution contract.',
+    summary: 'Persist model-authored Plan working memory with stable identity and semantic revision/CAS; Plan items do not own execution, checks, or acceptance.',
+  },
+  {
+    capabilityId: 'repository.validation',
+    domain: 'repository',
+    group: 'repository-core',
+    operationClass: 'execute',
+    risk: 'workspace_write',
+    exposedVia: 'capability_execute',
+    schemaExposure: 'stable_static',
+    summary: 'Refresh exact Work validation authority through the existing Work validation owner without adding a top-level MCP tool or command execution surface.',
   },
   {
     capabilityId: 'repository.git',
     domain: 'repository',
     group: 'git',
-    operationClass: 'finalize',
+    operationClass: 'write',
     risk: 'local_repo_write',
-    exposedVia: 'rh_work',
+    exposedVia: 'capability_execute',
     schemaExposure: 'stable_static',
-    summary: 'Use typed Git status, diff, branch, commit, integration, and cleanup handlers without routing arbitrary Git text through a facade RPC.',
+    summary: 'Repository-native typed Git handlers own identity, dirty-path, CAS, lease, conflict, authorization, and idempotency fences; Work completion is not a Git admission gate.',
   },
   {
-    capabilityId: 'workflow.issue_task',
+    capabilityId: 'workflow.durable_work',
     domain: 'controller',
     group: 'issue-task',
     operationClass: 'execute',
     risk: 'workspace_write',
     exposedVia: 'rh_work',
     schemaExposure: 'stable_static',
-    summary: 'Plan, dispatch, review, verify, retry, and accept durable Issue and Task work through existing typed handlers.',
-  },
-  {
-    capabilityId: 'plugin.browser',
-    domain: 'plugin',
-    group: 'browser',
-    operationClass: 'execute',
-    risk: 'unknown',
-    exposedVia: 'plugin_action_execute',
-    schemaExposure: 'stable_static',
-    summary: 'Use typed HTTP(S) browser navigation, snapshot, and interaction actions through plugin_action_execute when browser capability is configured.',
+    summary: 'Persist and schedule durable semantic Work. Work is open, completed, or cancelled; execution evidence is advisory and never an admission phase.',
   },
   {
     capabilityId: 'platform.ios',
@@ -184,6 +220,10 @@ function pluginCapabilityDescriptor(
   manifest: AssistantPluginManifest,
   action: AssistantPluginManifest['actions'][number],
 ): CapabilityDescriptor {
+  const semanticCapabilities = (manifest.capabilities ?? [])
+    .filter((capability) => capability.actions.includes(action.actionId))
+    .map((capability) => capability.capabilityId)
+    .sort();
   return {
     capabilityId: `plugin.${manifest.pluginId}.${action.actionId}`,
     domain: domainFromPlugin(manifest.pluginId),
@@ -193,6 +233,7 @@ function pluginCapabilityDescriptor(
     exposedVia: exposedViaFromPluginAction(action.readOnly, action.risk),
     schemaExposure: 'plugin_manifest',
     summary: `${manifest.displayName}: ${action.title}. ${action.description}`,
+    ...(semanticCapabilities.length > 0 ? { semanticCapabilities } : {}),
   } satisfies CapabilityDescriptor;
 }
 
@@ -225,8 +266,10 @@ function capabilityIntentTokens(query: string): string[] {
   return [...new Set(normalizedCapabilityText(query).split(' ').filter((token) => token.length >= 2))];
 }
 
-function intentBoosts(query: string, capabilityId: string): Array<{ label: string; score: number }> {
+function intentBoosts(query: string, descriptor: CapabilityDescriptor): Array<{ label: string; score: number }> {
   const normalized = normalizedCapabilityText(query);
+  const capabilityId = descriptor.capabilityId;
+  const semanticCapabilities = new Set(descriptor.semanticCapabilities ?? []);
   const boosts: Array<{ label: string; score: number }> = [];
   const appleDevelopmentIntent = /\b(xcode|provision|provisioning|signing|developer account|apple developer)\b/.test(normalized);
   if (appleDevelopmentIntent) {
@@ -235,20 +278,16 @@ function intentBoosts(query: string, capabilityId: string): Array<{ label: strin
     if (capabilityId === 'plugin.app_store_connect.auth_status') boosts.push({ label: 'apple-development', score: 88 });
     else if (capabilityId === 'plugin.app_store_connect.configure') boosts.push({ label: 'apple-development', score: 82 });
     else if (capabilityId.startsWith('plugin.app_store_connect.')) boosts.push({ label: 'apple-development', score: 28 });
-    if (capabilityId === 'plugin.desktop_operator.desktop_session_open') boosts.push({ label: 'xcode-desktop-fallback', score: 86 });
-    else if (capabilityId === 'plugin.desktop_operator.desktop_observe') boosts.push({ label: 'xcode-desktop-fallback', score: 78 });
-    else if (capabilityId === 'plugin.desktop_operator.desktop_press') boosts.push({ label: 'xcode-desktop-fallback', score: 74 });
-    else if (capabilityId.startsWith('plugin.desktop_operator.')) boosts.push({ label: 'xcode-desktop-fallback', score: 22 });
+    if (semanticCapabilities.has(COMPUTER_OBSERVE_CAPABILITY)) boosts.push({ label: 'xcode-computer-observe', score: 78 });
+    if (semanticCapabilities.has(COMPUTER_INPUT_CAPABILITY)) boosts.push({ label: 'xcode-computer-input', score: 74 });
+    if (semanticCapabilities.has(COMPUTER_CAPTURE_CAPABILITY)) boosts.push({ label: 'xcode-computer-capture', score: 44 });
   }
 
   const browserLoginIntent = normalized.includes('browser')
     && /\b(login|log in|signin|sign in|auth|authentication|session)\b/.test(normalized);
   if (browserLoginIntent) {
-    if (capabilityId === 'plugin.browser') boosts.push({ label: 'browser-auth', score: 90 });
-    else if (capabilityId.startsWith('plugin.browser.')) boosts.push({ label: 'browser-auth', score: 62 });
-    if (capabilityId === 'plugin.desktop_operator.desktop_session_open') boosts.push({ label: 'browser-desktop-fallback', score: 70 });
-    else if (capabilityId === 'plugin.desktop_operator.desktop_observe') boosts.push({ label: 'browser-desktop-fallback', score: 62 });
-    else if (capabilityId.startsWith('plugin.desktop_operator.')) boosts.push({ label: 'browser-desktop-fallback', score: 18 });
+    if (semanticCapabilities.has(COMPUTER_OBSERVE_CAPABILITY)) boosts.push({ label: 'browser-computer-observe', score: 90 });
+    if (semanticCapabilities.has(COMPUTER_INPUT_CAPABILITY)) boosts.push({ label: 'browser-computer-input', score: 82 });
   }
   return boosts;
 }
@@ -272,6 +311,7 @@ export function searchCapabilityDescriptors(
         descriptor.domain,
         descriptor.operationClass,
         descriptor.exposedVia,
+        ...(descriptor.semanticCapabilities ?? []),
       ].join(' '));
       let score = haystack.includes(normalizedQuery) ? 48 : 0;
       const matchedTerms = new Set<string>();
@@ -280,7 +320,7 @@ export function searchCapabilityDescriptors(
         matchedTerms.add(token);
         score += descriptor.capabilityId.toLowerCase().includes(token) ? 12 : 5;
       }
-      for (const boost of intentBoosts(query, descriptor.capabilityId)) {
+      for (const boost of intentBoosts(query, descriptor)) {
         score += boost.score;
         matchedTerms.add(boost.label);
       }
@@ -311,13 +351,309 @@ export function summarizeCapabilityGroups(manifests: readonly AssistantPluginMan
       capabilityCount: entries.length,
       domains: [...new Set(entries.map((entry) => entry.domain))].sort(),
       executionSurfaces: [...new Set(entries.map((entry) => entry.exposedVia))].sort(),
-      facadeTools: [...new Set(entries.map((entry) => entry.exposedVia).filter((surface): surface is FacadeTool => surface.startsWith('rh_')))].sort(),
+      facadeTools: [...new Set(entries.map((entry) => entry.exposedVia).filter((surface): surface is FacadeTool => FACADE_TOOLS.includes(surface as FacadeTool)))].sort(),
       operationClasses: [...new Set(entries.map((entry) => entry.operationClass))].sort(),
       risks: [...new Set(entries.map((entry) => entry.risk))].sort(),
       schemaExposures: [...new Set(entries.map((entry) => entry.schemaExposure))].sort(),
     }));
 }
 
+export function getCoreCapabilityExecutionSchema(capabilityId: string): Record<string, unknown> | undefined {
+  if (capabilityId === 'controller.connection') {
+    return {
+      capabilityId,
+      executeWith: 'capability_execute',
+      actions: {
+        get: {
+          readOnly: true,
+          risk: 'readonly',
+          argumentsSchema: { type: 'object', additionalProperties: false, properties: {} },
+        },
+        repair_connector: {
+          readOnly: false,
+          risk: 'workspace_write',
+          argumentsSchema: { type: 'object', additionalProperties: false, properties: {} },
+        },
+      },
+    };
+  }
+  if (capabilityId === 'controller.local_conversation') {
+    return {
+      capabilityId,
+      executeWith: 'capability_execute',
+      actions: {
+        status: {
+          readOnly: true,
+          risk: 'readonly',
+          argumentsSchema: { type: 'object', additionalProperties: false, properties: {} },
+        },
+        send: {
+          readOnly: false,
+          risk: 'workspace_write',
+          argumentsSchema: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['conversation_id', 'prompt'],
+            properties: {
+              conversation_id: { type: 'string', minLength: 1, maxLength: 160 },
+              provider_session_id: { type: 'string', minLength: 1, maxLength: 160 },
+              prompt: { type: 'string', minLength: 1, maxLength: 20_000 },
+              timeout_ms: { type: 'number', minimum: 5_000, maximum: 600_000 },
+            },
+          },
+        },
+      },
+    };
+  }
+  if (capabilityId === 'controller.round_recovery') {
+    return {
+      capabilityId,
+      executeWith: 'capability_execute',
+      actions: {
+        recover_and_dispose: {
+          readOnly: false,
+          risk: 'workspace_write',
+          argumentsSchema: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['work_id', 'recovery_reason', 'disposition', 'user_directed'],
+            properties: {
+              work_id: { type: 'string', minLength: 1, maxLength: 256 },
+              recovery_reason: { type: 'string', minLength: 1, maxLength: 1000 },
+              disposition: { type: 'string', enum: ['continue_immediately', 'wait', 'wait_for_user', 'goal_complete'] },
+              handoff_id: { type: 'string', minLength: 1, maxLength: 200 },
+              user_directed: { type: 'boolean', const: true },
+            },
+          },
+        },
+      },
+    };
+  }
+  if (capabilityId === 'controller.workflow_supervisor') {
+    return {
+      capabilityId,
+      executeWith: 'capability_execute',
+      actions: {
+        start: {
+          readOnly: false,
+          risk: 'workspace_write',
+          argumentsSchema: {
+            type: 'object', additionalProperties: false, required: ['objective'],
+            properties: { objective: { type: 'string', minLength: 1, maxLength: 4000 } },
+          },
+        },
+        list: {
+          readOnly: true,
+          risk: 'readonly',
+          argumentsSchema: {
+            type: 'object', additionalProperties: false,
+            properties: { active_only: { type: 'boolean' } },
+          },
+        },
+        get: {
+          readOnly: true,
+          risk: 'readonly',
+          argumentsSchema: {
+            type: 'object', additionalProperties: false, required: ['task_id'],
+            properties: { task_id: { type: 'string', minLength: 1, maxLength: 256 } },
+          },
+        },
+        revise: {
+          readOnly: false,
+          risk: 'workspace_write',
+          argumentsSchema: {
+            type: 'object', additionalProperties: false, required: ['task_id', 'objective', 'expected_objective_sha256'],
+            properties: {
+              task_id: { type: 'string', minLength: 1, maxLength: 256 },
+              objective: { type: 'string', minLength: 1, maxLength: 8000 },
+              expected_objective_sha256: { type: 'string', minLength: 64, maxLength: 64 },
+              authorized_by: { type: 'string', minLength: 1, maxLength: 256 },
+            },
+          },
+        },
+        switch_to_fresh_conversation: {
+          readOnly: false,
+          risk: 'workspace_write',
+          argumentsSchema: {
+            type: 'object', additionalProperties: false, required: ['task_id', 'expected_conversation_id', 'reason'],
+            properties: {
+              task_id: { type: 'string', minLength: 1, maxLength: 256 },
+              expected_conversation_id: { type: 'string', minLength: 1, maxLength: 256 },
+              reason: { type: 'string', minLength: 1, maxLength: 2000 },
+              authorized_by: { type: 'string', minLength: 1, maxLength: 256 },
+            },
+          },
+        },
+        recover: {
+          readOnly: false,
+          risk: 'workspace_write',
+          argumentsSchema: {
+            type: 'object', additionalProperties: false, required: ['task_id', 'reason'],
+            properties: {
+              task_id: { type: 'string', minLength: 1, maxLength: 256 },
+              reason: { type: 'string', minLength: 1, maxLength: 2000 },
+              source_effect_id: { type: 'string', minLength: 1, maxLength: 256 },
+              supersede_unknown: { type: 'boolean' },
+              authorized_by: { type: 'string', minLength: 1, maxLength: 256 },
+            },
+          },
+        },
+        stop: {
+          readOnly: false,
+          risk: 'workspace_write',
+          argumentsSchema: {
+            type: 'object', additionalProperties: false, required: ['task_id'],
+            properties: {
+              task_id: { type: 'string', minLength: 1, maxLength: 256 },
+              reason: { type: 'string', maxLength: 2000 },
+            },
+          },
+        },
+        proof: {
+          readOnly: true,
+          risk: 'readonly',
+          argumentsSchema: {
+            type: 'object', additionalProperties: false, required: ['active_release_id', 'not_before'],
+            properties: {
+              active_release_id: { type: 'string', minLength: 1, maxLength: 256 },
+              not_before: { type: 'string', minLength: 1, maxLength: 128 },
+            },
+          },
+        },
+      },
+    };
+  }
+  if (capabilityId === 'repository.direct_edit') {
+    return {
+      capabilityId,
+      executeWith: 'capability_execute',
+      actions: {
+        plan: {
+          readOnly: true,
+          risk: 'readonly',
+          argumentsSchema: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['operations'],
+            properties: {
+              operations: { type: 'array', minItems: 1, maxItems: 100, items: EDIT_OPERATION_INPUT_SCHEMA },
+              chunk_size: { type: 'number', minimum: 1, maximum: 100 },
+            },
+          },
+        },
+        apply: {
+          readOnly: false,
+          risk: 'local_repo_write',
+          argumentsSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+              work_id: { type: 'string', minLength: 1, maxLength: 256 },
+              session_id: { type: 'string', minLength: 1, maxLength: 256 },
+              purpose: { type: 'string', maxLength: 2000 },
+              operations: { type: 'array', minItems: 1, maxItems: 100, items: EDIT_OPERATION_INPUT_SCHEMA },
+              chunk_size: { type: 'number', minimum: 1, maximum: 100 },
+              expected_revision: { type: 'number', minimum: 0 },
+              allowed_paths: { type: 'array', maxItems: 128, items: { type: 'string', minLength: 1, maxLength: 1024 } },
+              continue_on_error: { type: 'boolean' },
+              refresh_fingerprints: { type: 'boolean' },
+              recover_stale_session: { type: 'boolean' },
+              check_ids: { type: 'array', maxItems: 32, items: { type: 'string', minLength: 1, maxLength: 256 } },
+              check_timeout_ms: { type: 'number', minimum: 1 },
+              lease_wait_ms: { type: 'number', minimum: 0 },
+              validation_request_id: { type: 'string', minLength: 1, maxLength: 256 },
+              validation_only: { type: 'boolean' },
+            },
+          },
+        },
+      },
+    };
+  }
+  if (capabilityId === 'repository.validation') {
+    return {
+      capabilityId,
+      executeWith: 'capability_execute',
+      actions: {
+        validate_work: {
+          readOnly: false,
+          risk: 'workspace_write',
+          argumentsSchema: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['work_id'],
+            properties: {
+              session_id: { type: 'string', minLength: 1, maxLength: 256 },
+              work_id: { type: 'string', minLength: 1, maxLength: 256 },
+              check_ids: { type: 'array', maxItems: 32, items: { type: 'string', minLength: 1, maxLength: 256 } },
+              interactive_wait_ms: { type: 'number', minimum: 0, maximum: 30000 },
+            },
+          },
+        },
+      },
+    };
+  }
+  if (capabilityId !== 'repository.git') return undefined;
+  return {
+    capabilityId,
+    executeWith: 'capability_execute',
+    actions: {
+      diff_paths: {
+        readOnly: true,
+        risk: 'readonly',
+        argumentsSchema: {
+          type: 'object',
+          additionalProperties: false,
+          required: ['paths'],
+          properties: {
+            paths: { type: 'array', minItems: 1, maxItems: 128, items: { type: 'string' } },
+            staged: { type: 'boolean' },
+            max_bytes: { type: 'number', minimum: 1024, maximum: 524288 },
+          },
+        },
+      },
+      stage_paths: {
+        readOnly: false,
+        risk: 'local_repo_write',
+        argumentsSchema: {
+          type: 'object',
+          additionalProperties: false,
+          required: ['paths'],
+          properties: {
+            paths: { type: 'array', minItems: 1, maxItems: 128, items: { type: 'string' } },
+          },
+        },
+      },
+      commit_paths: {
+        readOnly: false,
+        risk: 'local_repo_write',
+        argumentsSchema: {
+          type: 'object',
+          additionalProperties: false,
+          required: ['paths', 'message'],
+          properties: {
+            paths: { type: 'array', minItems: 1, maxItems: 128, items: { type: 'string' } },
+            message: { type: 'string', minLength: 1 },
+          },
+        },
+      },
+      deliver_work: {
+        readOnly: false,
+        risk: 'local_repo_write',
+        argumentsSchema: {
+          type: 'object',
+          additionalProperties: false,
+          required: ['work_id'],
+          properties: {
+            session_id: { type: 'string', minLength: 1, maxLength: 256 },
+            work_id: { type: 'string', minLength: 1, maxLength: 256 },
+            target_branch: { type: 'string', minLength: 1, maxLength: 512 },
+          },
+        },
+      },
+    },
+  };
+}
+
 export function getPluginActionCapabilitySchema(
   capabilityId: string,
   manifests: readonly AssistantPluginManifest[] = [],

package/src/runtime/control-plane/facade/check-normalization.ts

@@ -94,15 +94,9 @@ export function normalizeCheckIds(
     validCheckIds,
     invalidCheckIds,
     warnings,
-    suggestedNextActions: validCheckIds.map((checkId) => ({
-      label: `Run ${checkId}`,
-      tool: 'rh_work',
-      operation: 'verify',
-      payload: { check_id: checkId },
-      risk: 'workspace_write',
-      confidence: 'high',
-      reason: 'Check id exists in the repository check registry.',
-    })),
+    // Registered check ids are evidence for the model to invoke run_check directly.
+    // The facade does not translate them back into a retired Work verification verb.
+    suggestedNextActions: [],
   };
 }
 

package/src/runtime/control-plane/facade/codex-delegation.ts

@@ -8,7 +8,7 @@ import type {
 
 export type DelegateTarget = 'codex' | 'grok' | 'claude';
 
-/** @deprecated since 1.4.0; removed no earlier than 2026-12-31. Use controller_claim and handoff_create/read/accept. */
+/** @deprecated since 1.4.0; removed no earlier than 2026-12-31. Use launcher_start for an explicit external controller. */
 
 export interface CodexContextPack {
   schemaVersion: 1;
@@ -25,8 +25,8 @@ export interface CodexContextPack {
   currentEvidenceRefs: EvidenceRef[];
   workContractState?: {
     workId: string;
-    status: WorkContract['status'];
-    mode: WorkContract['mode'];
+    state: WorkContract['semanticState'];
+    dispatchState: WorkContract['dispatchState'];
   };
   policyDecision?: string;
   expectedOutputFormat: {
@@ -100,7 +100,7 @@ export function buildCodexContextPack(input: CodexDelegationInput & { repoId: st
     target,
     objective: (input.objective || work?.objective || '').slice(0, 2_000),
     acceptanceCriteria: (input.acceptanceCriteria ?? work?.acceptanceCriteria ?? []).slice(0, 20),
-    constraints: input.constraints ?? work?.constraints ?? { requireHandoffOnAmbiguity: true },
+    constraints: input.constraints ?? work?.constraints ?? {},
     relevantFilesSummary: (input.relevantFilesSummary ?? []).slice(0, 30).map((entry) => entry.slice(0, 200)),
     policyBoundaries: (input.policyBoundaries ?? [
       `${target} is an external controller, not a Kernel-managed executor.`,
@@ -108,13 +108,13 @@ export function buildCodexContextPack(input: CodexDelegationInput & { repoId: st
       'Do not push, merge, or perform destructive cleanup.',
       'Do not return raw secrets, tokens, auth config, or full runtime state.',
       'Output must be evidence / handoff / patch proposal / suggested_next_actions only.',
-      'ChatGPT must review before rh_work.finalize.',
+      'ChatGPT remains responsible for semantic review and explicit Work completion.',
     ]).slice(0, 20),
-    allowedPaths: (input.allowedPaths ?? work?.allowedPaths ?? []).slice(0, 50),
-    forbiddenPaths: (input.forbiddenPaths ?? work?.forbiddenPaths ?? ['.env', '_ops/secrets', '**/*secret*', '**/*token*']).slice(0, 50),
+    allowedPaths: (input.allowedPaths ?? []).slice(0, 50),
+    forbiddenPaths: (input.forbiddenPaths ?? ['.env', '_ops/secrets', '**/*secret*', '**/*token*']).slice(0, 50),
     currentEvidenceRefs: (input.evidenceRefs ?? work?.evidenceRefs ?? []).slice(0, 10),
     workContractState: work
-      ? { workId: work.workId, status: work.status, mode: work.mode }
+      ? { workId: work.workId, state: work.semanticState, dispatchState: work.dispatchState }
       : undefined,
     policyDecision: input.policyDecision,
     expectedOutputFormat: {
@@ -154,7 +154,7 @@ export function prepareGrokDelegateRequest(
       'Act as a parallel small-brain reviewer/implementer for ChatGPT.',
       'Return only bounded evidence, patch proposal, and suggested next actions.',
       'Do not finalize work, push, or request secrets.',
-      'ChatGPT remains the primary controller and must review before finalize.',
+      'ChatGPT remains responsible for semantic review; Forge does not impose a finalize phase.',
     ],
     directExecutionAvailable: false,
     returnPath: 'evidence_or_handoff_for_chatgpt_review',
@@ -177,7 +177,7 @@ export function delegateToCodexCerebellum(
   });
   return buildFacadeResult({
     status: 'blocked',
-    summary: 'DEPRECATED_DELEGATE: delegate is read-only through 2026-12-31 and will be removed in 1.5.0. Use controller_claim, launcher_start, and rh_inbox.create/accept.',
+    summary: 'DEPRECATED_DELEGATE: delegate is read-only through 2026-12-31 and will be removed in 1.5.0. Use launcher_start for an explicit external controller and the inbox only for genuine human decisions.',
     data: {
       target,
       workId: input.workId,
@@ -189,7 +189,6 @@ export function delegateToCodexCerebellum(
       workerOutputIgnored: input.workerOutput !== undefined,
     },
     suggestedNextActions: input.workId ? [
-      { label: 'Claim controller ownership', tool: 'rh_work', operation: 'controller_claim', payload: { work_id: input.workId }, risk: 'workspace_write' },
       { label: 'Start external controller', tool: 'rh_work', operation: 'launcher_start', payload: { work_id: input.workId, controller_type: target }, risk: 'workspace_write' },
     ] : [],
   });