@moretea-labs/forge 1.8.0 → 1.8.1

package/adapters/mcp/runtime-gateway/runtime-tool-definitions.ts

@@ -1,6 +1,7 @@
 import type { McpToolDefinition } from '../../../packages/protocols/mcp/tool-contract';
-import { CONTROLLER_CONTEXT_IMPACT_DOMAINS } from '../../../src/cli/controller/context-pack';
-import { RH_WORK_OPERATIONS } from '../../../src/runtime/control-plane/facade/rh-work-operation-contract';
+import { CONTROLLER_CONTEXT_IMPACT_DOMAINS } from '../../../src/cli/controller/context/types';
+import { RH_WORK_MODEL_OPERATIONS } from '../../../src/runtime/control-plane/facade/rh-work-operation-contract';
+import { CONTROLLER_LEARNING_SIGNAL_ENVELOPE_MAX_ITEMS } from '../../../src/runtime/context/automatic-learning';
 
 function definition(name: string, description: string, properties: Record<string, unknown>, required: string[] = [], readOnly = true): McpToolDefinition {
   return {
@@ -23,26 +24,40 @@ export const runtimeToolDefinitions: McpToolDefinition[] = [
     chatgpt_pull_failed: { type: 'boolean' },
     destructive: { type: 'boolean' },
   }),
-  definition('rh_inbox', 'Preferred ChatGPT facade: pending handoff decisions only (not logs).', {
-    repo_id: repoId,
+  definition('rh_inbox', 'Preferred ChatGPT facade: instance-level UserRequest inbox for genuine human actions/decisions. Repository-scoped handoff_id remains a legacy compatibility lookup.', {
+    repo_id: { ...repoId, description: 'Optional legacy repository context. Omit for canonical instance-level UserRequest operations.' },
     operation: { type: 'string', enum: ['list', 'get', 'ack', 'accept', 'resolve', 'dismiss', 'create'], description: 'Defaults to list (pending).' },
-    handoff_id: { type: 'string' },
+    request_id: { type: 'string', description: 'Canonical instance-level UserRequest id.' },
+    handoff_id: { type: 'string', description: 'Legacy compatibility id.' },
     work_id: { type: 'string' },
     title: { type: 'string' },
     reason: { type: 'string' },
     summary: { type: 'string' },
     recommended_decision: { type: 'string' },
     recommended_prompt: { type: 'string' },
+    action_required: { type: 'string', enum: ['login', 'grant_permission', 'confirm_destructive', 'product_decision'] },
+    request_kind: { type: 'string', enum: ['user_action_request', 'user_decision_request'] },
+    root_cause_key: { type: 'string' },
     decision: { type: 'string', description: 'Recorded on resolve/dismiss.' },
     resolver: { type: 'string', description: 'Who resolved or dismissed the handoff.' },
     detail_level: { type: 'string', enum: ['summary', 'detail'] },
     limit: { type: 'number' },
   }),
-  definition('rh_context', 'Preferred ChatGPT facade and default repository code-discovery/read path. Start broad once to combine heuristic lexical discovery, current raw source, and optional CodeGraph structural evidence with few round trips. Natural-language lexical terms are discovery hints: do not require every guessed term to match and do not repeat the same broad search merely because a heuristic term missed. After credible files or symbols are found, derive follow-up paths/symbols from the returned source and prefer known_paths, compiler semantic_navigation/@tsnav for TypeScript, or structural relationships before another broad lexical pass. Call rh_context repeatedly only when that progressive expansion can materially improve correctness; follow-ups reuse session-scoped evidence when source identity is unchanged. Shell rg/grep/sed/cat loops are fallback-only when this Context Plane cannot supply the needed evidence.', {
+  definition('rh_context', 'Preferred ChatGPT facade and default repository code-discovery/read path. Semantic task/capability queries can also recall an initial bounded, relevance-gated Cognitive advisory working set when Project/Workspace scope is available. That first pack is an attention envelope, never a claim that the top N items are cognitively complete. Reuse it through routine micro-steps; when the model judges prior context insufficient, progressively narrow/expand recall with another semantic query or explicit knowledge audit. Start broad once to combine heuristic lexical discovery, current raw source, and optional CodeGraph structural evidence with few round trips. Natural-language lexical terms are discovery hints: do not require every guessed term to match and do not repeat the same broad search merely because a heuristic term missed. After credible files or symbols are found, derive follow-up paths/symbols from the returned source and prefer known_paths, compiler semantic_navigation/@tsnav for TypeScript, or structural relationships before another broad lexical pass. Call rh_context repeatedly only when that progressive expansion can materially improve correctness; follow-ups reuse session-scoped evidence when source identity is unchanged. Shell rg/grep/sed/cat loops are fallback-only when this Context Plane cannot supply the needed evidence.', {
     repo_id: repoId,
     checkout_id: { type: 'string', description: 'Optional checkout identity for repositories with multiple worktrees.' },
     operation: { type: 'string', enum: ['list', 'get', 'search'], description: 'Defaults to get. Use search as the default code-location path when an exact file is unknown.' },
     query: { type: 'string', description: 'Code/content intent for operation=search. For operation=list, a natural-language capability intent such as "configure Xcode provisioning" returns ranked read-only capability candidates while execution remains on the capability\'s typed executor. Frozen-schema clients may append @tsnav or @swiftnav references|definition|implementations <repo-path>:<line>:<column> for compiler/LSP-backed semantic navigation.' },
+    include_learning_recall: { type: 'boolean', description: 'Defaults to true for semantic task/capability queries. Set false for routine progressive source follow-ups or micro-steps when the already recalled working set is still valid. This is a model-owned attention/cadence choice, not a Forge semantic trigger.' },
+    knowledge_query: { type: 'string', description: 'Optional explicit read-only Cognitive audit query. Ordinary code/capability intent queries already receive a bounded relevant-learning recall; use this field for deliberate memory inspection. May be used without code query. Use "*" or omit text with filters to list learned advisory memory in scopes reachable from this repo/Work.' },
+    knowledge_memory_id: { type: 'string', description: 'Optional exact Cognitive memory id for inspection.' },
+    knowledge_scope_kind: { type: 'string', enum: ['work', 'requirement', 'plan', 'plan_step', 'project', 'workspace'], description: 'Optional Cognitive scope filter; it must already be reachable from the selected repo/Work.' },
+    knowledge_scope_id: { type: 'string', description: 'Optional Cognitive scope id paired with knowledge_scope_kind.' },
+    knowledge_concept: { type: 'string', description: 'Optional exact learned concept filter.' },
+    knowledge_facet: { type: 'string', description: 'Optional exact learned facet filter.' },
+    knowledge_source_kind: { type: 'string', enum: ['experience', 'outcome', 'knowledge', 'controller', 'system', 'external'], description: 'Optional provenance source-kind filter.' },
+    knowledge_source_work_id: { type: 'string', description: 'Optional provenance source Work filter.' },
+    knowledge_limit: { type: 'number', minimum: 1, maximum: 100, description: 'Per-call read envelope for explicit Cognitive audit/expansion; defaults to 24. This is a context/transport budget, not a semantic claim that N memories are sufficient.' },
     known_paths: { type: 'array', items: { type: 'string' }, description: 'Optional exact paths or globs that should receive highest retrieval priority.' },
     include_globs: { type: 'array', items: { type: 'string' } },
     exclude_globs: { type: 'array', items: { type: 'string' } },
@@ -52,7 +67,7 @@ export const runtimeToolDefinitions: McpToolDefinition[] = [
     semantic_navigation: {
       type: 'array',
       maxItems: 8,
-      description: 'Optional bounded semantic navigation through the provider registry. TypeScript uses the in-process Language Service; Swift uses SourceKit-LSP only with existing build settings; registered generic LSP providers currently cover Rust, Go, Python, and C/C++ when their language-server executable and project root markers already exist. Providers start lazily only for explicit semantic requests; Forge never installs a server, triggers a build, or treats language-server output as source authority.',
+      description: 'Optional bounded semantic navigation through the provider registry. TypeScript uses a short-lived release-owned Language Service sidecar so compiler/project allocator growth never remains resident in the canonical Runtime; Swift uses SourceKit-LSP only with existing build settings; registered generic LSP providers currently cover Rust, Go, Python, and C/C++ when their language-server executable and project root markers already exist. Providers start lazily only for explicit semantic requests; Forge never installs a server, triggers a build, or treats language-server output as source authority.',
       items: {
         type: 'object',
         required: ['navigation', 'path', 'line', 'column'],
@@ -74,59 +89,73 @@ export const runtimeToolDefinitions: McpToolDefinition[] = [
     work_id: { type: 'string' },
     detail_level: { type: 'string', enum: ['summary', 'detail', 'raw'], description: 'Defaults to summary; raw is still bounded.' },
   }),
-  definition('rh_work', 'Preferred ChatGPT facade for bounded execution, optional Requirement authority, optional planning, controller ownership, and external SuperController launch. Requirement and Plan are not universal prerequisites: start explicit bounded work directly when safe, establish Requirement authority only when durable goal identity is useful, and use Plan only for real decomposition, dependency ordering, or replanning.', {
+  definition('rh_work', 'Preferred ChatGPT facade for optional durable Requirement/Plan/Work semantic context, explicit recovery, scheduling/workflow intent, and external controller launch. Ordinary execution and validation use direct domain capabilities; provider/session binding, retries, transport recovery, dedupe, and other mechanical bookkeeping stay internal.', {
     repo_id: repoId,
     checkout_id: { type: 'string', description: 'Optional checkout identity for exact Work and Plan source selection.' },
-    operation: { type: 'string', enum: [...RH_WORK_OPERATIONS], description: 'Defaults to start. controller_disposition records ChatGPT\'s explicit end-of-round continue/wait decision; Forge never infers the semantic next step. requirement_create establishes optional durable Requirement authority only and never implies plan_create. requirement_continue records an explicit semantic continue for a Requirement waiting_for_user and resumes it to active without creating a new Work or Plan. Plan-bound starts require plan_id and plan_step_id, but Plan is a late semantic commitment for real decomposition/replanning rather than a universal complex-task wrapper. plan_accept_step records explicit Controller semantic acceptance after machine delivery leaves a step validating. schedule_* manages Work-bound continuation, bounded browser observation, and explicit standalone browser keepalive.' },
+    operation: { type: 'string', enum: [...RH_WORK_MODEL_OPERATIONS], description: 'Defaults to start. list reads current semantic Work plus a bounded recent terminal history for the selected repository; start creates semantic Work context only. Requirement, Plan, and Work remain model-authored durable semantic records; execution and validation use direct capabilities. Work completion is an explicit semantic update rather than an execution phase transition.' },
+    limit: { type: 'number', minimum: 1, maximum: 100, description: 'Bounded result limit for list operations.' },
     objective: { type: 'string' },
-    capability_id: { type: 'string', description: 'Legacy-readable compatibility input. operation=repair maps semantic.v1:<bounded-payload> only to an explicitly allowlisted forward-compatible semantic facade operation and then re-enters its canonical Runtime handler; current allowlist supports requirement_create, plan_create obligation continuity, and bounded start technical admission fields (work_kind, engineering_preconditions, paired controller_authority_id/relay_scope_id) while requirement_id remains an explicit stable field. Existing compatibility forms also map schedule.delete:<scheduleId>, controller.disposition:<disposition>:<relayScopeId> for live-owner rounds or controller.disposition:<disposition>:<authorityId>:<relayScopeId> for exact terminal closure, controller.round:<operation>:<authorityId>:<relayScopeId> including plan_accept_step, controller.authority.recover:<workId>, plan.step.retry:<workId>, and work.review:<decision>:<workId> without creating alternate lifecycle or persistence authority.' },
+    capability_id: { type: 'string', description: 'Compatibility-only carrier. Current callers should use typed rh_work fields directly. The outer adapter accepts only the bounded frozen semantic.v1 bridge and current-conversation enrollment, validates them without persistence, and routes them into the same Thin owners.' },
     work_id: { type: 'string' },
     workflow_id: { type: 'string', description: 'Versioned Workflow asset identity for workflow_execute/workflow_reconcile.' },
     workflow_run_id: { type: 'string', description: 'Stable run identity. Reusing it resumes only the exact same workflow/content/input identity.' },
     workflow_inputs: { type: 'object', description: 'Typed Workflow inputs validated against the installed asset contract.' },
     workflow_scope_project_id: { type: 'string', description: 'Optional project-scoped Workflow registry identity. First-party Xiaohongshu assets use controller scope and still validate the owning Work project/account inputs.' },
     workflow_reconciliation_request_id: { type: 'string', description: 'Fresh idempotency identity for one reconciliation observation. Retry the same observation with the same id; use a new id only for a later observation.' },
-    related_work_id: { type: 'string', description: 'Optional explicit existing Work ownership target for continue/extend semantics. Unrelated active Work is never inferred as a semantic target.' },
-    work_relation: { type: 'string', enum: ['continue', 'extend', 'parallel', 'new_goal'], description: 'Optional semantic relation to an explicitly related Work. This field never selects Direct/Process/Durable execution depth; checkout conflicts are resolved by placement.' },
-    related_plan_id: { type: 'string', description: 'Explicit existing Plan target for compatibility extend/revision semantics. Requirement membership alone never selects a related Plan.' },
-    plan_relation: { type: 'string', enum: ['extend', 'parallel'], description: 'Compatibility relation to an explicitly related Plan. Requirement membership alone never requires a relation. extend revises the related stable Plan identity in place (draft repair or durable committed revision); parallel remains accepted for older clients, while a distinct scope can create directly without it.' },
-    requested_by: { type: 'string', enum: ['chatgpt', 'user', 'system', 'scheduler'], description: 'Origin of the request. Scheduler-origin starts are continuation-only and cannot create new durable Work.' },
-    requirement_id: { type: 'string', description: 'Stable Requirement authority for requirement_create/requirement_continue or optional authority used to find related active Work before creation; ordinary Work may start without Requirement or Plan authority.' },
+    requirement_id: { type: 'string', description: 'Stable Requirement identity for requirement_get/requirement_revise/requirement_create or optional semantic context link for Work/Plan.' },
+    expected_revision: { type: 'number', minimum: 1, description: 'Expected current semantic revision for requirement_revise, plan_revise, revise, or complete. Stale writers fail and return current state; Forge never performs an implicit merge.' },
+    work_state: { type: 'string', enum: ['open', 'completed', 'cancelled'], description: 'Thin semantic Work state for revise.' },
+    work_result_refs: { type: 'array', maxItems: 100, uniqueItems: true, items: { type: 'string', maxLength: 512 }, description: 'Model/user-selected result references for thin semantic Work; separate from mechanical evidence and delivery receipts.' },
+    semantic_parent_work_id: { type: 'string', minLength: 1, maxLength: 256, description: 'Optional objective-decomposition parent for primary semantic Work. Distinct from execution parentWorkId and continuation lineage.' },
+    depends_on_work_ids: { type: 'array', maxItems: 32, uniqueItems: true, items: { type: 'string', minLength: 1, maxLength: 256 }, description: 'Explicit semantic ordering dependencies for primary Work. No edge means siblings may proceed independently; this field never dispatches or blocks Scheduler execution by itself.' },
+    requirement_revision: { type: 'number', minimum: 1, description: 'Work start defaults to selected Requirement head; Work revise explicitly adopts an existing semantic revision via expected_revision CAS, including historical revisions. For Plan, optional provenance.' },
+    plan_revision: { type: 'number', minimum: 1, description: 'Work start defaults to selected Plan head; Work revise explicitly adopts an existing semantic revision via expected_revision CAS, including historical revisions. Work get compares adopted and current heads without rebinding.' },
     requirement_title: { type: 'string', description: 'Human-readable Requirement title for requirement_create.' },
     requirement_outcome: { type: 'string', description: 'Durable outcome statement for requirement_create.' },
     requirement_acceptance_criteria: { type: 'array', items: { type: 'string' }, description: 'Bounded semantic acceptance criteria for requirement_create.' },
     requirement_delivery_references: { type: 'array', items: { type: 'string' }, description: 'Optional durable delivery/reference identifiers for requirement_create.' },
     requirement_legacy_aliases: { type: 'array', items: { type: 'string' }, description: 'Optional migration aliases for requirement_create; not a second identity authority.' },
-    handoff_id: { type: 'string', description: 'Optional existing HandoffItem used to resume controller context. Required for controller_disposition=wait_for_user.' },
-    disposition: { type: 'string', enum: ['continue_immediately', 'wait', 'wait_for_user', 'goal_complete'], description: 'Explicit ChatGPT end-of-round semantic decision. continue_immediately is consumed only after the current controller lease closes.' },
-    relay_scope_id: { type: 'string', description: 'Stable Requirement/Goal relay identity. Requirement-bound Work uses requirement:<id>; otherwise reuse the exact returned goal scope across Works.' },
-    controller_authority_id: { type: 'string', description: 'Opaque durable authority for the currently dispatched ChatGPT controller round. Required with relay_scope_id for lifecycle mutation of relay-bound Work; rotates before a successor round while surviving MCP transport/Runtime rotation within the same round.' },
-    assistant_context_digest: { type: 'string', description: 'Exact digest returned at controller_claim for the context snapshot whose items are being classified at round close.' },
-    assistant_context_usage: { type: 'array', maxItems: 32, items: { type: 'object', additionalProperties: false,
-      properties: { kind: { type: 'string', enum: ['knowledge', 'experience'] }, itemId: { type: 'string' }, decision: { type: 'string', enum: ['used', 'rejected'] }, reason: { type: 'string', maxLength: 1000 } },
-      required: ['kind', 'itemId', 'decision', 'reason'] }, description: 'Exact claim-time context items classified as used or rejected. If supplied, every delivered item must be classified; omitted usage remains an explicit coverage gap.' },
-    execution_quality_decisions: { type: 'array', maxItems: 8, items: { type: 'object', additionalProperties: false,
-      properties: { fingerprint: { type: 'string' }, action: { type: 'string', enum: ['no_adjustment', 'adjustment'] },
-        reason: { type: 'string', maxLength: 1000 }, verificationCondition: { type: 'string', maxLength: 1000 } },
-      required: ['fingerprint', 'action', 'reason'] }, description: 'Controller diagnosis of delivered execution-quality signals. Adjustments require an explicit verification condition; budgets and mandatory checks remain unchanged.' },
-    execution_quality_adjustment_results: { type: 'array', maxItems: 8, items: { type: 'object', additionalProperties: false,
-      properties: { fingerprint: { type: 'string' }, outcome: { type: 'string', enum: ['improved', 'not_improved', 'inconclusive'] }, evidenceRefs: { type: 'array', maxItems: 16, items: { type: 'string' } }, reason: { type: 'string', maxLength: 1000 } },
-      required: ['fingerprint', 'outcome', 'evidenceRefs', 'reason'] }, description: 'Post-adjustment result for a prior adjustment decision. Every evidenceRef must be a Work check receipt recorded after that decision; the result never resets ControllerRound budgets.' },
-    outcome_observation: { type: 'object', description: 'Typed OutcomeObservation draft for outcome_record. sourceWorkId/sourceRoundId are derived from the exact current Controller authority and cannot be supplied by the caller.' },
-    experience_draft: { type: 'object', description: 'Typed Experience draft for experience_record. source Work/Round authority is derived from the current Controller claim.' },
-    quality_adjustment_fingerprint: { type: 'string', description: 'Optional quality adjustment fingerprint. When present, experience_record requires a verified non-inconclusive adjustment result and includes all of its verification receipts as evidence.' },
-    state_fingerprint: { type: 'string', description: 'Optional controller-observed semantic-state fingerprint. When omitted, Forge derives a mechanical fingerprint from current Requirement/Work/Handoff state.' },
-    max_rounds: { type: 'number', description: 'Mechanical immediate-relay round budget; defaults to 8 and cannot be loosened within an existing relay scope.' },
-    max_repeated_state: { type: 'number', description: 'Mechanical repeated-state fence; defaults to 2 repeated observations and cannot be loosened within an existing relay scope.' },
-    controller_id: { type: 'string', description: 'Stable external SuperController identity for controller_claim/release.' },
-    controller_type: { type: 'string', enum: ['chatgpt', 'codex', 'grok', 'claude', 'human'], description: 'Controller kind for claims and launcher_start.' },
-    session_id: { type: 'string', description: 'Controller-owned session identity used for an exclusive Work lease.' },
-    lease_ms: { type: 'number', description: 'Authenticated Controller ownership lease duration, bounded to one hour. Legacy launcher callers may still use this as a launch-reservation TTL.' },
+    requirement_state: { type: 'string', enum: ['open', 'completed', 'cancelled'], description: 'Thin semantic Requirement state for requirement_revise.' },
+    requirement_candidate_id: { type: 'string', description: 'Exact Cognitive memory id for operation=requirement_promote_candidate.' },
+    handoff_id: { type: 'string', description: 'Optional existing HandoffItem to include as bounded context for launcher_start.' },
+    learning_signals: { type: 'array', maxItems: CONTROLLER_LEARNING_SIGNAL_ENVELOPE_MAX_ITEMS, items: { type: 'object', additionalProperties: false,
+      properties: {
+        scope_kind: { type: 'string', enum: ['work', 'requirement', 'project', 'workspace'] },
+        kind: { type: 'string', maxLength: 64, description: 'Compact model-authored descriptive kind (for example principle, procedure, product-model, architecture-pattern). This vocabulary is open and never an admission gate.' },
+        valence: { type: 'string', enum: ['positive', 'negative', 'neutral'] },
+        summary: { type: 'string', maxLength: 2000 },
+        concepts: { type: 'array', minItems: 1, maxItems: 32, uniqueItems: true, items: { type: 'string', maxLength: 256 } },
+        facets: { type: 'array', maxItems: 12, uniqueItems: true, items: { type: 'string', maxLength: 128 } },
+        admission_source: { type: 'string', enum: ['explicit_human', 'controller_observation', 'system_inference'] },
+        portability: { type: 'string', enum: ['local', 'portable'] },
+        salience: { type: 'number', minimum: 0, maximum: 1 },
+        confidence: { type: 'number', minimum: 0, maximum: 1 },
+        utility: { type: 'number', minimum: 0, maximum: 1 },
+        evidence_refs: { type: 'array', maxItems: 16, uniqueItems: true, items: { type: 'string', maxLength: 512 } },
+        counter_evidence_refs: { type: 'array', maxItems: 16, uniqueItems: true, items: { type: 'string', maxLength: 512 } },
+        expires_at: { type: 'string' },
+      },
+      required: ['scope_kind', 'kind', 'valence', 'summary', 'concepts', 'admission_source', 'portability', 'salience', 'confidence', 'utility'] },
+      description: 'Model-authored semantic deltas, never keyword/phrase-derived lessons. The array bound is only one MCP transport envelope; it is not a per-interaction learning quota. With operation=learning_record, project/workspace learning is lifecycle-free; when work_id is selected, its server-derived reachable Work/Requirement scopes are also available through the same writer. Distill reusable judgement/procedure/product/architecture knowledge rather than copying raw transcripts or source prose.' },
+    learning_feedback: { type: 'array', maxItems: 32, items: { type: 'object', additionalProperties: false,
+      properties: {
+        memory_address: { type: 'string', maxLength: 1024, description: 'Exact stable memoryId/address returned by learningRecall or Cognitive audit.' },
+        decision: { type: 'string', enum: ['used', 'rejected'] },
+        reason: { type: 'string', maxLength: 1000 },
+        rejection_kind: { type: 'string', enum: ['irrelevant', 'stale', 'contradicted'], description: 'Required only for rejected feedback. Semantic classification is model-authored, never inferred from keywords.' },
+      },
+      required: ['memory_address', 'decision', 'reason'] },
+      description: 'Lifecycle-free advisory retrieval feedback for operation=learning_feedback. The current principal/session and repository-reachable Cognitive scope are server-derived; feedback influences retrieval utility only and never factual confidence or execution authority.' },
+    outcome_observation: { type: 'object', description: 'Typed Work-specific OutcomeObservation draft for outcome_record. Work semantic provenance is derived server-side and cannot be supplied by the caller.' },
+    experience_draft: { type: 'object', description: 'Typed verified Work Experience draft for experience_record. Generic teaching/correction belongs in learning_record instead; source provenance is derived from current Work semantic context.' },
+    quality_adjustment_fingerprint: { type: 'string', description: 'Optional quality adjustment fingerprint for experience_record when backed by verified evidence.' },
+    controller_type: { type: 'string', enum: ['chatgpt', 'codex', 'grok', 'claude'], description: 'External controller kind for launcher_start.' },
     launch_reservation_ms: { type: 'number', description: 'Short duplicate-spawn reservation TTL for launcher_start or schedule_create; does not grant Work ownership.' },
     executable: { type: 'string', description: 'External controller executable for launcher_start. This is owned by the Launcher, not the Kernel.' },
     launch_args: { type: 'array', items: { type: 'string' }, description: 'Provider-specific arguments for launcher_start.' },
     browser_session_id: { type: 'string', description: 'Saved Forge ChatGPT browser session to continue when controller_type=chatgpt.' },
     conversation_url: { type: 'string', description: 'Explicit https://chatgpt.com conversation URL used when no saved Forge browser session exists.' },
+    transport_conversation: { type: 'string', enum: ['bound', 'fresh'], description: 'ChatGPT launcher transport only. When omitted, an existing Work binding or explicit conversation_url is reused; otherwise a fresh conversation is created. bound requires an existing binding or explicit conversation_url. fresh always starts a new conversation and records transport metadata after provider delivery is observed.' },
     continuation_prompt: { type: 'string', description: 'Bounded Work continuation instruction.' },
     schedule_id: { type: 'string', description: 'Schedule identity for schedule_get/pause/resume/delete/trigger.' },
     schedule_name: { type: 'string', description: 'Human-readable schedule name.' },
@@ -163,151 +192,23 @@ export const runtimeToolDefinitions: McpToolDefinition[] = [
     backoff_max_minutes: { type: 'number' },
     include_occurrences: { type: 'boolean' },
     plan_id: { type: 'string' },
-    plan_step_id: { type: 'string', description: 'PlanContract step identity. Used to bind a complex Goal Workloop start and to accept a validating step.' },
-    acceptance_rationale: { type: 'string', description: 'Controller rationale for plan_accept_step after reviewing the completed Work evidence against the Plan step acceptance criteria.' },
-    scope_key: { type: 'string', description: 'Stable normalized scope identity used to prevent overlapping active plans.' },
+    superseded_by: { type: 'string', description: 'For plan_revise only: record the one-way successor Plan lineage. Once set it cannot be cleared or redirected; current Plan listings exclude the predecessor without restoring legacy Plan lifecycle semantics.' },
+    scope_key: { type: 'string', description: 'Optional normalized semantic scope label for Plan discovery/lineage; it is not execution ownership or a repository mutex.' },
     source_revision: { type: 'string', description: 'Repository revision observed during read-only planning preflight.' },
-    plan_steps: { type: 'array', items: { type: 'object' }, description: 'Bounded plan steps with id, objective, dependencies, authoritative_files, allowed_paths, forbidden_paths, check_ids, and acceptance_criteria.' },
+    plan_items: { type: 'array', maxItems: 100, items: { type: 'object', required: ['id', 'objective'], additionalProperties: false, properties: { id: { type: 'string', maxLength: 200 }, objective: { type: 'string', maxLength: 2000 }, dependencies: { type: 'array', maxItems: 100, items: { type: 'string', maxLength: 200 } } } }, description: 'Thin model-authored Plan items for plan_create/plan_revise. Items are descriptive working memory only and never own paths, checks, Work, scheduling, or acceptance.' },
     non_goals: { type: 'array', items: { type: 'string' } },
     assumptions: { type: 'array', items: { type: 'string' } },
     resolved_decisions: { type: 'array', items: { type: 'string' } },
     stop_conditions: { type: 'array', items: { type: 'string' } },
     replan_conditions: { type: 'array', items: { type: 'string' } },
     integration_strategy: { type: 'string' },
-    obligation_dispositions: { type: 'array', items: { type: 'object' }, description: 'For successor Plans, explicit predecessor obligation reconciliation. Each item carries predecessor_plan_id, obligation_id, disposition keep/change/defer/drop, successor_refs, and rationale for change/defer/drop.' },
-    superseded_by: { type: 'string', description: 'For plan_supersede, the explicit replacement Plan id. For legacy active Plan-bound Work scope repair, a compatibility revision label only; the stable Plan identity is not replaced.' },
-    expected_files: { type: 'number' },
-    expected_changed_lines: { type: 'number' },
-    mode: { type: 'string', enum: ['plan', 'scale'], description: 'Explicit durable Plan/Scale mode for start. Plan binds one approved PlanContract delivery step without implying isolation; Scale additionally coordinates parallel delivery through existing Work/Process/resource-claim authorities.' },
-    work_kind: { type: 'string', enum: ['repository_change', 'completed_no_change', 'read_only_review', 'investigation', 'local_effect', 'remote_effect', 'reconciliation'], description: 'Explicit technical Work evidence shape for operation=start. read_only_review is a recoverable source-frozen review lifecycle: it permits inspected-path/finding persistence without repository edits and only clean-finalizes after unchanged-source proof. local_effect/remote_effect represent effect-only execution; completed_no_change/investigation/reconciliation likewise do not imply a source mutation. None imply semantic completion; ChatGPT must still explicitly finalize after reviewing evidence.' },
-    scope_clear: { type: 'boolean' },
-    requires_investigation: { type: 'boolean' },
-    requires_long_running_checks: { type: 'boolean' },
-    requires_parallelism: { type: 'boolean' },
-    needs_dependencies: { type: 'boolean' },
-    requires_recovery: { type: 'boolean' },
-    requires_worker: { type: 'boolean', description: 'Opt-in only. Set true only when the user explicitly requests Codex/Claude or another agent worker; never infer it from task complexity.' },
-    requires_external_effect: { type: 'boolean' },
-    requires_approval: { type: 'boolean' },
-    requires_user_approval: { type: 'boolean' },
-    destructive: { type: 'boolean' },
-    remote_write: { type: 'boolean' },
-    secret_access: { type: 'boolean' },
     approval_confirmed: { type: 'boolean' },
     dry_run: { type: 'boolean', description: 'Defaults to true for repair.' },
-    check_ids: { type: 'array', items: { type: 'string' }, description: 'Requested checks. Before launching multiple checks concurrently, call rh_context with requested_check_ids to read resource-compatible checkScheduling waves; do not overlap checks from different waves.' },
-    check_id: { type: 'string' },
-    acceptance_criteria: { type: 'array', items: { type: 'string' } },
-    allowed_paths: { type: 'array', items: { type: 'string' } },
-    initial_likely_paths: { type: 'array', items: { type: 'string' }, description: 'Non-authoritative first-pass discovery candidates. May expand after investigation; allowed_paths remains a policy fence only.' },
-    engineering_preconditions: {
-      type: 'object',
-      description: 'Semantic precondition draft for start/continue. Context Closure must be the complete rh_context receipt; Product DoD, Design and independent critique are semantic content. Forge validates current source/provenance and mints the durable receipt ids server-side; raw caller-supplied evidence ids are never accepted as admission authority.',
-      properties: {
-        context_closure: { type: 'object' },
-        product_dod: { type: 'object', properties: {
-          user_outcome: { type: 'string' },
-          completion_conditions: { type: 'array', items: { type: 'string' } },
-          non_regression: { type: 'array', items: { type: 'string' } },
-          performance_expectations: { type: 'array', items: { type: 'string' } },
-          non_goals: { type: 'array', items: { type: 'string' } },
-        }, required: ['user_outcome', 'completion_conditions', 'non_regression', 'performance_expectations', 'non_goals'], additionalProperties: false },
-        design_decision: { type: 'object', properties: {
-          semantic_scope_keys: { type: 'array', items: { type: 'string' } },
-          mutation_class: { type: 'string', enum: ['readonly', 'isolated_write', 'integration_write', 'external_effect'] },
-          supersedes_receipt_id: { type: 'string' },
-          decisions: { type: 'object', properties: {
-            ownership: { type: 'string' }, single_writer: { type: 'string' }, transaction: { type: 'string' }, lifecycle: { type: 'string' }, concurrency: { type: 'string' }, persistence: { type: 'string' }, failure: { type: 'string' }, projection_cache: { type: 'string' }, time: { type: 'string' }, performance: { type: 'string' }, compatibility: { type: 'string' },
-          }, required: ['ownership', 'single_writer', 'transaction', 'lifecycle', 'concurrency', 'persistence', 'failure', 'projection_cache', 'time', 'performance', 'compatibility'], additionalProperties: false },
-          complexity_budget: { type: 'object', properties: {
-            added_writers: { type: 'number' }, added_durable_mechanisms: { type: 'number' }, projection_paths: { type: 'number' }, global_invalidations: { type: 'number' }, lifecycle_hooks: { type: 'number' }, synchronous_critical_path_work: { type: 'number' }, notes: { type: 'array', items: { type: 'string' } },
-          }, additionalProperties: false },
-        }, required: ['semantic_scope_keys', 'mutation_class', 'decisions', 'complexity_budget'], additionalProperties: false },
-        independent_critique: { type: 'object', properties: {
-          decision: { type: 'string', enum: ['approved', 'changes_required', 'blocked'] },
-          findings: { type: 'array', items: { type: 'object', properties: { severity: { type: 'string', enum: ['critical', 'high', 'medium', 'low', 'info'] }, summary: { type: 'string' } }, required: ['severity', 'summary'], additionalProperties: false } },
-        }, required: ['decision', 'findings'], additionalProperties: false },
-      },
-      required: ['context_closure', 'product_dod', 'design_decision', 'independent_critique'],
-      additionalProperties: false,
-    },
-    engineering_blocker: { type: 'object', description: 'Explicit semantic blocker classification for continue. Forge derives return_to_design vs linked_work; free text cannot widen the current Work.', properties: {
-      blocker_id: { type: 'string' }, classification: { type: 'string', enum: ['same_root_cause', 'unrelated'] }, rationale: { type: 'string' }, semantic_scope_keys: { type: 'array', items: { type: 'string' } },
-    }, required: ['blocker_id', 'classification', 'rationale'], additionalProperties: false },
-    additional_likely_paths: { type: 'array', items: { type: 'string' }, description: 'Non-authoritative candidates discovered after Work start. Valid for continue; does not widen allowed_paths.' },
-    inspected_paths: { type: 'array', items: { type: 'string' }, description: 'Paths actually inspected during progressive discovery. Valid for continue; does not widen allowed_paths.' },
-    review_findings: { type: 'array', items: { type: 'string' }, description: 'Concise semantic findings for operation=continue on work_kind=read_only_review. Findings are source-bound durable review evidence and prevent clean completed_no_change finalization until a successor repair/review resolves them.' },
-    review_decision: { type: 'string', enum: ['approved', 'changes_required', 'blocked'], description: 'Explicit Controller implementation-review decision for operation=review. No default approval.' },
-    review_rationale: { type: 'string', description: 'Explicit Controller rationale for operation=review.' },
-    implementation_review_findings: { type: 'array', items: { type: 'object', required: ['severity', 'category', 'summary'], properties: { severity: { type: 'string', enum: ['critical', 'high', 'medium', 'low', 'info'] }, category: { type: 'string' }, summary: { type: 'string' }, path: { type: 'string' }, symbol: { type: 'string' } }, additionalProperties: false }, description: 'Structured implementation-review findings. Candidate source, fingerprints, paths, and evidence identities are derived by Forge and are never accepted from the caller.' },
-    acceptance_evidence: { type: 'array', items: { type: 'object', required: ['criterion', 'evidence_ids', 'rationale'], properties: { criterion: { type: 'string', description: 'Exact declared Work acceptance criterion reviewed by the Controller.' }, evidence_ids: { type: 'array', items: { type: 'string' }, description: 'Durable evidence ids already attributed to this Work that support this exact criterion.' }, rationale: { type: 'string', description: 'Controller rationale for why the cited evidence satisfies this exact criterion.' } }, additionalProperties: false }, description: 'Operation=continue only. Explicit Controller-reviewed criterion-to-evidence bindings for no-check local_effect Work. Mechanical plugin/process attribution alone never implies semantic acceptance.' },
-    acceptance_failure_decision: { type: 'string', enum: ['repair', 'rescope'], description: 'Explicit Controller decision for operation=continue after a deterministic valid_fail. Bypasses acceptance-review handoff only for this bounded repair/re-scope decision; never inferred from free text.' },
-    forbidden_paths: { type: 'array', items: { type: 'string' } },
-    constraints: {
-      type: 'object',
-      properties: {
-        max_changed_files: { type: 'number' },
-        max_changed_lines: { type: 'number' },
-        allow_commit: { type: 'boolean' },
-        allow_merge: { type: 'boolean' },
-        allow_cleanup: { type: 'boolean' },
-        allow_destructive: { type: 'boolean' },
-        require_handoff_on_ambiguity: { type: 'boolean' },
-        access_mode: { type: 'string', enum: ['request', 'full_access'] },
-        workspace_mode: { type: 'string', enum: ['current', 'isolated', 'auto'], description: 'Typed placement policy. isolated is an admission fence and cannot be downgraded to Direct Control.' },
-        require_worktree: { type: 'boolean', description: 'Typed placement policy. true requires isolated Work placement before routing.' },
-        direct_main_prohibited: { type: 'boolean', description: 'Typed admission fence. true forbids Direct Control/current-main repository mutation.' },
-      },
-      additionalProperties: true,
-    },
     repair_operation: { type: 'string', enum: ['diagnose', 'repair', 'verify', 'handoff'] },
-    target: { type: 'string', enum: ['codex', 'grok', 'claude'], description: 'Explicit small-brain delegate target for operation=delegate. Delegation is never the default execution path.' },
-    available: { type: 'boolean', description: 'Whether the delegate target is currently available.' },
-    codex_available: { type: 'boolean' },
-    simulate_check: { type: 'boolean', description: 'Test hook: skip real check execution and use infrastructure_failed/check_failed flags.' },
-    infrastructure_failed: { type: 'boolean' },
-    check_failed: { type: 'boolean' },
     authorize_destructive_cleanup: { type: 'boolean' },
-    commit: { type: 'boolean', description: 'Finalize override. Defaults to true only when the Work owns uncommitted changes.' },
-    merge: { type: 'boolean', description: 'Finalize override. Defaults to true for managed Work delivery.' },
-    cleanup: { type: 'boolean', description: 'Finalize/stop override. Defaults to true so managed worktrees close automatically.' },
-    target_branch: { type: 'string', description: 'Delivery branch; defaults to the repository default branch.' },
-    delete_branch: { type: 'boolean', description: 'Defaults to true after target-branch containment is proven.' },
-    no_ff: { type: 'boolean' },
-    completion_outcome: { type: 'string', enum: ['completed_changed', 'completed_no_change', 'completed_local', 'completed_remote'], description: 'Explicit completion semantics. completed_local is for controller-local effect Work finalized from durable result evidence; completed_remote remains bound to a durable remote plugin receipt.' },
-    no_change_evidence: { type: 'string', description: 'Optional explicit proof for a no-change completion; otherwise the lifecycle coordinator derives proof only for an unchanged validated HEAD.' },
-    reconcile_historical_delivery: { type: 'boolean', description: 'Explicitly request reviewed reconciliation for a historically delivered repository Work whose original receipt is missing. Managed Work is eligible only after merge, branch cleanup, and worktree cleanup are durably complete.' },
-    reconcile_target_revision: { type: 'string', description: 'Exact already-integrated commit accepted by the reviewer.' },
-    reconcile_compared_paths: { type: 'array', items: { type: 'string' }, description: 'Complete exact path set changed from the Work base revision to reconcile_target_revision.' },
-    reconcile_rationale: { type: 'string', description: 'Bounded reviewer rationale for accepting the historical delivery.' },
-    reconcile_cleanup_proof: { type: 'string', description: 'Concrete proof that no owned cleanup remains or that cleanup is complete.' },
     detail_level: { type: 'string', enum: ['summary', 'detail'] },
     reason: { type: 'string', description: 'Bounded reason for a work stop or repair record.' },
   }, [], false),
-  definition('work_get', 'Resume one Work by work_id or request_id. Repository scope is always enforced.', {
-    repo_id: repoId,
-    work_id: { type: 'string' },
-    request_id: { type: 'string' },
-    include_events: { type: 'boolean' },
-    wait: { type: 'boolean', description: 'When true, wait for terminal status before returning digest.' },
-    wait_ms: { type: 'number' },
-  }),
-  definition('work_list', 'List recent resumable Work for one repository.', {
-    repo_id: repoId,
-    limit: { type: 'number' },
-  }),
-  definition('work_cancel', 'Cancel one queued or running Work by work_id or request_id.', {
-    repo_id: repoId,
-    work_id: { type: 'string' },
-    request_id: { type: 'string' },
-    reason: { type: 'string' },
-  }, [], false),
-  definition('work_wait', 'Wait for one Work/ExecutionJob/managed process to reach a terminal status and return a bounded operation digest.', {
-    repo_id: repoId,
-    work_id: { type: 'string' },
-    request_id: { type: 'string' },
-    wait_ms: { type: 'number', description: 'Max wait in ms. Default 15000, max 120000.' },
-  }),
   definition('git_diff_paths', 'Return a bounded Git diff and status for explicit repository-relative paths only.', {
     repo_id: repoId,
     paths: { type: 'array', items: { type: 'string' } },
@@ -335,7 +236,7 @@ export const runtimeToolDefinitions: McpToolDefinition[] = [
     wait: { type: 'boolean', description: 'When true, wait for terminal status before returning digest.' },
     wait_ms: { type: 'number' },
   }, ['job_id']),
-  definition('get_artifact', 'Read one bounded Evidence Plane artifact by id. Large content remains bounded.', { artifact_id: { type: 'string' }, repo_id: repoId, max_bytes: { type: 'number' } }, ['artifact_id', 'repo_id']),
+  definition('get_artifact', 'Read one bounded Evidence Plane artifact/evidence handle by opaque id. repo_id is optional and used only to adopt a historical repository-partitioned handle once.', { artifact_id: { type: 'string' }, repo_id: { ...repoId, description: 'Legacy repository hint only. Omit for canonical ForgeInstance output handles.' }, max_bytes: { type: 'number' } }, ['artifact_id']),
   definition('repository_change_verify', 'Composite: verify checkout/SHA, apply bounded patch, run checks, return first failure inline without get_job/get_artifact follow-ups.', {
     repo_id: repoId,
     expected_branch: { type: 'string' },
@@ -470,6 +371,30 @@ export const runtimeToolDefinitions: McpToolDefinition[] = [
     confirm_authorization: { type: 'boolean', description: 'Must be true to authorize this exact one-shot console unlock invocation.' },
     timeout_ms: { type: 'number', description: 'Bounded provider/postcondition timeout in milliseconds. Defaults to 15000 and is capped at 30000.' },
   }, ['credential_handle', 'confirm_authorization'], false),
+  definition('computer_console_unlock_enroll', 'Enroll provider-local device-only protected console recovery. Credential material never enters ChatGPT, Forge Runtime, plugin receipts, or replayable jobs. Requires confirm_authorization=true for every invocation.', {
+    confirm_authorization: { type: 'boolean', description: 'Must be true to authorize this exact provider-local enrollment invocation.' },
+    timeout_ms: { type: 'number', description: 'Bounded provider timeout in milliseconds. Defaults to 15000 and is capped at 30000.' },
+  }, ['confirm_authorization'], false),
+  definition('computer_console_unlock_status', 'Read protected console recovery enrollment and availability without exposing provider-local credential material. Requires confirm_authorization=true for every invocation.', {
+    confirm_authorization: { type: 'boolean', description: 'Must be true to authorize this exact protected status invocation.' },
+    timeout_ms: { type: 'number', description: 'Bounded provider timeout in milliseconds. Defaults to 15000 and is capped at 30000.' },
+  }, ['confirm_authorization'], false),
+  definition('computer_console_unlock_recover', 'Recover a locked macOS console using only previously enrolled provider-local device-only credential material. No credential is transported through ChatGPT or Forge Runtime. Requires confirm_authorization=true for every invocation.', {
+    confirm_authorization: { type: 'boolean', description: 'Must be true to authorize this exact one-shot recovery invocation.' },
+    timeout_ms: { type: 'number', description: 'Bounded provider/postcondition timeout in milliseconds. Defaults to 15000 and is capped at 30000.' },
+  }, ['confirm_authorization'], false),
+  definition('computer_console_unlock_revoke', 'Revoke provider-local protected console recovery enrollment. Requires confirm_authorization=true for every invocation.', {
+    confirm_authorization: { type: 'boolean', description: 'Must be true to authorize this exact provider-local revocation invocation.' },
+    timeout_ms: { type: 'number', description: 'Bounded provider timeout in milliseconds. Defaults to 15000 and is capped at 30000.' },
+  }, ['confirm_authorization'], false),
+  definition('capability_execute', 'Execute one typed Forge core capability through its canonical substrate owner. Discover the exact action schema with rh_context capability_id first. This stable facade prevents one top-level MCP tool per atomic repository operation; plugin capabilities continue to use plugin_action_execute.', {
+    repo_id: repoId,
+    checkout_id: { type: 'string', description: 'Optional exact checkout identity.' },
+    capability_id: { type: 'string', description: 'Exact core capability identity returned by rh_context.' },
+    action: { type: 'string', description: 'Exact capability action returned by rh_context.' },
+    request_id: { type: 'string', description: 'Stable idempotency identity for this invocation.' },
+    arguments: { type: 'object', description: 'Action-specific arguments validated by the capability owner.' },
+  }, ['capability_id', 'action', 'request_id'], false),
   definition('plugin_action_execute', 'Execute one typed repository or controller-scoped plugin action through the plugin provider authority. rh_context exposes plugin schemas/policy; rh_work does not execute plugin capabilities. For confirmation=authorization, normal host permission is authoritative and an exact-target Forge capability grant may be reused; do not set confirm_authorization merely because an ordinary authorization-class action was previously allowed. Strong-confirmation actions still require their explicit confirmation contract.', {
     repo_id: repoId,
     plugin_id: { type: 'string' },
@@ -528,6 +453,21 @@ export const runtimeToolDefinitions: McpToolDefinition[] = [
     recent_safe_error: { type: 'string' },
     model: { type: 'string' },
   }),
+  definition('supervisor_task', 'Start, list, inspect, revise, recover, stop, or prove standalone Workflow Supervisor autonomous tasks. Supervisor task/effect state is the continuation authority; Requirement, Plan, and Work are optional and are not created by this tool.', {
+    repo_id: { ...repoId, description: 'Optional repository provenance for start/proof; never Work authority.' },
+    operation: { type: 'string', enum: ['start', 'list', 'get', 'revise', 'recover', 'stop', 'proof'] },
+    task_id: { type: 'string' },
+    objective: { type: 'string', description: 'Outcome objective for start/revise; revise never changes task or conversation identity.' },
+    expected_objective_sha256: { type: 'string', description: 'For revise: CAS hash of the exact current objective.' },
+    reason: { type: 'string', description: 'Operator reason recorded for stop/recover.' },
+    source_effect_id: { type: 'string', description: 'Optional exact source effect for operator recovery fencing.' },
+    supersede_unknown: { type: 'boolean', description: 'For recover only: explicitly retire one outcome-unknown effect instead of replaying it.' },
+    authorized_by: { type: 'string', description: 'Optional operator identity recorded by canonical recovery authority.' },
+    active_only: { type: 'boolean', description: 'For list, defaults true; exclude terminal tasks.' },
+    request_id: { type: 'string', description: 'Stable idempotency identity for start/revise/recover.' },
+    active_release_id: { type: 'string', description: 'Active Runtime release expected in proof dispatch evidence.' },
+    not_before: { type: 'string', description: 'ISO-8601 lower bound for proof completions.' },
+  }, ['operation'], false),
   definition('review_artifacts_prepare', 'Create bounded repo-local review artifact roots for browser/iOS screenshot review workflows.', { repo_id: repoId }, [], false),
   definition('review_artifacts_index', 'Index bounded repo-local browser/iOS screenshots, logs, and build reports for visual review.', { repo_id: repoId, limit: { type: 'number' } }),
   definition('browser_review_packet', 'Build a browser visual review packet from indexed browser screenshots.', { repo_id: repoId, limit: { type: 'number' } }),

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

@@ -5,13 +5,14 @@ import { callLegacyIosAdapter } from './legacy-ios-tool-adapter';
 import { result } from './result-adapter';
 import { callContextAdapter } from './context-adapter';import { callPluginAdapter } from './plugin-adapter';import { callRecoveryAdapter } from './recovery-adapter';import { callArtifactAdapter } from './artifact-adapter';import { callFilesystemAdapter } from './filesystem-adapter';import { callModelAdapter } from './model-adapter';
 import { callProtectedComputerAdapter } from './protected-computer-adapter';
-import { callWorkCompatibilityAdapter } from './work-compat-adapter';
+import { callWorkflowSupervisorAdapter } from './workflow-supervisor-adapter';
 import { callRepositoryCompatibilityAdapter } from './repository-compat-adapter';
 import { callSchedulerAdapter } from './scheduler-adapter';
 import { callRuntimeObservationAdapter } from './runtime-observation-adapter';
 import { callExecutionControlAdapter } from './execution-control-adapter';
 import { callMaintenanceAdapter } from './maintenance-adapter';
 import { callStatusInboxAdapter } from './status-inbox-adapter';
+import { callCoreCapabilityAdapter } from './core-capability-adapter';
 export { boundedPluginArtifactImageContent } from './result-adapter';
 export { classifyTerminalCheckEvidence } from '../../../src/runtime/execution/process-runtime/check-result';
 
@@ -21,8 +22,9 @@ export {
   runtimeToolDefinitions,
 } from './runtime-tool-definitions';
 import { callWorkAdapter, runFacadeRepair } from './work-adapter';
+import { automationMetadata, persistAutomationReceipt } from './automation-receipt-adapter';
 
-export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name: string, args: Record<string, unknown>): Promise<CallToolResult | undefined> {
+async function callRuntimeToolUnchecked(ctx: MultiRepositoryMcpToolContext, name: string, args: Record<string, unknown>): Promise<CallToolResult | undefined> {
   try {
     const statusInbox = await callStatusInboxAdapter(ctx, name, args, { repair: runFacadeRepair });
     if (statusInbox) return statusInbox;
@@ -30,6 +32,8 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
     if (context) return context;
     const protectedComputer = await callProtectedComputerAdapter(ctx, name, args);
     if (protectedComputer) return protectedComputer;
+    const coreCapability = await callCoreCapabilityAdapter(ctx, name, args);
+    if (coreCapability) return coreCapability;
     const plugin = await callPluginAdapter(ctx, name, args);
     if (plugin) return plugin;
     const recovery = await callRecoveryAdapter(ctx, name, args);
@@ -40,8 +44,8 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
     if (filesystem) return filesystem;
     const model = callModelAdapter(ctx, name, args);
     if (model) return model;
-    const workCompatibility = await callWorkCompatibilityAdapter(ctx, name, args);
-    if (workCompatibility) return workCompatibility;
+    const workflowSupervisor = await callWorkflowSupervisorAdapter(ctx, name, args);
+    if (workflowSupervisor) return workflowSupervisor;
     const repositoryCompatibility = await callRepositoryCompatibilityAdapter(ctx, name, args);
     if (repositoryCompatibility) return repositoryCompatibility;
     const scheduler = await callSchedulerAdapter(ctx, name, args);
@@ -63,6 +67,12 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
   }
 }
 
-export { RH_WORK_VERIFY_LEASE_WAIT_MS } from './work-adapter';
+export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name: string, args: Record<string, unknown>): Promise<CallToolResult | undefined> {
+  const metadata = automationMetadata(args);
+  const outcome = await callRuntimeToolUnchecked(ctx, name, args);
+  await persistAutomationReceipt(ctx, name, metadata, outcome);
+  return outcome;
+}
+
 export { runtimeIdentitySnapshot, dispatchedChatgptRelayAuthorizesStaleControllerRecovery, sessionlessFacadeControllerAuthorityMatches } from './controller-authority-adapter';
 export type { RuntimeIdentitySnapshot } from './controller-authority-adapter';

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

@@ -66,6 +66,7 @@ export async function callRhWorkScheduleAdapter(
         workId,
         scheduleMode: scheduleModeRaw as 'continuation' | 'browser_watch' | 'browser_keepalive',
         controllerType: controllerType as ContinuationControllerType,
+        authorizationGrantRefs: Array.isArray(args.authorization_grant_refs) ? args.authorization_grant_refs.map(String) : undefined,
         executable: typeof args.executable === 'string' ? args.executable : undefined,
         launchArgs: Array.isArray(args.launch_args) ? args.launch_args.map(String) : undefined,
         launchReservationMs: typeof args.launch_reservation_ms === 'number' ? args.launch_reservation_ms : typeof args.lease_ms === 'number' ? args.lease_ms : undefined,

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

@@ -16,6 +16,26 @@ export function repositoryRootForRepoId(controllerHome: string, repoId: string):
   return listRepositories(controllerHome).find((repository) => repository.repoId === repoId)?.canonicalRoot;
 }
 
+/**
+ * Repository selection for tools whose semantics can be instance-scoped.
+ *
+ * An explicitly named repository (or the MCP server's default repository
+ * context) stays authoritative and fails closed when invalid. When the caller
+ * names none, a sole enabled repository is used; zero or several repositories
+ * yield undefined so the caller can serve the ForgeInstance-level answer
+ * instead of inventing a repository.
+ */
+export function selectedOptional(
+  ctx: MultiRepositoryMcpToolContext,
+  args: Record<string, unknown>,
+): ReturnType<typeof selected> | undefined {
+  const explicitRepoId = typeof args.repo_id === 'string' ? args.repo_id.trim() : '';
+  const explicitCheckoutId = typeof args.checkout_id === 'string' ? args.checkout_id.trim() : '';
+  if (explicitRepoId || explicitCheckoutId || ctx.explicitRepository) return selected(ctx, args);
+  const enabled = listRepositories(ctx.controllerHome).filter((record) => record.enabled);
+  return enabled.length === 1 ? selected(ctx, args) : undefined;
+}
+
 export function expectedRevision(args: Record<string, unknown>, key = 'expected_revision'): number | undefined {
   return typeof args[key] === 'number' ? Math.trunc(args[key] as number) : undefined;
 }