@moretea-labs/forge 1.8.1 → 1.8.2

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

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'fs';
 import type { McpToolDefinition, CallToolResult } from '../../../packages/protocols/mcp/tool-contract';
 import type { MultiRepositoryMcpToolContext } from '../multi-repository';
-import { repositoryGitStatus, repositoryGitDiff } from '../../../src/cli/repositories/structured-git';
+import { repositoryGitWorkspaceChanges } from '../../../src/cli/repositories/structured-git';
 import { listControllerChecks } from '../../../src/cli/controller/check-runner';
 import { buildWorkContinuationSnapshot } from '../../../src/runtime/control-plane/facade/work-continuation';
 import { currentControllerInstanceId, startExecutionSession, type ExecutionSessionContext } from '../../../src/runtime/control-plane/execution/session-store';
@@ -12,7 +12,7 @@ import { resumeExecutionJobAfterApproval } from '../../../src/runtime/execution/
 import { recordMcpTiming, type McpTimingTrace } from '../../../src/runtime/diagnostics/mcp-timing';
 import { compactHandle, contractFor, identityFor, makeBoundedWorkResult, principalFor, requireSession, workForSession } from '../../../src/runtime/control-plane/execution/work-execution-support';
 import { bindSessionRepository, prepareWork } from '../../../src/runtime/control-plane/execution/work-preparation-service';
-import { executeWork, validateWork } from '../../../src/runtime/control-plane/execution/work-operation-service';
+import { validateWork } from '../../../src/runtime/control-plane/execution/work-operation-service';
 
 export { selectDefaultWorkValidationChecks } from '../../../src/runtime/control-plane/execution/work-operation-service';
 
@@ -33,13 +33,9 @@ export const executionToolDefinitions: McpToolDefinition[] = [
     isolation: { type: 'string', enum: ['reuse', 'new_worktree', 'auto'] }, base_ref: { type: 'string' }, needs_dependencies: { type: 'boolean' },
     expected_previous_head: { type: 'string', description: 'Explicit prior WorkHandle HEAD required for audited successor adoption of an existing work_id.' },
     adopt_candidate_head: { type: 'string', description: 'Explicit current successor commit to adopt after exact identity, ownership, cleanliness, and ancestry validation.' },
+    relocate_to_new_worktree: { type: 'boolean', description: 'Move this existing Work identity to its own managed worktree, with exact previous/candidate HEADs and base_ref. WorkHandle and WorkContract placement commit atomically; the source checkout is not mutated.' },
   }, [], false),
   definition('work_inspect', 'Collect bounded Git, WorkContract, changed-path, check, and readiness evidence through one work handle.', { session_id: sessionId, repo_id: repoId, work_id: workId, detail: { type: 'string', enum: ['summary', 'detail'] } }, ['work_id'], true),
-  definition('work_execute', 'Execute approved, repository-scoped commands against a validated work handle while preserving the existing command policy and audit path.', {
-    session_id: sessionId, controller_id: { type: 'string', description: 'Controller identity that holds the Work lease. Defaults to the authenticated principal.' }, repo_id: repoId, work_id: workId,
-    command: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }] }, approval_token: { type: 'string' }, cwd: { type: 'string' }, timeout_ms: { type: 'number' }, max_output_bytes: { type: 'number' },
-    commands: { type: 'array', items: { type: 'object' } }, approval_request_id: { type: 'string' },
-  }, ['work_id'], false),
   definition('work_validate', 'Run targeted checks or read-only validation commands against a work handle with full current-state validation.', {
     session_id: sessionId, controller_id: { type: 'string', description: 'Controller identity that holds the Work lease. Defaults to the authenticated principal.' }, repo_id: repoId, work_id: workId, check_ids: { type: 'array', items: { type: 'string' } }, commands: { type: 'array', items: { type: 'object' } }, interactive_wait_ms: { type: 'number', description: 'Optional bounded attach window for checks launched by this validation call. Defaults to asynchronous behavior.' },
   }, ['work_id'], false),
@@ -52,7 +48,6 @@ const executionToolNames = new Set(executionToolDefinitions.map((tool) => tool.n
 
 /** Repository execution and validation remain Process/WorkHandle operations; semantic Work completion is separate. */
 const DURABLE_WORK_OPERATION_NAMES = new Set([
-  'work_execute',
   'work_validate',
 ]);
 
@@ -89,8 +84,8 @@ function inspectWork(ctx: MultiRepositoryMcpToolContext, args: Record<string, un
   const validationStarted = performance.now();
   const validated = validateWorkHandle(ctx.controllerHome, handle, identityFor(ctx, args), 'cheap', 'inspect');
   const validationMs = performance.now() - validationStarted;
-  const status = repositoryGitStatus(validated.worktreeRepository);
-  const diff = repositoryGitDiff(validated.worktreeRepository, { maxBytes: 64 * 1024 });
+  const candidate = repositoryGitWorkspaceChanges(validated.worktreeRepository);
+  const { status, diff } = candidate;
   const contract = contractFor(ctx, handle);
   const checks = contract?.checks ?? [];
   const packageManifest = existsSync(`${validated.worktreeRepository.canonicalRoot}/package.json`)
@@ -100,7 +95,7 @@ function inspectWork(ctx: MultiRepositoryMcpToolContext, args: Record<string, un
     session: { sessionId: session.sessionId, repoId: session.activeRepositoryId, checkoutId: session.activeCheckoutId },
     work: compactHandle(handle),
     readiness: { valid: true, warnings: validated.warnings, permissionSnapshotVersion: handle.permissionSnapshotVersion },
-    git: { status, diff: { nameOnly: diff.nameOnly, stat: diff.stat, patch: diff.patch, truncated: diff.truncated } },
+    git: { status, diff: { ...diff, staged: { nameOnly: candidate.staged.nameOnly, stat: candidate.staged.stat, truncated: candidate.staged.truncated }, unstaged: { nameOnly: candidate.unstaged.nameOnly, stat: candidate.unstaged.stat, truncated: candidate.unstaged.truncated }, untracked: status.untracked } },
     workContract: contract ? {
       workId: contract.workId,
       state: contract.semanticState,
@@ -110,7 +105,7 @@ function inspectWork(ctx: MultiRepositoryMcpToolContext, args: Record<string, un
       semantics: buildWorkContinuationSnapshot(contract).semantics,
     } : undefined,
     continuation: contract ? buildWorkContinuationSnapshot(contract) : undefined,
-    paths: { changed: diff.nameOnly },
+    paths: { changed: candidate.changedPaths },
     checks: checks.map((checkId) => ({ checkId, registered: listControllerChecks(validated.worktreeRepository.canonicalRoot).some((check) => check.id === checkId) })),
     package: packageManifest ? { name: packageManifest.name, scripts: packageManifest.scripts } : undefined,
   };
@@ -131,7 +126,6 @@ export async function callExecutionTool(ctx: MultiRepositoryMcpToolContext, name
       case 'session_bind_repository': return result(bindSessionRepository(ctx, args));
       case 'work_prepare': return result(prepareWork(ctx, args));
       case 'work_inspect': return result(inspectWork(ctx, args));
-      case 'work_execute': return result(await executeWork(ctx, args));
       case 'work_validate': return result(await validateWork(ctx, args));
       case 'approval_resolve': {
         const session = requireSession(ctx, args);

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

@@ -141,15 +141,15 @@ export async function callPluginAdapter(
   switch (name) {
     case 'list_plugins': {
       const controllerPlugins = listControllerPluginManifests(ctx.controllerHome, {
-        forceRefresh: true,
+        preferStored: true,
       }).map(summarizePlugin);
       let repositoryPlugins: ReturnType<typeof summarizePlugin>[] = [];
       let repositoryId: string | undefined;
-      if (explicitRepositoryContextRequested(args)) {
+      if (explicitRepositoryContextRequested(args) || typeof ctx.repoId === 'string' && ctx.repoId.trim()) {
         const repository = selected(ctx, args);
         repositoryId = repository.repoId;
         repositoryPlugins = listAssistantPluginManifests(ctx.controllerHome, repository, {
-          forceRefresh: true,
+          preferStored: true,
         }).map(summarizePlugin);
       }
       return result({
@@ -316,6 +316,19 @@ export async function callPluginAdapter(
       }
 
       const submitted = application.submitted;
+      if (submitted.receipt.status === 'failed' && submitted.receipt.effectOutcome !== 'outcome_unknown') {
+        return result({
+          accepted: true,
+          deduplicated: submitted.deduplicated,
+          scope: pluginScopeLabel(scope),
+          plugin: summarizePluginActionReceipt(submitted.manifest),
+          action: { actionId: submitted.action.actionId },
+          requestId: submitted.receipt.requestId,
+          receiptId: submitted.receipt.receiptId,
+          effectOutcome: submitted.receipt.effectOutcome ?? 'failed',
+          error: submitted.receipt.error ?? { code: 'PLUGIN_ACTION_FAILED', message: 'Plugin action failed.' },
+        }, true);
+      }
       const compactResult = compactSubmittedPluginActionResult(submitted.result);
       const value = {
         accepted: true,

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

@@ -53,27 +53,10 @@ const repoIdProp = {
 };
 const processIdProp = {
   type: 'string',
-  description: 'Lightweight or durable process id returned by run_check / repository_command_execute.',
+  description: 'Process id returned by execute_command or run_check.',
 };
 
 export const processToolDefinitions: McpToolDefinition[] = [
-  definition(
-    'process_exec',
-    'Execute one command on the Forge instance itself: cwd is an execution argument and no repository, checkout, or Work is required. Requires an explicit broad `process:exec` canonical Grant for this ForgeInstance; Forge does not parse the command to prove path safety. Returns a process handle; attach with process_get/process_wait/process_logs/process_cancel using the handle only.',
-    {
-      command: { type: 'array', items: { type: 'string' }, maxItems: 512, description: 'Typed argv command; command[0] is the executable. Mutually exclusive with shell_command.' },
-      shell_command: { type: 'string', maxLength: 32_000, description: 'Explicit broad shell form. Mutually exclusive with command. Never parsed for path safety.' },
-      cwd: { type: 'string', description: 'Optional absolute working directory. With work_id and no cwd, Forge uses that Work handle\'s exact workspace/worktree as a convenience default; this never grants permission and explicit authorized cwd may be elsewhere.' },
-      timeout_ms: { type: 'number' },
-      interactive_wait_ms: { type: 'number' },
-      max_output_bytes: { type: 'number' },
-      request_id: { type: 'string', description: 'Stable invocation id. A retry with the same id attaches to the existing process instead of re-executing.' },
-      work_id: { type: 'string', description: 'Optional Work provenance; Work is never required to run a host command.' },
-    },
-    [],
-    false,
-    true,
-  ),
   definition(
     'run_check',
     'Run one focused repository check, or launch one resource-compatible check wave, through Process Runtime. Use check_id for the existing single-check behavior or check_ids for a batch; do not send both. Batch mode validates the existing check-scheduling resource model and starts every check in one compatible wave concurrently without waiting for completion or creating a second scheduler. Cross-wave, invalid, release, and multi-phase batches fail closed. Long ordinary checks return managed handles; attach only at a real dependency boundary.',
@@ -304,7 +287,6 @@ export async function callProcessTool(
   name: string,
   args: Record<string, unknown>,
 ): Promise<CallToolResult | undefined> {
-  if (name === 'process_exec') return callProcessExecTool(ctx, args);
   // run_check shares this module's public schema, but its execution authority is
   // the Gateway check facade in router.ts. Only attachment/lifecycle operations
   // consume an existing process_id here.
@@ -383,7 +365,7 @@ export async function callProcessTool(
 }
 
 /**
- * `process_exec` — the canonical host-local command lane.
+ * Host target of the single execute_command entry: canonical process:exec Grant.
  *
  * Repo-less by construction: the Forge instance is the target and `cwd` is an
  * execution argument. Authorization is one explicit canonical `process:exec`
@@ -406,7 +388,7 @@ function workDefaultCommandCwd(ctx: MultiRepositoryMcpToolContext, workId: strin
   return workspace || undefined;
 }
 
-async function callProcessExecTool(
+export async function executeAuthorizedHostCommand(
   ctx: MultiRepositoryMcpToolContext,
   args: Record<string, unknown>,
 ): Promise<CallToolResult> {

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

@@ -48,7 +48,6 @@ function result(value: Record<string, unknown>, isError = false): CallToolResult
 
 export function getMcpToolDefinition(ctx: MultiRepositoryMcpToolContext, name: string): McpToolDefinition | undefined {
   const currentDefinitions = [...runtimeToolDefinitions, ...executionToolDefinitions, ...processToolDefinitions, ...repositoryToolDefinitions];
-  if (ctx.toolset !== 'full') return currentDefinitions.find((tool) => tool.name === name);
   return [...currentDefinitions, ...buildMultiRepositoryToolDefinitions(ctx)].find((tool) => tool.name === name);
 }
 
@@ -212,11 +211,11 @@ export async function routeDurableMcpCall(
     }, true);
   }
 
-  // repository_command_execute has its own durable boundary: non-destructive
+  // execute_command has its own durable boundary: non-destructive
   // remote writes run through the durable Process Runtime, while destructive or
   // explicitly delegated commands are refused by the repository facade itself.
   // Do not intercept that tool with the retired ExecutionJob gate here.
-  if (classification.path === 'durable' && executionJobCreationRetired() && name !== 'repository_command_execute') {
+  if (classification.path === 'durable' && executionJobCreationRetired() && name !== 'execute_command') {
     return result({
       accepted: false,
       mode: 'external_controller_required',
@@ -227,8 +226,7 @@ export async function routeDurableMcpCall(
         ...(classification.decision ? { decision: classification.decision } : {}),
       },
       rejectCode: 'EXECUTION_JOB_RETIRED',
-      message: 'This operation requires an explicit external Controller or domain capability; the Kernel no longer creates ExecutionJobs or a Work-ownership phase.',
-      suggestedOperation: 'Create or resume semantic Work only when durable context is useful, then use the direct Process/domain capability or rh_work.launcher_start.',
+      message: 'This operation needs external Controller or authorized domain capability; Forge does not create Work/Plans or prescribe a workflow to fulfill it.',
     });
   }
 

package/adapters/mcp/runtime-gateway/routing-policy.ts

@@ -7,7 +7,7 @@ import { classifyRepositoryCommandRoute } from '../../../src/runtime/execution/p
 import { isProcessIsolatedReadDiagnostic } from '../../../src/runtime/diagnostics/process-facade';
 
 /** Pure deterministic MCP Gateway placement policy. No execution or lifecycle mutation belongs here. */
-const DIRECT_REPOSITORY_TOOLS = new Set(['repository_list', 'repository_get', 'repository_workbench', 'repository_command_preview']);
+const DIRECT_REPOSITORY_TOOLS = new Set(['repository_list', 'repository_get', 'repository_workbench']);
 const DIRECT_CONTROL_WRITE_TOOLS = new Set([
   'runtime_maintenance_apply',
   // Protected credential preparation and physical input own their authorization boundary.
@@ -21,7 +21,7 @@ const DIRECT_CONTROL_WRITE_TOOLS = new Set([
 ]);
 
 const THIN_ROUTED_TOOLS = new Set([
-  'repository_command_execute',
+  'execute_command',
   'repository_safe_patch_apply',
   'repository_safe_patch_plan',
   'capability_execute',
@@ -128,8 +128,8 @@ const GATEWAY_ROUTE_BEHAVIOR_PROBES: ReadonlyArray<{
 }> = [
   { id: 'hot-read', operation: 'controller_ready', args: {} },
   { id: 'isolated-read-diagnostic', operation: 'workflow_watchdog_report', args: {} },
-  { id: 'readonly-command', operation: 'repository_command_execute', args: { command: ['git', 'status', '--short'] } },
-  { id: 'managed-local-command', operation: 'repository_command_execute', args: { command: ['bun', 'run', 'check:type'], timeout_ms: 120_000 } },
+  { id: 'readonly-command', operation: 'execute_command', args: { command: ['git', 'status', '--short'] } },
+  { id: 'managed-local-command', operation: 'execute_command', args: { command: ['bun', 'run', 'check:type'], timeout_ms: 120_000 } },
   { id: 'focused-check', operation: 'run_check', args: { check_id: 'package:check:type' } },
   { id: 'release-check', operation: 'run_check', args: { check_id: 'package:check:release' } },
   { id: 'interactive-write', operation: 'repository_safe_patch_apply', args: { operations: [] } },
@@ -311,7 +311,7 @@ export function classifyGatewayExecutionPath(
     };
   }
   const selfManagedProcessAsync = (
-    name === 'repository_command_execute'
+    name === 'execute_command'
     || name === 'run_check'
     || name === 'verify_edit_session'
   ) && (
@@ -394,11 +394,18 @@ export function classifyGatewayExecutionPath(
     };
   }
 
-  // repository_command_execute has one authoritative classifier. Process Runtime
-  // owns every local single-process command regardless of timeout. Async requests
-  // stay here and return a handle; explicit durable mode remains an external-
-  // Controller boundary.
-  if (name === 'repository_command_execute') {
+  // Host commands are already placed explicitly by the model and authorized
+  // by the ForgeInstance process:exec Grant. Never route them through a
+  // repository classifier or infer a Work/Plan from the shell command.
+  if (name === 'execute_command' && args.scope === 'host') {
+    return { path: 'fast', reasons: ['explicit_host_process_runtime'] };
+  }
+  if (name === 'execute_command' && args.dry_run === true) {
+    return { path: 'direct', reasons: ['explicit_command_preview_only'] };
+  }
+  // Repository commands use the existing Process Runtime classifier only for
+  // process handling and mechanical write protection.
+  if (name === 'execute_command') {
     const command = args.command;
     if (!(typeof command === 'string' || Array.isArray(command))) {
       return { path: 'reject', reasons: ['repository_command_missing'] };

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

@@ -2,7 +2,7 @@ import { existsSync } from 'fs';
 import { collectRuntimePerformanceDiagnostics, inferLocalControllerProcess } from '../../../src/runtime/diagnostics/performance';
 import type { McpToolDefinition, CallToolResult } from '../../../packages/protocols/mcp/tool-contract';
 import type { MultiRepositoryMcpToolContext } from '../multi-repository';
-import { allControllerToolDefinitions, controllerExposureSnapshot, controllerToolSurfaceStatus } from '../toolset';
+import { controllerExposureSnapshot, controllerToolSurfaceStatus } from '../toolset';
 import { boundedPluginArtifactImageContent, jsonPreview, result, resultWithPluginArtifactImages } from './result-adapter';
 import { expectedRevision, repositoryRootForRepoId, selected, stringList } from './shared-adapter';
 import { callStatusInboxAdapter, GIT_IDENTITY_SAMPLE_TTL_MS, summarizeInvalidActiveWorkCandidate, summarizeWorkListItem } from './status-inbox-adapter';

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

@@ -43,11 +43,12 @@ export const runtimeToolDefinitions: McpToolDefinition[] = [
     detail_level: { type: 'string', enum: ['summary', 'detail'] },
     limit: { type: 'number' },
   }),
-  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.', {
+  definition('rh_context', 'Read-only semantic repository retrieval and advisory context, including source snippets, paths, symbols, relationships and optional project knowledge. The model chooses when to retrieve context, when to use terminal search through execute_command, and whether the retrieved evidence is sufficient. This tool does not authorize execution or impose a required workflow.', {
     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.' },
+    operation: { type: 'string', enum: ['list', 'get', 'search'], description: 'Defaults to get. Search returns semantic source candidates when the model selects this retrieval capability.' },
     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.' },
+    search_terms: { type: 'array', maxItems: 8, items: { type: 'string', maxLength: 160 }, description: 'Optional model-selected literal code-search terms, ordered by likely relevance. Preserve query as the original user intent; for non-English or descriptive questions about source written in another language, infer repository-language identifiers/phrases (such as the relevant function name, file symbol, or operation keyword) and supply them here. Forge uses bounded lexical ripgrep matching, not automatic translation or semantic embeddings. Refine terms or known_paths when initial candidates are insufficient.' },
     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.' },
@@ -63,7 +64,7 @@ export const runtimeToolDefinitions: McpToolDefinition[] = [
     exclude_globs: { type: 'array', items: { type: 'string' } },
     retrieval_mode: { type: 'string', enum: ['implementation', 'plan', 'debug', 'review'], description: 'Defaults to implementation. Implementation returns current raw impact evidence for ChatGPT to judge; plan/debug/review intentionally widen evidence.' },
     impact_domains: { type: 'array', items: { type: 'string', enum: [...CONTROLLER_CONTEXT_IMPACT_DOMAINS] }, description: 'Optional GPT-selected cross-cutting evidence dimensions. Forge expands these mechanically in the same retrieval call; it never treats them as proof of semantic completeness.' },
-    structural_context: { type: 'string', enum: ['off', 'auto', 'required'], description: 'Optional override. Defaults to auto for implementation/review and required for plan/debug.' },
+    structural_context: { type: 'string', enum: ['off', 'auto', 'required'], description: 'Optional override. Defaults to off for all modes; explicitly opt in only for structural investigations.' },
     semantic_navigation: {
       type: 'array',
       maxItems: 8,
@@ -292,13 +293,13 @@ export const runtimeToolDefinitions: McpToolDefinition[] = [
     min_age_minutes: { type: 'number' },
     max_candidates: { type: 'number' },
   }, ['action_id'], false),
-  definition('runtime_maintenance_status', 'Read the self-contained runtime maintenance plan without using repository_command_execute or Local Job tickets.', {
+  definition('runtime_maintenance_status', 'Read the self-contained runtime maintenance plan without invoking execute_command or creating Local Job tickets.', {
     repo_id: repoId,
     min_age_minutes: { type: 'number' },
     max_candidates: { type: 'number' },
     cancel_pending_approvals: { type: 'boolean' },
   }),
-  definition('runtime_maintenance_apply', 'Apply one bounded runtime maintenance action without repository_command_execute or Local Job tickets.', {
+  definition('runtime_maintenance_apply', 'Apply one bounded runtime maintenance action without invoking execute_command or creating Local Job tickets.', {
     repo_id: repoId,
     action_id: { type: 'string', enum: ['local_jobs_reconcile', 'quarantine_unreadable_local_jobs', 'runtime_storage_finalize_relocation', 'rebuild_projection', 'full_maintenance_pass'] },
     confirm_maintenance: { type: 'boolean' },
@@ -355,7 +356,7 @@ export const runtimeToolDefinitions: McpToolDefinition[] = [
     max_candidates: { type: 'number' },
     confirm_repair: { type: 'boolean' },
   }, ['confirm_repair'], false),
-  definition('list_plugins', 'List repository plugins, or controller-scoped plugins when repo_id is omitted.', {
+  definition('list_plugins', 'List controller plugins and the selected repository plugins. When repo_id is omitted, the current repository context is included automatically; with multiple repositories, provide repo_id. Uses registered manifest snapshots with last-observed capability health; action execution independently validates provider identity and readiness.', {
     repo_id: repoId,
   }),
   definition('get_plugin', 'Read one repository or controller-scoped plugin manifest including action schemas and policy requirements.', {
@@ -453,8 +454,11 @@ 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.' },
+  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 not created by this tool. A standalone task may bind to one existing Work or Requirement for semantic DONE proof; omitting both keeps the unbound standalone contract.', {
+    repo_id: { ...repoId, description: 'Optional repository provenance for start/proof; a repository scope must be available with work_id or requirement_id. Repository identity alone is never Work authority.' },
+    work_id: { type: 'string', minLength: 1, maxLength: 256, description: 'For start, bind the task to this exact Work; for revise, one-way bind an existing unbound task using expected_completion_contract_sha256.' },
+    requirement_id: { type: 'string', minLength: 1, maxLength: 256, description: 'For start, bind the task to this exact Requirement; for revise, one-way bind an existing unbound task using expected_completion_contract_sha256. Mutually exclusive with work_id.' },
+    expected_completion_contract_sha256: { type: 'string', description: 'For revise with work_id or requirement_id, CAS fingerprint returned by supervisor_task get as completionContractSha256.' },
     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.' },
@@ -463,7 +467,8 @@ export const runtimeToolDefinitions: McpToolDefinition[] = [
     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.' },
+    active_only: { type: 'boolean', description: 'For list, defaults true; exclude terminal tasks. Set false for legacy all-task listing.' },
+    terminal_only: { type: 'boolean', description: 'For list, return only canonically terminal DONE/NEEDS_USER/STOPPED task history with exact task and terminal status; does not archive ChatGPT conversations.' },
     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.' },

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

@@ -22,7 +22,6 @@ export {
   runtimeToolDefinitions,
 } from './runtime-tool-definitions';
 import { callWorkAdapter, runFacadeRepair } from './work-adapter';
-import { automationMetadata, persistAutomationReceipt } from './automation-receipt-adapter';
 
 async function callRuntimeToolUnchecked(ctx: MultiRepositoryMcpToolContext, name: string, args: Record<string, unknown>): Promise<CallToolResult | undefined> {
   try {
@@ -68,10 +67,7 @@ async function callRuntimeToolUnchecked(ctx: MultiRepositoryMcpToolContext, name
 }
 
 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;
+  return callRuntimeToolUnchecked(ctx, name, args);
 }
 
 export { runtimeIdentitySnapshot, dispatchedChatgptRelayAuthorizesStaleControllerRecovery, sessionlessFacadeControllerAuthorityMatches } from './controller-authority-adapter';

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

@@ -3,6 +3,7 @@ import type { MultiRepositoryMcpToolContext } from '../multi-repository';
 import { applyScheduleDedupe, buildScheduleDedupeReport, deleteSchedule } from '../../../packages/kernel/scheduler/api/index';
 import { buildFacadeResult } from '../../../src/runtime/control-plane/facade/facade-result';
 import { buildWorkContinuationSnapshot } from '../../../src/runtime/control-plane/facade/work-continuation';
+import { bindWorkflowSupervisorScheduledWakeForWork } from '../../../src/runtime/root/workflow-supervisor-composition';
 import {
   createWorkContinuationSchedule,
   getWorkContinuationSchedule,
@@ -34,6 +35,34 @@ const RH_WORK_SCHEDULE_OPERATIONS = new Set<RhWorkScheduleOperation>([
   'schedule_trigger',
 ]);
 
+async function bindSupervisorWakeForSchedule(
+  ctx: MultiRepositoryMcpToolContext,
+  repoId: string,
+  schedule: { scheduleId: string; action: { operation: string; arguments?: Record<string, unknown> } },
+): Promise<{ status: 'bound' | 'not_enrolled' | 'binding_deferred'; taskId?: string } | undefined> {
+  if (schedule.action.operation !== 'controller_progression' || schedule.action.arguments?.controller_type !== 'chatgpt') {
+    return undefined;
+  }
+  const workId = typeof schedule.action.arguments.work_id === 'string' ? schedule.action.arguments.work_id.trim() : '';
+  if (!workId) throw new Error('SCHEDULE_SUPERVISOR_WAKE_WORK_ID_REQUIRED');
+  try {
+    return await bindWorkflowSupervisorScheduledWakeForWork(
+      { controllerHome: ctx.controllerHome, repoId },
+      workId,
+      schedule.scheduleId,
+    );
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    let pauseFailure = '';
+    try {
+      pauseWorkContinuationSchedule(ctx.controllerHome, repoId, schedule.scheduleId, `Supervisor scheduled-wake binding failed: ${reason}`);
+    } catch (pauseError) {
+      pauseFailure = `; schedule pause also failed: ${pauseError instanceof Error ? pauseError.message : String(pauseError)}`;
+    }
+    throw new Error(`SCHEDULE_SUPERVISOR_WAKE_BINDING_FAILED:${reason}${pauseFailure}`);
+  }
+}
+
 export function isRhWorkScheduleOperation(operation: string): operation is RhWorkScheduleOperation {
   return RH_WORK_SCHEDULE_OPERATIONS.has(operation as RhWorkScheduleOperation);
 }
@@ -105,6 +134,7 @@ export async function callRhWorkScheduleAdapter(
         backoffMaxMinutes: typeof args.backoff_max_minutes === 'number' ? args.backoff_max_minutes : undefined,
         stopConditions: Array.isArray(args.stop_conditions) ? args.stop_conditions.map(String) : undefined,
       });
+      const supervisorWakeBinding = await bindSupervisorWakeForSchedule(ctx, repository.repoId, created.schedule);
       return result(buildFacadeResult({
         summary: created.work
           ? `Work schedule ${created.schedule.scheduleId} is configured for Work ${created.work.workId}.`
@@ -112,6 +142,7 @@ export async function callRhWorkScheduleAdapter(
         data: {
           schedule: created.schedule,
           ...(created.work ? { work: buildWorkContinuationSnapshot(created.work) } : {}),
+          ...(supervisorWakeBinding ? { supervisorWakeBinding } : {}),
         },
       }) as unknown as Record<string, unknown>);
     }
@@ -134,7 +165,11 @@ export async function callRhWorkScheduleAdapter(
     }
     if (operation === 'schedule_resume') {
       const saved = resumeWorkContinuationSchedule(ctx.controllerHome, repository.repoId, scheduleId);
-      return result(buildFacadeResult({ summary: `Schedule ${scheduleId} is resumed.`, data: { schedule: saved } }) as unknown as Record<string, unknown>);
+      const supervisorWakeBinding = await bindSupervisorWakeForSchedule(ctx, repository.repoId, saved);
+      return result(buildFacadeResult({
+        summary: `Schedule ${scheduleId} is resumed.`,
+        data: { schedule: saved, ...(supervisorWakeBinding ? { supervisorWakeBinding } : {}) },
+      }) as unknown as Record<string, unknown>);
     }
     if (operation === 'schedule_delete') {
       const schedule = getWorkContinuationSchedule(ctx.controllerHome, repository.repoId, scheduleId).schedule;

package/adapters/mcp/runtime-gateway/status-inbox-adapter.ts

@@ -2,7 +2,7 @@ import { existsSync } from "fs";
 import { join } from "path";
 import { runProcess } from '../../../src/effects/process-runner';
 import type { MultiRepositoryMcpToolContext } from "../multi-repository";
-import { allControllerToolDefinitions, controllerExposureSnapshot, controllerToolSurfaceStatus } from "../toolset";
+import { controllerExposureSnapshot, controllerToolSurfaceStatus } from "../toolset";
 import { result } from "./result-adapter";
 import { selected, selectedOptional } from "./shared-adapter";
 import { SEMANTIC_SCOPE_KEY } from "../../../src/cli/repositories/controller-home";
@@ -16,7 +16,8 @@ import { cachedGitIdentity, gitSnapshot } from "../../../src/cli/repository/insp
 import { buildRuntimeMaintenanceStatus } from "../../../src/runtime/recovery";
 import { allowedFacadeOperations, buildFacadeResult, listCapabilityDescriptors, summarizeCapabilityGroups, listHandoffAttentionItems, normalizeCheckIds, buildWorkContinuationSnapshot, listPlanContracts, summarizePlanContract, runHandoffInboxApplication, type FacadeTool } from "../../../src/runtime/control-plane/facade";
 import { buildJobOperationDigest } from '../../../src/runtime/control-plane/facade/operation-digest';
-import { readActiveWorkCandidates, type InvalidActiveWorkCandidate } from "../../../packages/kernel/work/api/index";
+import { getWorkContract, readActiveWorkCandidates, semanticWorkState, type InvalidActiveWorkCandidate } from "../../../packages/kernel/work/api/index";
+import { listWorkHandles } from '../../../src/runtime/control-plane/execution/work-handle-store';
 import { observeRuntimeStatus } from "../../../src/runtime/root/status";
 import { getControllerSession } from "../../../packages/kernel/controller/api/index";
 import { listActiveOccurrences, listSchedules, scheduleOwnsWork } from "../../../packages/kernel/scheduler/api/index";
@@ -447,6 +448,7 @@ export async function callStatusInboxAdapter(
         detailTimingMark = now;
       };
       const readiness = await controllerReadinessEvidence(ctx, repository);
+      const runtimeObservation = observeRuntimeStatus(ctx.controllerHome);
       markDetailPhase('readiness');
       const liveGit = gitSnapshot(repository.canonicalRoot);
       markDetailPhase('git');
@@ -455,7 +457,7 @@ export async function callStatusInboxAdapter(
       const runtimeSource = runtimeSourceSnapshotStatus(readiness.daemon.source, ctx.runtimeSourceRoot);
       const sourceSnapshotStale = runtimeSource.restartRequired;
       const exposure = controllerExposureSnapshot(ctx);
-      const localRegisteredToolNames = allControllerToolDefinitions(ctx).map((tool) => tool.name).sort();
+      const localRegisteredToolNames = [...exposure.actualToolNames].sort();
       markDetailPhase('tool_surface');
       const toolSurfaceReady = exposure.ready && exposure.missingToolNames.length === 0;
       // Ordinary interactive execution depends on the execution axis only.
@@ -582,7 +584,7 @@ export async function callStatusInboxAdapter(
         )],
         diagnostics: {
           runtime: {
-            ready: readiness.ready,
+            ready: runtimeObservation.ready,
           },
           toolSurface: {
             ready: toolSurfaceReady,
@@ -644,6 +646,39 @@ export async function callStatusInboxAdapter(
       const pendingHandoffCount = pendingHandoffAttention.length;
       const activeWorkProjection = readActiveWorkCandidates({ ...store, limit: 200 });
       const activeContracts = activeWorkProjection.contracts;
+      // Reuse the exact WorkHandle and semantic Work authorities consulted by
+      // delivery. This is a read-only diagnosis, never a delivery admission gate.
+      const receivingOwners = detailLevel === 'detail'
+        ? listWorkHandles(ctx.controllerHome, repository.repoId)
+        .filter((handle) => {
+          if (handle.checkoutId !== repository.activeCheckoutId
+            || handle.branch !== liveGit.branch
+            || handle.state === 'cleaned' || handle.state === 'failed') return false;
+          const contract = getWorkContract(store, handle.workContractId ?? handle.workId);
+          return Boolean(contract && semanticWorkState(contract) === 'open');
+        })
+        .sort((left, right) => left.workId.localeCompare(right.workId))
+        : [];
+      const headDriftedOwners = receivingOwners.filter((handle) =>
+        Boolean(handle.expectedHead && handle.expectedHead !== liveGit.head));
+      const repositoryDeliveryBlockers = [
+        ...(receivingOwners.length > 1 ? ['WORK_CANONICAL_MUTATION_OWNERSHIP_AMBIGUOUS']
+          : receivingOwners.length ? ['WORK_DELIVERY_TARGET_WORK_ACTIVE'] : []),
+        ...(headDriftedOwners.length ? ['WORK_HANDLE_HEAD_CHANGED'] : []),
+        ...(liveGit.dirty ? ['WORK_DELIVERY_TARGET_DIRTY'] : []),
+      ];
+      const repositoryDeliveryNextSafeAction =
+        receivingOwners.length > 1
+          ? 'Multiple open WorkHandles claim this checkout. Resolve canonical ownership before any Git mutation; do not guess or bypass a writer.'
+          : headDriftedOwners.length && liveGit.dirty
+          ? 'Owning Work: review the uncommitted paths against successor commits, converge its edits, then use explicit work_prepare successor adoption only if ancestry and path disjointness are proven.'
+          : headDriftedOwners.length
+            ? 'Owning Work: verify exact HEAD ancestry and use work_prepare with expected_previous_head/adopt_candidate_head; never silently rebase or reset.'
+            : liveGit.dirty
+              ? 'Owning writer: review and verify the existing dirty paths, then commit through its authorized Work before integrating another candidate; never auto-stash or reset.'
+              : receivingOwners.length
+                ? 'The receiving Work owns this checkout. Integrate reviewed source commits using its own authorized Git path, then reconcile each source Work through canonical deliver_work.'
+                : 'For a validated source Work, use canonical repository.git.deliver_work; this read-only projection does not check live mutation leases or grant integration authority.';
       markDetailPhase('work_state');
       const activePrimaryWork = activeContracts.filter((contract) => (contract.lifecycleRole ?? 'primary') === 'primary');
       const activeExecutionChildren = activeContracts.filter((contract) => contract.lifecycleRole === 'execution_child');
@@ -743,6 +778,25 @@ export async function callStatusInboxAdapter(
           primaryWorkActivityCounts,
           primaryWorkActivities,
           activeContractCount: activeContracts.length,
+          ...(detailLevel === 'detail' ? { repositoryDelivery: {
+            observation: 'work_handle_and_git_snapshot' as const,
+            diagnosticOnly: true,
+            checkoutId: repository.activeCheckoutId,
+            branch: liveGit.branch,
+            head: liveGit.head,
+            dirty: liveGit.dirty,
+            ownerCount: receivingOwners.length,
+            ownersTruncated: receivingOwners.length > 5,
+            owners: receivingOwners.slice(0, 5).map((handle) => ({
+              workId: handle.workId,
+              state: handle.state,
+              expectedHead: handle.expectedHead ?? null,
+              headDrift: Boolean(handle.expectedHead && handle.expectedHead !== liveGit.head),
+            })),
+            blockers: repositoryDeliveryBlockers,
+            nextSafeAction: repositoryDeliveryNextSafeAction,
+            limitations: 'Live leases, source validation, conflict preview and target CAS remain canonical delivery-time checks.',
+          } } : {}),
           invalidActiveContractCount: activeWorkProjection.invalid.length,
           invalidActiveContracts: activeWorkProjection.invalid.slice(0, 10).map(summarizeInvalidActiveWorkCandidate),
           // Summary keeps the stable facade surface only; detail expands to the full registered schema.

package/adapters/mcp/runtime-gateway/typescript-navigation-sidecar.ts

@@ -10,9 +10,10 @@ import {
   navigateTypeScriptSymbol,
   type TypeScriptNavigationRequest,
 } from '../../../src/runtime/context/typescript-navigation';
-import type {
-  SemanticNavigationOutcome,
-  SemanticNavigationReadPolicy,
+import {
+  isIncidentalSemanticDependencyProbe,
+  type SemanticNavigationOutcome,
+  type SemanticNavigationReadPolicy,
 } from '../../../src/runtime/context/semantic-navigation-contract';
 
 interface Envelope {
@@ -83,6 +84,7 @@ export function runTypeScriptNavigationSidecar(
   try {
     for (const request of envelope.requests) {
       let policyDeniedReads = 0;
+      let materialPolicyDeniedReads = 0;
       const policyDeniedReadSamples = new Set<string>();
       try {
         const result = navigateTypeScriptSymbol(repoRoot, request, {
@@ -92,6 +94,7 @@ export function runTypeScriptNavigationSidecar(
             const decision = resolveMcpPath(repoRoot, relativePath, policy, 'read');
             if (decision.ok) return true;
             policyDeniedReads += 1;
+            if (!isIncidentalSemanticDependencyProbe(relativePath)) materialPolicyDeniedReads += 1;
             if (policyDeniedReadSamples.size < 20) policyDeniedReadSamples.add(relativePath);
             return false;
           },
@@ -105,6 +108,7 @@ export function runTypeScriptNavigationSidecar(
             target: result.target,
             locations: result.locations,
             policyDeniedReads,
+            materialPolicyDeniedReads,
             ...(policyDeniedReadSamples.size > 0 ? {
               details: { policyDeniedReadSamples: [...policyDeniedReadSamples] },
             } : {}),