@moretea-labs/forge 1.5.1 → 1.6.0

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

@@ -1,8 +1,9 @@
 import { createHash } from 'crypto';
-import { existsSync } from 'fs';
-import { basename } from 'path';
+import { existsSync, readFileSync, statSync } from 'fs';
+import { basename, isAbsolute, join, relative, resolve, sep } from 'path';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import type { CallToolResult as SdkCallToolResult } from '@modelcontextprotocol/sdk/types.js';
 import { collectRuntimePerformanceDiagnostics, inferLocalControllerProcess } from '../../diagnostics/performance';
 import type { McpToolDefinition, CallToolResult } from '../../../cli/mcp/tools';
 import type { MultiRepositoryMcpToolContext } from '../../../cli/mcp/multi-repository';
@@ -14,11 +15,11 @@ import { repositoryControllerRoot } from '../../../cli/repositories/controller-h
 import { cancelExecutionJob, findExecutionJob, getExecutionJob, getExecutionJobByRequestId, listExecutionJobs } from '../../execution/jobs/store';
 import { waitForExecutionJob } from '../../execution/jobs/wait';
 import type { ExecutionJob } from '../../execution/jobs/types';
-import { getProcessHandle, getProcessRecord, processCheckCompletionReceipt, processRuntimeResourceDiagnostics, readPersistedCheckResultReceipt, runPersistedCheckViaProcessRuntime, waitForProcess } from '../../execution/process-runtime';
+import { getProcessHandle, getProcessRecord, isManagedProcessActive, listProcessRecords, processCheckCompletionReceipt, processRuntimeResourceDiagnostics, readPersistedCheckResultReceipt, runPersistedCheckViaProcessRuntime, waitForProcess } from '../../execution/process-runtime';
 import { buildJobOperationDigest } from '../../control-plane/facade/operation-digest';
-import { readWorkHandle, type WorkHandleState } from '../../control-plane/execution/work-handle-store';
+import { readWorkHandle, transitionWorkHandle, writeWorkHandle, type WorkHandleState } from '../../control-plane/execution/work-handle-store';
 import { executionIdentityForRepository } from '../../control-plane/execution/execution-identity';
-import { reconcileFinalizedDirectEditWorksAfterCommit } from '../../control-plane/execution/direct-edit-work-completion';
+import { acceptReviewedDirectEditWorkReconciliation, reconcileFinalizedDirectEditWorksAfterCommit } from '../../control-plane/execution/direct-edit-work-completion';
 import { readJobEvents } from '../../evidence/event-ledger';
 import { readExecutionArtifact } from '../../evidence/artifact-store';
 import { readExecutionEvidence } from '../../evidence/evidence-store';
@@ -44,11 +45,6 @@ import { applyScheduleDedupe, buildScheduleDedupeReport, createSchedule, getSche
 import { evaluateSchedule } from '../../workflow/schedules/engine';
 import {
   createWorkContinuationSchedule,
-  getWorkContinuationSchedule,
-  listWorkContinuationSchedules,
-  pauseWorkContinuationSchedule,
-  resumeWorkContinuationSchedule,
-  triggerWorkContinuationSchedule,
   type ContinuationControllerType,
 } from '../../workflow/schedules/work-continuation';
 import { createPortfolioWorkflow, getPortfolioWorkflow, listPortfolioWorkflows } from '../../workflow/portfolio/store';
@@ -109,10 +105,6 @@ import { resolveLocalBridgeSurface, summarizeRecentJobs } from '../../shared/loc
 import { assistantPluginScope, controllerPluginRepository, executeAssistantPluginReadDirect, getAssistantPluginManifest, isDirectPluginReadAction, listAssistantPluginManifests, submitAssistantPluginAction } from '../../plugins/store';
 import { mcpPluginExecutionOrigin } from '../../plugins/execution-origin';
 import {
-  listWebTargets,
-  mergeAllowedDomains,
-  previewBrowserDomainAccess,
-  resolveWebTargetUrl,
   summarizeExecutionJobForMcp,
   summarizeJobResultForLowInterception,
   summarizePluginForLowInterception,
@@ -205,7 +197,9 @@ import {
   releaseControllerSession,
   resumeControllerSession,
 } from '../../control-plane/facade';
-import { currentControllerInstanceId, startExecutionSession, updateExecutionSession } from '../../control-plane/execution/session-store';
+import { currentControllerInstanceId, readExecutionSession, startExecutionSession, updateExecutionSession } from '../../control-plane/execution/session-store';
+import { ensureManagedWorkspace } from '../../execution/managed-workspace';
+import { currentPermissionSnapshotVersion } from '../../control-plane/execution/validation';
 import { observeRuntimeStatus } from '../../root/status';
 import { reconcileWorkValidation } from './work-validation-reconciler';
 import { callExecutionTool } from './execution-tools';
@@ -296,9 +290,15 @@ export const runtimeToolDefinitions: McpToolDefinition[] = [
   }),
   definition('rh_work', 'Preferred ChatGPT facade: bounded planning, direct control, controller ownership, and external SuperController launch.', {
     repo_id: repoId,
-    operation: { type: 'string', enum: ['start', 'continue', 'verify', 'repair', 'finalize', 'stop', 'delegate', 'controller_claim', 'controller_release', 'controller_get_owner', 'launcher_start', 'plan_create', 'plan_get', 'plan_list', 'plan_approve', 'plan_supersede', 'schedule_create', 'schedule_list', 'schedule_get', 'schedule_pause', 'schedule_resume', 'schedule_trigger'], description: 'Defaults to start. Complex starts require plan_id and plan_step_id. schedule_* manages bounded external-controller continuation for existing Work.' },
+    operation: { type: 'string', enum: ['start', 'continue', 'verify', 'repair', 'finalize', 'stop', 'delegate', 'controller_claim', 'controller_release', 'controller_get_owner', 'launcher_start', 'plan_create', 'plan_get', 'plan_list', 'plan_approve', 'plan_supersede', 'schedule_create', 'schedule_list', 'schedule_get', 'schedule_pause', 'schedule_resume', 'schedule_trigger'], description: 'Defaults to start. Complex starts require plan_id and plan_step_id. schedule_* manages generic recurring ChatGPT workflow schedules plus Work-bound continuation/browser subtypes.' },
     objective: { type: 'string' },
     work_id: { type: 'string' },
+    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: 'Existing active Plan selected when resolving another slice under the same Requirement.' },
+    plan_relation: { type: 'string', enum: ['extend', 'parallel'], description: 'Relationship to another active Plan under the same Requirement. Omit to receive candidates first. parallel explicitly permits a distinct Plan slice; extend reuses the existing Plan authority and requires replanning/supersession instead of creating another draft.' },
+    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 used to find related active Work before creation.' },
     handoff_id: { type: 'string', description: 'Optional existing HandoffItem used to resume controller context.' },
     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.' },
@@ -309,10 +309,23 @@ export const runtimeToolDefinitions: McpToolDefinition[] = [
     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.' },
-    continuation_prompt: { type: 'string', description: 'Additional bounded continuation instruction appended to the Work/Handoff prompt.' },
+    continuation_prompt: { type: 'string', description: 'Bounded Work continuation instruction, or the recurring ChatGPT prompt when schedule_mode=workflow and objective is omitted.' },
     schedule_id: { type: 'string', description: 'Schedule identity for schedule_get/pause/resume/trigger.' },
-    schedule_name: { type: 'string', description: 'Human-readable schedule name; defaults to Continue Work <work_id>.' },
+    schedule_name: { type: 'string', description: 'Human-readable schedule name; generic workflow schedules use the objective/prompt when omitted.' },
     schedule_request_id: { type: 'string', description: 'Stable idempotency key for schedule_create.' },
+    schedule_mode: { type: 'string', enum: ['workflow', 'continuation', 'browser_watch', 'browser_keepalive'], description: 'Defaults to workflow when work_id is omitted and continuation when work_id is present. workflow dispatches one bounded ChatGPT prompt per finite Occurrence without requiring Work; continuation/browser modes remain Work-bound.' },
+    probe_url: { type: 'string', description: 'Allowed URL to navigate or refresh for browser_watch/browser_keepalive.' },
+    probe_browser_session_id: { type: 'string', description: 'Existing Forge browser session used as the external observation target.' },
+    probe_selector: { type: 'string', description: 'Optional selector limiting text extraction for browser_watch.' },
+    probe_max_chars: { type: 'number', description: 'Bounded extracted text size for browser_watch.' },
+    probe_timeout_ms: { type: 'number', description: 'Bounded browser probe timeout.' },
+    include_terms: { type: 'array', items: { type: 'string' }, description: 'Optional case-insensitive terms; only matching normalized lines contribute to the observation fingerprint.' },
+    ignore_patterns: { type: 'array', items: { type: 'string' }, description: 'Optional regex patterns stripped before fingerprinting volatile text such as relative timestamps.' },
+    login_url_terms: { type: 'array', items: { type: 'string' }, description: 'Configured URL markers that classify the browser observation as authentication-required.' },
+    login_text_terms: { type: 'array', items: { type: 'string' }, description: 'Configured page-text markers that classify the browser observation as authentication-required.' },
+    wake_on_first_observation: { type: 'boolean', description: 'Defaults false so the first browser_watch occurrence records a silent baseline.' },
+    wake_on_auth_required: { type: 'boolean', description: 'Defaults true for Work-bound browser schedules.' },
+    auth_required_prompt: { type: 'string', description: 'Optional ChatGPT continuation instruction when the probe detects a login marker.' },
     trigger_type: { type: 'string', enum: ['interval', 'cron', 'calendar', 'condition', 'repository-event', 'dependency-checkpoint', 'manual'] },
     every_minutes: { type: 'number', description: 'Interval trigger cadence in minutes.' },
     cron_expression: { type: 'string' },
@@ -383,12 +396,18 @@ export const runtimeToolDefinitions: McpToolDefinition[] = [
     no_ff: { type: 'boolean' },
     completion_outcome: { type: 'string', enum: ['completed_changed', 'completed_no_change'] },
     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 Direct Edit Work whose original Work binding/receipt is missing.' },
+    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_submit', 'Submit one durable repository operation and return a resumable Work handle.', {
     repo_id: repoId,
-    request_id: { type: 'string', description: 'Stable idempotency key used to resume the same Work after reconnecting.' },
+    request_id: { type: 'string', description: 'Stable idempotency key used to resume the same execution-child Work after reconnecting.' },
+    parent_work_id: { type: 'string', description: 'Optional active primary Work that owns this low-level execution child. work_submit never creates a second business-workflow authority.' },
     operation: { type: 'string', description: 'Existing durable controller operation, for example run_check, dispatch_task, or create_issue.' },
     arguments: { type: 'object', description: 'Arguments passed to the durable operation.' },
     timeout_ms: { type: 'number' },
@@ -718,6 +737,7 @@ export const runtimeToolDefinitions: McpToolDefinition[] = [
     plugin_id: { type: 'string' },
     action_id: { type: 'string' },
     request_id: { type: 'string' },
+    work_id: { type: 'string', description: 'Optional existing remote-effect Work that should own the successful typed plugin receipt.' },
     arguments: { type: 'object' },
     timeout_ms: { type: 'number' },
     confirm_authorization: { type: 'boolean' },
@@ -727,34 +747,6 @@ export const runtimeToolDefinitions: McpToolDefinition[] = [
     repo_id: repoId,
     plugin_id: { type: 'string' },
   }, ['plugin_id']),
-  definition('web_targets_list', 'List pre-allowed web targets as domain keys. This avoids arbitrary URL parameters.', {
-    repo_id: repoId,
-  }),
-  definition('web_target_snapshot', 'Create a read-only browser snapshot for a pre-allowed web target by target_key and path. Does not accept arbitrary URLs.', {
-    repo_id: repoId,
-    target_key: { type: 'string' },
-    path: { type: 'string' },
-    query: { type: 'object' },
-    capture: { type: 'string', enum: ['title', 'text', 'screenshot'] },
-    wait_until: { type: 'string', enum: ['load', 'domcontentloaded', 'networkidle'] },
-    max_chars: { type: 'number' },
-    full_page: { type: 'boolean' },
-    request_id: { type: 'string' },
-    timeout_ms: { type: 'number' },
-  }, ['target_key', 'request_id'], false),
-  definition('web_domain_access_preview', 'Preview a browser domain access request without writing plugin config or accepting arbitrary URLs.', {
-    repo_id: repoId,
-    domain: { type: 'string' },
-    reason: { type: 'string' },
-  }, ['domain']),
-  definition('web_domain_access_apply', 'Apply a previously previewed browser domain access request through browser configuration with explicit authorization.', {
-    repo_id: repoId,
-    domain: { type: 'string' },
-    reason: { type: 'string' },
-    preview_ticket_id: { type: 'string' },
-    request_id: { type: 'string' },
-    confirm_authorization: { type: 'boolean' },
-  }, ['domain', 'request_id', 'confirm_authorization'], false),
   definition('work_result_summary', 'Return a redacted job result summary with failure class and suggested next actions. Does not return raw stdout or stderr.', {
     repo_id: repoId,
     job_id: { type: 'string' },
@@ -1123,6 +1115,77 @@ function result(value: Record<string, unknown>, isError = false): CallToolResult
   return { content: [{ type: 'text', text: JSON.stringify(value) }], structuredContent: value, ...(isError ? { isError: true } : {}) };
 }
 
+const MAX_INLINE_PLUGIN_IMAGE_BYTES = 8 * 1024 * 1024;
+const MAX_INLINE_PLUGIN_IMAGES = 4;
+const INLINE_PLUGIN_IMAGE_MEDIA_TYPES = new Set(['image/png', 'image/jpeg', 'image/webp']);
+
+type McpImageContent = Extract<SdkCallToolResult['content'][number], { type: 'image' }>;
+
+export function boundedPluginArtifactImageContent(
+  controllerHome: string,
+  repoId: string,
+  pluginResult: Record<string, unknown> | undefined,
+): McpImageContent[] {
+  if (!pluginResult) return [];
+  const nestedResult = pluginResult.result && typeof pluginResult.result === 'object' && !Array.isArray(pluginResult.result)
+    ? pluginResult.result as Record<string, unknown>
+    : undefined;
+  const candidates = [
+    ...(Array.isArray(pluginResult.artifactCandidates) ? pluginResult.artifactCandidates : []),
+    ...(nestedResult && Array.isArray(nestedResult.artifactCandidates) ? nestedResult.artifactCandidates : []),
+  ];
+  if (candidates.length === 0) return [];
+  const allowedRoot = resolve(repositoryControllerRoot(controllerHome, repoId));
+  const images: McpImageContent[] = [];
+  const seenPaths = new Set<string>();
+
+  for (const candidate of candidates) {
+    if (images.length >= MAX_INLINE_PLUGIN_IMAGES) break;
+    if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) continue;
+    const record = candidate as Record<string, unknown>;
+    const mediaType = typeof record.mediaType === 'string' ? record.mediaType : '';
+    const path = typeof record.path === 'string' ? record.path : '';
+    if (!INLINE_PLUGIN_IMAGE_MEDIA_TYPES.has(mediaType) || !path) continue;
+
+    const resolvedPath = resolve(path);
+    if (seenPaths.has(resolvedPath)) continue;
+    const rel = relative(allowedRoot, resolvedPath);
+    if (rel === '..' || rel.startsWith(`..${sep}`) || isAbsolute(rel)) continue;
+    if (!existsSync(resolvedPath)) continue;
+
+    try {
+      const stat = statSync(resolvedPath);
+      if (!stat.isFile() || stat.size <= 0 || stat.size > MAX_INLINE_PLUGIN_IMAGE_BYTES) continue;
+      images.push({
+        type: 'image',
+        data: readFileSync(resolvedPath).toString('base64'),
+        mimeType: mediaType,
+      });
+      seenPaths.add(resolvedPath);
+    } catch {
+      // The structured plugin result remains authoritative when an artifact cannot be inlined.
+    }
+  }
+
+  return images;
+}
+
+function resultWithPluginArtifactImages(
+  value: Record<string, unknown>,
+  controllerHome: string,
+  repoId: string,
+  pluginResult: Record<string, unknown> | undefined,
+): CallToolResult {
+  const images = boundedPluginArtifactImageContent(controllerHome, repoId, pluginResult);
+  const richResult: SdkCallToolResult = {
+    content: [{ type: 'text', text: JSON.stringify(value) }, ...images],
+    structuredContent: value,
+  };
+  // The legacy internal facade intentionally types content as text-first for existing callers.
+  // The MCP wire contract supports additional SDK image blocks after that stable first text block.
+  return richResult as unknown as CallToolResult;
+}
+
 function repositoryRootForRepoId(controllerHome: string, repoId: string): string | undefined {
   return listRepositories(controllerHome).find((repository) => repository.repoId === repoId)?.canonicalRoot;
 }
@@ -1543,6 +1606,64 @@ function authenticatedFacadeControllerIdentity(
   };
 }
 
+function ensureFacadeWorkHandle(
+  ctx: MultiRepositoryMcpToolContext,
+  repository: ReturnType<typeof selected>,
+  workId: string,
+  args: Record<string, unknown>,
+): WorkHandleState | undefined {
+  const existing = readWorkHandle(ctx.controllerHome, repository.repoId, workId);
+  if (existing) return existing;
+  const contract = getWorkContract({ controllerHome: ctx.controllerHome, repoId: repository.repoId }, workId);
+  if (!contract || contract.workKind !== 'repository_change' || contract.mode !== 'goal_workloop' || !contract.checkoutId) return undefined;
+  const executionRepository = resolveRepositorySelection({ repoId: repository.repoId, checkoutId: contract.checkoutId, controllerHome: ctx.controllerHome, allowSoleRepository: false });
+  const checkout = selectRepositoryCheckout(executionRepository, contract.checkoutId, { allowArchived: true });
+  const status = repositoryGitStatus(checkout);
+  if (!status.branch) throw new Error(`WORKTREE_DETACHED: ${contract.checkoutId} has no branch`);
+  const identity = authenticatedFacadeControllerIdentity(ctx, args);
+  const at = new Date().toISOString();
+  const managedWorktree = Boolean(contract.worktreeRef) && resolve(contract.worktreeRef!) === resolve(checkout.canonicalRoot) && resolve(checkout.canonicalRoot) !== resolve(repository.canonicalRoot);
+  return writeWorkHandle(ctx.controllerHome, {
+    schemaVersion: 1,
+    workId,
+    sessionId: identity.sessionId,
+    principalId: identity.principalId,
+    repositoryId: repository.repoId,
+    checkoutId: contract.checkoutId,
+    worktreePath: checkout.canonicalRoot,
+    branch: status.branch,
+    sourceCheckoutId: repository.activeCheckoutId,
+    managedWorktree,
+    workContractId: contract.workId,
+    baseCommit: contract.baseRevision ?? status.head ?? undefined,
+    expectedHead: status.head ?? contract.baseRevision,
+    permissionSnapshotVersion: currentPermissionSnapshotVersion(ctx.controllerHome, repository.repoId),
+    state: 'prepared',
+    createdAt: at,
+    updatedAt: at,
+    finalization: { validation: 'pending', commit: 'pending', merge: 'pending', branchCleanup: 'pending', worktreeCleanup: 'pending' },
+    cleanupResponsibility: { owner: 'work_finalizer', registeredAt: at },
+  });
+}
+
+function claimNewFacadeWork(
+  ctx: MultiRepositoryMcpToolContext,
+  repository: ReturnType<typeof selected>,
+  workId: string,
+  args: Record<string, unknown>,
+) {
+  const identity = authenticatedFacadeControllerIdentity(ctx, args);
+  return resumeControllerSession({ controllerHome: ctx.controllerHome, repoId: repository.repoId }, {
+    workId,
+    controllerId: identity.controllerId,
+    controllerType: identity.controllerType,
+    sessionId: identity.sessionId,
+    principalId: identity.principalId,
+    controllerInstanceId: identity.controllerInstanceId,
+    leaseMs: typeof args.lease_ms === 'number' ? args.lease_ms : undefined,
+  });
+}
+
 function bindFacadeExecutionSession(
   ctx: MultiRepositoryMcpToolContext,
   repository: ReturnType<typeof selected>,
@@ -1623,14 +1744,7 @@ async function finalizeFacadeWorkHandle(
     ...(noChangeEvidence ? { no_change_evidence: noChangeEvidence } : {}),
   };
 
-  let physical = await callExecutionTool(ctx, 'work_finalize', finalizeArgs);
-  let payload = contextRecord(physical?.structuredContent);
-  if (
-    physical
-    && physical.isError !== true
-    && typeof payload.continuation === 'string'
-    && payload.continuation.startsWith('WORK_COMMITTED_REVALIDATION_REQUIRED')
-  ) {
+  const validateExactWorkspace = async (): Promise<CallToolResult | undefined> => {
     const contract = getWorkContract({ controllerHome: ctx.controllerHome, repoId: repository.repoId }, workId);
     const validation = await callExecutionTool(ctx, 'work_validate', {
       session_id: session.sessionId,
@@ -1640,13 +1754,38 @@ async function finalizeFacadeWorkHandle(
     });
     if (!validation || validation.isError === true) return validation;
     const validationPayload = contextRecord(validation.structuredContent);
-    if (contextRecord(validationPayload.validation).passed !== true) return validation;
+    return contextRecord(validationPayload.validation).passed === true ? undefined : validation;
+  };
+
+  let physical = await callExecutionTool(ctx, 'work_finalize', finalizeArgs);
+  let payload = contextRecord(physical?.structuredContent);
+  if (physical?.isError === true && contextRecord(payload.error).code === 'WORK_VALIDATION_REQUIRED') {
+    const validationFailure = await validateExactWorkspace();
+    if (validationFailure) return validationFailure;
     physical = await callExecutionTool(ctx, 'work_finalize', finalizeArgs);
     payload = contextRecord(physical?.structuredContent);
   }
+  if (
+    physical
+    && physical.isError !== true
+    && typeof payload.continuation === 'string'
+    && payload.continuation.startsWith('WORK_COMMITTED_REVALIDATION_REQUIRED')
+  ) {
+    const validationFailure = await validateExactWorkspace();
+    if (validationFailure) return validationFailure;
+    physical = await callExecutionTool(ctx, 'work_finalize', finalizeArgs);
+  }
   return physical;
 }
 
+function structuralIndexRoot(repository: ReturnType<typeof resolveRepositorySelection>): string | undefined {
+  if (existsSync(join(repository.canonicalRoot, '.codegraph', 'codegraph.db'))) return repository.canonicalRoot;
+  return repository.checkouts
+    .filter((checkout) => checkout.checkoutId !== repository.activeCheckoutId && checkout.worktree !== true)
+    .map((checkout) => checkout.canonicalRoot)
+    .find((root) => existsSync(join(root, '.codegraph', 'codegraph.db')));
+}
+
 function selected(ctx: MultiRepositoryMcpToolContext, args: Record<string, unknown>) {
   return resolveRepositorySelection({
     repoId: typeof args.repo_id === 'string' ? args.repo_id : undefined,
@@ -2569,15 +2708,18 @@ async function runFacadeVerify(
     const requestId = typeof args.request_id === 'string' && args.request_id.trim()
       ? args.request_id.trim()
       : undefined;
-    const observedGitHead = repositoryGitStatus(repository).head;
     const workContract = workId ? getWorkContract(store, workId) : undefined;
     if (workId && !workContract) throw new Error(`WORK_NOT_FOUND: ${workId}`);
+    const verificationRepository = workContract?.checkoutId
+      ? selectRepositoryCheckout(repository, workContract.checkoutId, { allowArchived: true })
+      : repository;
+    const observedGitHead = repositoryGitStatus(verificationRepository).head;
     const executed = await runPersistedCheckViaProcessRuntime({
       controllerHome: ctx.controllerHome,
-      repoId: repository.repoId,
-      checkoutId: repository.activeCheckoutId,
-      repoRoot: repository.canonicalRoot,
-      executionIdentity: executionIdentityForRepository(repository, workId ? { workId } : {}),
+      repoId: verificationRepository.repoId,
+      checkoutId: verificationRepository.activeCheckoutId,
+      repoRoot: verificationRepository.canonicalRoot,
+      executionIdentity: executionIdentityForRepository(verificationRepository, workId ? { workId } : {}),
       checkId: normalizedCheckId,
       timeoutMs: typeof args.timeout_ms === 'number' ? args.timeout_ms : undefined,
       // rh_work.verify is a control-plane continuation primitive: callers should
@@ -2620,7 +2762,7 @@ async function runFacadeVerify(
 
     const handle = executed.process;
     if (!handle) throw new Error(`PROCESS_CHECK_HANDLE_MISSING: ${normalizedCheckId}`);
-    const record = getProcessRecord(ctx.controllerHome, repository.repoId, handle.processId);
+    const record = getProcessRecord(ctx.controllerHome, verificationRepository.repoId, handle.processId);
     const checkContentRevision = record?.checkExecution?.revision;
 
     if (!handle.completed) {
@@ -2651,11 +2793,11 @@ async function runFacadeVerify(
 
     if (!record) throw new Error(`PROCESS_CHECK_RECORD_MISSING: ${handle.processId}`);
     const receipt = processCheckCompletionReceipt(record, {
-      repoId: repository.repoId,
+      repoId: verificationRepository.repoId,
       checkId: normalizedCheckId,
       processId: handle.processId,
       ...(record.checkExecution ? {
-        checkoutId: repository.activeCheckoutId,
+        checkoutId: verificationRepository.activeCheckoutId,
         workId: workId || undefined,
         requestId,
         checkExecution: {
@@ -2677,7 +2819,7 @@ async function runFacadeVerify(
     );
     const legacyEvidence = record.origin?.checkResultReceiptPath
       ? undefined
-      : readLatestControllerCheckEvidence(repository.canonicalRoot, normalizedCheckId);
+      : readLatestControllerCheckEvidence(verificationRepository.canonicalRoot, normalizedCheckId);
     const legacyEvidenceMatchesProcess = Boolean(
       legacyEvidence?.cacheKey
       && record.checkExecution?.cacheKey
@@ -2922,7 +3064,14 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
         });
         const capabilities = listCapabilityDescriptors(manifests);
         const pendingHandoffs = listHandoffItems({ ...store, status: 'pending', limit: 20 });
-        const activeWork = listWorkContracts({ ...store, status: 'active', limit: 20 });
+        const activeContracts = listWorkContracts({ ...store, status: 'active', limit: 200 });
+        const activePrimaryWork = activeContracts.filter((contract) => (contract.lifecycleRole ?? 'primary') === 'primary');
+        const activeExecutionChildren = activeContracts.filter((contract) => contract.lifecycleRole === 'execution_child');
+        const activeRuntimeInstanceId = currentControllerInstanceId();
+        const activeProcessRecords = listProcessRecords(ctx.controllerHome, repository.repoId, 500).filter((process) => isManagedProcessActive(process) && (!process.runtimeInstanceId || process.runtimeInstanceId === activeRuntimeInstanceId));
+        const activeProcessWorkIds = new Set(activeProcessRecords.map((process) => process.workId).filter((workId): workId is string => Boolean(workId)));
+        const activeControllerWorkIds = new Set(activePrimaryWork.filter((contract) => Boolean(getControllerSession({ controllerHome: ctx.controllerHome, repoId: repository.repoId }, contract.workId))).map((contract) => contract.workId));
+        const executingPrimaryWorkIds = new Set([...activeProcessWorkIds, ...activeControllerWorkIds].filter((workId) => activePrimaryWork.some((contract) => contract.workId === workId)));
         const preferredFacadeTools = ['rh_access', 'rh_status', 'rh_inbox', 'rh_context', 'rh_work'] as const;
         const facade = buildFacadeResult({
           status: effectiveReady ? 'ok' : 'blocked',
@@ -2951,7 +3100,15 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
               dynamicDomainSchemaLoadingSupported: false,
             },
             pendingHandoffCount: pendingHandoffs.length,
-            activeWorkCount: activeWork.length,
+            // User-facing Work count means objective-level primary lanes. Low-level
+            // resumable operation handles are reported separately.
+            activeWorkCount: activePrimaryWork.length,
+            activePrimaryWorkCount: activePrimaryWork.length,
+            activeExecutionChildCount: activeExecutionChildren.length,
+            activeProcessCount: activeProcessRecords.length,
+            executingPrimaryWorkCount: executingPrimaryWorkIds.size,
+            waitingPrimaryWorkCount: Math.max(0, activePrimaryWork.length - executingPrimaryWorkIds.size),
+            activeContractCount: activeContracts.length,
             // Summary keeps the stable facade surface only; detail expands to the full registered schema.
             toolSurface: detailLevel === 'detail'
               ? exposure.actualToolNames
@@ -3099,6 +3256,7 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
             maxFiles: typeof args.max_files === 'number' ? args.max_files : undefined,
             maxSnippets: typeof args.max_snippets === 'number' ? args.max_snippets : undefined,
             structuralContext,
+            structuralIndexRoot: structuralContext === 'off' ? undefined : structuralIndexRoot(repository),
             retrievalMode,
             impactDomains,
           });
@@ -3116,6 +3274,7 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
               goal: pack.goal,
               search: pack.search,
               structuralContext: pack.structuralContext,
+              impactContext: pack.impactContext,
               files: pack.files,
               deniedPaths: pack.deniedPaths,
               omitted: pack.omitted,
@@ -3167,6 +3326,11 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
             .filter((job) => timestampIsCurrent(job.updatedAt, currentCutoffMs))
             .slice(0, 5)
           : [];
+        const processScan = listProcessRecords(ctx.controllerHome, repository.repoId, workId ? 100 : 50);
+        const relevantProcesses = processScan.filter((process) => workId ? process.workId === workId : timestampIsCurrent(process.updatedAt, currentCutoffMs));
+        const activeRuntimeInstanceId = currentControllerInstanceId();
+        const activeProcesses = relevantProcesses.filter((process) => isManagedProcessActive(process) && (!process.runtimeInstanceId || process.runtimeInstanceId === activeRuntimeInstanceId));
+        const workController = work ? getControllerSession(store, work.workId) : undefined;
         const repositoryManifests = listAssistantPluginManifests(ctx.controllerHome, repository, {
           preferStored: true,
         });
@@ -3204,6 +3368,7 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
             || timestampIsCurrent(item.updatedAt, currentCutoffMs)
           ))
           : pendingAttention;
+        const workAttention = work ? currentAttentionScan.find((item) => item.workId === work.workId) : undefined;
         const currentAttentionItems = isSummary
           ? currentAttentionScan.slice(0, 3)
           : pendingAttention;
@@ -3259,6 +3424,10 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
               }
             : undefined,
           executionJob: executionJob ? summarizeWorkListItem(executionJob) : undefined,
+          executionState: work ? (workAttention ? 'blocked' : activeProcesses.length > 0 ? 'executing' : workController ? 'controller_active' : 'waiting_trigger') : undefined,
+          activeController: workController ? { controllerType: workController.controllerType, sessionId: workController.sessionId, leaseExpiresAt: workController.leaseExpiresAt } : undefined,
+          activeProcesses: activeProcesses.slice(0, 3).map((process) => ({ processId: process.processId, workId: process.workId, status: process.status, route: process.route, startedAt: process.startedAt, updatedAt: process.updatedAt })),
+          recentProcesses: relevantProcesses.slice(0, 5).map((process) => ({ processId: process.processId, workId: process.workId, status: process.status, route: process.route, startedAt: process.startedAt, updatedAt: process.updatedAt })),
           activeWork: activeContracts.map((entry) => ({
             workId: entry.workId,
             status: entry.status,
@@ -3281,6 +3450,8 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
             historicalNonTerminalWork: Math.max(0, activeContractScan.length - currentContractScan.length),
             currentAttention: currentAttentionScan.length,
             currentAttentionShown: attention.length,
+            activeProcesses: activeProcesses.length,
+            recentProcesses: relevantProcesses.length,
             pendingAttentionScanned: pendingAttention.length,
             historicalPendingAttention: Math.max(0, pendingAttention.length - currentAttentionScan.length),
             omittedCurrentAttention: Math.max(0, currentAttentionScan.length - attention.length),
@@ -3318,6 +3489,10 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
           },
           work: work ? { ...work, continuation: buildWorkContinuationSnapshot(work) } : undefined,
           executionJob: executionJob ? summarizeWorkListItem(executionJob) : undefined,
+          executionState: work ? (workAttention ? 'blocked' : activeProcesses.length > 0 ? 'executing' : workController ? 'controller_active' : 'waiting_trigger') : undefined,
+          activeController: workController,
+          activeProcesses: activeProcesses.slice(0, 10),
+          recentProcesses: relevantProcesses.slice(0, 20),
           activeWork: activeContracts.map((entry) => ({
             workId: entry.workId,
             status: entry.status,
@@ -3333,6 +3508,8 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
             capabilities: capabilities.length,
             activeWork: activeContracts.length,
             recentExecutionJobs: recentJobs.length,
+            activeProcesses: activeProcesses.length,
+            recentProcesses: relevantProcesses.length,
             activeAttention: attention.length,
           },
           bounded: true,
@@ -3385,8 +3562,59 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
               const triggerType = ['interval', 'cron', 'calendar', 'condition', 'repository-event', 'dependency-checkpoint', 'manual'].includes(triggerTypeRaw)
                 ? triggerTypeRaw as 'interval' | 'cron' | 'calendar' | 'condition' | 'repository-event' | 'dependency-checkpoint' | 'manual'
                 : undefined;
+              const scheduleModeRaw = String(args.schedule_mode ?? (workId ? 'continuation' : 'workflow')).trim();
+              if (!['workflow', 'continuation', 'browser_watch', 'browser_keepalive'].includes(scheduleModeRaw)) throw new Error('SCHEDULE_MODE_INVALID');
+              if (scheduleModeRaw === 'workflow') {
+                if (controllerType !== 'chatgpt') throw new Error('WORKFLOW_SCHEDULE_CONTROLLER_TYPE_UNSUPPORTED');
+                const prompt = (typeof args.objective === 'string' ? args.objective : typeof args.continuation_prompt === 'string' ? args.continuation_prompt : '').trim();
+                if (!prompt) throw new Error('WORKFLOW_SCHEDULE_PROMPT_REQUIRED');
+                const trigger = {
+                  type: triggerType ?? (typeof args.every_minutes === 'number' ? 'interval' : 'manual'),
+                  everyMinutes: typeof args.every_minutes === 'number' ? Math.max(1, Math.trunc(args.every_minutes)) : undefined,
+                  cronExpression: typeof args.cron_expression === 'string' ? args.cron_expression : undefined,
+                  timezone: typeof args.schedule_timezone === 'string' ? args.schedule_timezone : undefined,
+                  catchUpMinutes: typeof args.catch_up_minutes === 'number' ? Math.max(0, Math.trunc(args.catch_up_minutes)) : undefined,
+                  calendarAt: typeof args.calendar_at === 'string' ? args.calendar_at : undefined,
+                  condition: args.condition && typeof args.condition === 'object' && !Array.isArray(args.condition) ? args.condition as never : undefined,
+                  eventName: typeof args.event_name === 'string' ? args.event_name : undefined,
+                  dependencyJobIds: Array.isArray(args.dependency_job_ids) ? args.dependency_job_ids.map(String) : undefined,
+                };
+                const policy = {
+                  maxActiveOccurrences: 1,
+                  maxFailures: typeof args.max_failures === 'number' ? Math.max(1, Math.trunc(args.max_failures)) : 3,
+                  cooldownMinutes: typeof args.cooldown_minutes === 'number' ? Math.max(0, Math.trunc(args.cooldown_minutes)) : 120,
+                  dailyBudgetMinutes: typeof args.daily_budget_minutes === 'number' ? Math.max(1, Math.trunc(args.daily_budget_minutes)) : 180,
+                  shadowMode: args.shadow_mode !== false,
+                  backoffBaseMinutes: typeof args.backoff_base_minutes === 'number' ? Math.max(1, Math.trunc(args.backoff_base_minutes)) : 5,
+                  backoffMaxMinutes: typeof args.backoff_max_minutes === 'number' ? Math.max(1, Math.trunc(args.backoff_max_minutes)) : 24 * 60,
+                };
+                const actionArguments = {
+                  prompt,
+                  ...(typeof args.browser_session_id === 'string' && args.browser_session_id.trim() ? { browser_session_id: args.browser_session_id.trim() } : {}),
+                  ...(typeof args.conversation_url === 'string' && args.conversation_url.trim() ? { conversation_url: args.conversation_url.trim() } : {}),
+                };
+                assertAutomatedOperationAllowed('chatgpt_browser_prompt', actionArguments);
+                const name = typeof args.schedule_name === 'string' && args.schedule_name.trim() ? args.schedule_name.trim() : `Workflow: ${prompt.slice(0, 80)}`;
+                const stopConditions = Array.isArray(args.stop_conditions) ? args.stop_conditions.map(String) : [];
+                const semantic = JSON.stringify({ repoId: repository.repoId, name, trigger, policy, actionArguments, stopConditions });
+                const requestId = typeof args.schedule_request_id === 'string' && args.schedule_request_id.trim()
+                  ? args.schedule_request_id.trim()
+                  : `workflow-schedule:${repository.repoId}:${createHash('sha256').update(semantic).digest('hex').slice(0, 20)}`;
+                const schedule = createSchedule(ctx.controllerHome, {
+                  requestId,
+                  repoId: repository.repoId,
+                  name,
+                  enabled: true,
+                  trigger,
+                  policy,
+                  action: { operation: 'chatgpt_browser_prompt', target: 'runtime', arguments: actionArguments, resourceClaims: [] },
+                  stopConditions,
+                });
+                return result(buildFacadeResult({ summary: `Workflow schedule ${schedule.scheduleId} is configured without a durable Work.`, data: { schedule } }) as unknown as Record<string, unknown>);
+              }
               const created = createWorkContinuationSchedule(ctx.controllerHome, repository.repoId, {
                 workId,
+                scheduleMode: scheduleModeRaw as 'continuation' | 'browser_watch' | 'browser_keepalive',
                 controllerType: controllerType as ContinuationControllerType,
                 executable: typeof args.executable === 'string' ? args.executable : undefined,
                 launchArgs: Array.isArray(args.launch_args) ? args.launch_args.map(String) : undefined,
@@ -3395,6 +3623,18 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
                 browserSessionId: typeof args.browser_session_id === 'string' ? args.browser_session_id : undefined,
                 conversationUrl: typeof args.conversation_url === 'string' ? args.conversation_url : undefined,
                 continuationPrompt: typeof args.continuation_prompt === 'string' ? args.continuation_prompt : undefined,
+                probeUrl: typeof args.probe_url === 'string' ? args.probe_url : undefined,
+                probeBrowserSessionId: typeof args.probe_browser_session_id === 'string' ? args.probe_browser_session_id : undefined,
+                probeSelector: typeof args.probe_selector === 'string' ? args.probe_selector : undefined,
+                probeMaxChars: typeof args.probe_max_chars === 'number' ? args.probe_max_chars : undefined,
+                probeTimeoutMs: typeof args.probe_timeout_ms === 'number' ? args.probe_timeout_ms : undefined,
+                includeTerms: Array.isArray(args.include_terms) ? args.include_terms.map(String) : undefined,
+                ignorePatterns: Array.isArray(args.ignore_patterns) ? args.ignore_patterns.map(String) : undefined,
+                loginUrlTerms: Array.isArray(args.login_url_terms) ? args.login_url_terms.map(String) : undefined,
+                loginTextTerms: Array.isArray(args.login_text_terms) ? args.login_text_terms.map(String) : undefined,
+                wakeOnFirstObservation: args.wake_on_first_observation === true,
+                wakeOnAuthRequired: args.wake_on_auth_required !== false,
+                authRequiredPrompt: typeof args.auth_required_prompt === 'string' ? args.auth_required_prompt : undefined,
                 scheduleName: typeof args.schedule_name === 'string' ? args.schedule_name : undefined,
                 requestId: typeof args.schedule_request_id === 'string' ? args.schedule_request_id : undefined,
                 triggerType,
@@ -3414,33 +3654,41 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
                 backoffMaxMinutes: typeof args.backoff_max_minutes === 'number' ? args.backoff_max_minutes : undefined,
                 stopConditions: Array.isArray(args.stop_conditions) ? args.stop_conditions.map(String) : undefined,
               });
-              return result(buildFacadeResult({ summary: `Continuation schedule ${created.schedule.scheduleId} is configured for Work ${workId}.`, data: { schedule: created.schedule, work: buildWorkContinuationSnapshot(created.work) } }) as unknown as Record<string, unknown>);
+              return result(buildFacadeResult({ summary: `Work schedule ${created.schedule.scheduleId} is configured for Work ${workId}.`, data: { schedule: created.schedule, work: buildWorkContinuationSnapshot(created.work) } }) as unknown as Record<string, unknown>);
             }
             if (operation === 'schedule_list') {
-              const listed = listWorkContinuationSchedules(ctx.controllerHome, repository.repoId, { workId: workId || undefined, includeOccurrences: args.include_occurrences === true });
-              return result(buildFacadeResult({ summary: `Found ${listed.schedules.length} Work continuation schedule(s).`, data: listed }) as unknown as Record<string, unknown>);
+              const schedules = listSchedules(ctx.controllerHome, repository.repoId)
+                .filter((entry) => !workId || entry.action.arguments?.work_id === workId);
+              const data = args.include_occurrences === true
+                ? { schedules, occurrences: listOccurrences(ctx.controllerHome, repository.repoId, undefined, 100).filter((entry) => schedules.some((schedule) => schedule.scheduleId === entry.scheduleId)) }
+                : { schedules };
+              return result(buildFacadeResult({ summary: `Found ${schedules.length} schedule(s).`, data }) as unknown as Record<string, unknown>);
             }
             if (!scheduleId) throw new Error('SCHEDULE_ID_REQUIRED');
             if (operation === 'schedule_get') {
-              const fetched = getWorkContinuationSchedule(ctx.controllerHome, repository.repoId, scheduleId, args.include_occurrences === true);
-              return result(buildFacadeResult({ summary: `Continuation schedule ${scheduleId}.`, data: fetched }) as unknown as Record<string, unknown>);
+              const schedule = getSchedule(ctx.controllerHome, repository.repoId, scheduleId);
+              const data = args.include_occurrences === true ? { schedule, occurrences: listOccurrences(ctx.controllerHome, repository.repoId, scheduleId, 50) } : { schedule };
+              return result(buildFacadeResult({ summary: `Schedule ${scheduleId}.`, data }) as unknown as Record<string, unknown>);
             }
             if (operation === 'schedule_pause') {
-              const schedule = pauseWorkContinuationSchedule(ctx.controllerHome, repository.repoId, scheduleId, typeof args.reason === 'string' ? args.reason : undefined);
-              return result(buildFacadeResult({ summary: `Continuation schedule ${scheduleId} is paused.`, data: { schedule } }) as unknown as Record<string, unknown>);
+              const schedule = getSchedule(ctx.controllerHome, repository.repoId, scheduleId);
+              const saved = saveSchedule(ctx.controllerHome, { ...schedule, enabled: false, pausedReason: typeof args.reason === 'string' && args.reason.trim() ? args.reason.trim() : 'Paused by ChatGPT.' });
+              return result(buildFacadeResult({ summary: `Schedule ${scheduleId} is paused.`, data: { schedule: saved } }) as unknown as Record<string, unknown>);
             }
             if (operation === 'schedule_resume') {
-              const schedule = resumeWorkContinuationSchedule(ctx.controllerHome, repository.repoId, scheduleId);
-              return result(buildFacadeResult({ summary: `Continuation schedule ${scheduleId} is resumed.`, data: { schedule } }) as unknown as Record<string, unknown>);
+              const schedule = getSchedule(ctx.controllerHome, repository.repoId, scheduleId);
+              const saved = saveSchedule(ctx.controllerHome, { ...schedule, enabled: true, pausedReason: undefined, consecutiveFailures: 0, nextEligibleAt: undefined });
+              return result(buildFacadeResult({ summary: `Schedule ${scheduleId} is resumed.`, data: { schedule: saved } }) as unknown as Record<string, unknown>);
             }
             if (operation === 'schedule_trigger') {
-              const occurrence = await triggerWorkContinuationSchedule(ctx.controllerHome, repository.repoId, scheduleId, {
+              const schedule = getSchedule(ctx.controllerHome, repository.repoId, scheduleId);
+              const occurrence = await evaluateSchedule(ctx.controllerHome, schedule, true, {
                 source: typeof args.event_name === 'string' && args.event_name.trim() ? 'repository-event' : 'manual',
                 eventName: typeof args.event_name === 'string' ? args.event_name : undefined,
                 eventId: typeof args.event_id === 'string' ? args.event_id : undefined,
                 data: args.event_data && typeof args.event_data === 'object' && !Array.isArray(args.event_data) ? args.event_data as Record<string, unknown> : undefined,
               });
-              return result(buildFacadeResult({ summary: occurrence ? `Continuation schedule ${scheduleId} produced ${occurrence.decision}.` : `Continuation schedule ${scheduleId} produced no occurrence.`, data: { occurrence } }) as unknown as Record<string, unknown>);
+              return result(buildFacadeResult({ summary: occurrence ? `Schedule ${scheduleId} produced ${occurrence.decision}.` : `Schedule ${scheduleId} produced no occurrence.`, data: { occurrence } }) as unknown as Record<string, unknown>);
             }
           } catch (error) {
             return result(buildFacadeResult({ status: 'blocked', summary: error instanceof Error ? error.message : 'Schedule operation failed.', data: {} }) as unknown as Record<string, unknown>, true);
@@ -3453,7 +3701,8 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
         if (operation === 'controller_claim') {
           try {
             const workId = String(args.work_id ?? '').trim();
-            if (!getWorkContract(store, workId)) throw new Error(`WORK_NOT_FOUND: ${workId}`);
+            const work = getWorkContract(store, workId);
+            if (!work) throw new Error(`WORK_NOT_FOUND: ${workId}`);
             const identity = authenticatedFacadeControllerIdentity(ctx, args);
             const session = resumeControllerSession(store, {
               workId,
@@ -3464,6 +3713,24 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
               controllerInstanceId: identity.controllerInstanceId,
               leaseMs: typeof args.lease_ms === 'number' ? args.lease_ms : undefined,
             });
+            const permissionSnapshotVersion = currentPermissionSnapshotVersion(ctx.controllerHome, repository.repoId);
+            const executionSession = startExecutionSession(ctx.controllerHome, {
+              sessionId: identity.sessionId,
+              principalId: identity.principalId,
+              controllerInstanceId: identity.controllerInstanceId,
+              permissionSnapshotVersion,
+            });
+            updateExecutionSession(ctx.controllerHome, {
+              sessionId: executionSession.sessionId,
+              principalId: executionSession.principalId,
+              controllerInstanceId: executionSession.controllerInstanceId,
+            }, {
+              activeRepositoryId: repository.repoId,
+              activeCheckoutId: work.checkoutId || repository.activeCheckoutId,
+              activeWorkId: work.workId,
+              permissionSnapshotVersion,
+              lastValidatedAt: new Date().toISOString(),
+            });
             return result(buildFacadeResult({ summary: `Controller ${session.controllerId} claimed ${session.workId}.`, data: { session } }) as unknown as Record<string, unknown>);
           } catch (error) {
             return result(buildFacadeResult({ status: 'blocked', summary: error instanceof Error ? error.message : 'Controller claim failed.', data: {} }) as unknown as Record<string, unknown>, true);
@@ -3478,6 +3745,10 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
               throw new Error(`WORK_CONTROLLER_OWNER_MISMATCH: ${workId} is owned by ${owner.controllerId}`);
             }
             releaseControllerSession(store, workId, identity.controllerId);
+            const executionSession = readExecutionSession(ctx.controllerHome, identity);
+            if (executionSession?.activeWorkId === workId) {
+              updateExecutionSession(ctx.controllerHome, identity, { activeWorkId: undefined, lastValidatedAt: new Date().toISOString() });
+            }
             return result(buildFacadeResult({ summary: 'Controller lease released.', data: {} }) as unknown as Record<string, unknown>);
           } catch (error) {
             return result(buildFacadeResult({ status: 'blocked', summary: error instanceof Error ? error.message : 'Controller release failed.', data: {} }) as unknown as Record<string, unknown>, true);
@@ -3515,15 +3786,81 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
           controllerInstanceId: ctx.controllerInstanceId,
           availableChecks: checks,
           sourceRevision: gitSnapshot(repository.canonicalRoot).head ?? undefined,
+          materializeIsolatedWorkspace: ({ workId, title, baseRef }: { workId: string; title: string; baseRef?: string }) => {
+            const workspace = ensureManagedWorkspace(ctx.controllerHome, repository, { requestId: workId, title, baseRef });
+            if (!workspace.managed || !workspace.checkoutId || !workspace.root) throw new Error('MANAGED_WORKSPACE_NOT_MATERIALIZED');
+            return { checkoutId: workspace.checkoutId, root: workspace.root, baseRevision: workspace.baseRevision, managed: true as const };
+          },
         };
 
         if (operation.startsWith('plan_')) {
           try {
             if (operation === 'plan_create') {
               const rawSteps = Array.isArray(args.plan_steps) ? args.plan_steps : [];
+              const requestedRequirementId = typeof args.requirement_id === 'string' && args.requirement_id.trim() ? args.requirement_id.trim() : undefined;
+              const requestedScopeKey = String(args.scope_key ?? '').trim().toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 160);
+              const activePlans = listPlanContracts({ ...store, status: 'active', limit: 100 });
+              const exactScopeAuthority = requestedScopeKey
+                ? activePlans.find((candidate) => candidate.scopeKey === requestedScopeKey)
+                : undefined;
+              if (exactScopeAuthority) {
+                const facade = buildFacadeResult({
+                  summary: `PLAN_AUTHORITY_REUSED: active Plan ${exactScopeAuthority.planId} already owns scope ${requestedScopeKey}; no duplicate draft was created.`,
+                  data: {
+                    plan: summarizePlanContract(exactScopeAuthority),
+                    executionStarted: false,
+                    planContractCreated: false,
+                    admissionDecision: 'reuse_existing',
+                    resolutionRequired: false,
+                  },
+                  suggestedNextActions: [{ label: 'Read active Plan', tool: 'rh_work', operation: 'plan_get', payload: { plan_id: exactScopeAuthority.planId }, risk: 'readonly', confidence: 'high' }],
+                });
+                return result(facade as unknown as Record<string, unknown>);
+              }
+              const requirementPlans = requestedRequirementId
+                ? activePlans.filter((candidate) => candidate.requirementId === requestedRequirementId)
+                : [];
+              const requestedPlanRelation = args.plan_relation === 'extend' || args.plan_relation === 'parallel'
+                ? args.plan_relation
+                : undefined;
+              const relatedPlanId = typeof args.related_plan_id === 'string' && args.related_plan_id.trim() ? args.related_plan_id.trim() : undefined;
+              const relatedPlan = relatedPlanId
+                ? requirementPlans.find((candidate) => candidate.planId === relatedPlanId)
+                : requirementPlans.length === 1 ? requirementPlans[0] : undefined;
+              if (requirementPlans.length > 0 && !requestedPlanRelation) {
+                const facade = buildFacadeResult({
+                  summary: `PLAN_RELATION_RESOLUTION_REQUIRED: Requirement ${requestedRequirementId} already has ${requirementPlans.length} active Plan slice(s). Decide whether this scope extends one of them or is an intentional parallel slice before creating a draft.`,
+                  data: {
+                    executionStarted: false,
+                    planContractCreated: false,
+                    admissionDecision: 'resolution_required',
+                    resolutionRequired: true,
+                    candidates: requirementPlans.slice(0, 8).map(summarizePlanContract),
+                    allowedPlanRelations: ['extend', 'parallel'],
+                  },
+                  suggestedNextActions: requirementPlans.slice(0, 3).map((candidate) => ({ label: `Read ${candidate.planId}`, tool: 'rh_work', operation: 'plan_get', payload: { plan_id: candidate.planId }, risk: 'readonly' as const, confidence: 'high' as const })),
+                });
+                return result(facade as unknown as Record<string, unknown>);
+              }
+              if (requirementPlans.length > 0 && requestedPlanRelation === 'extend') {
+                if (!relatedPlan) {
+                  const facade = buildFacadeResult({
+                    summary: `PLAN_EXTENSION_TARGET_REQUIRED: select related_plan_id from the active Plan slices for Requirement ${requestedRequirementId}.`,
+                    data: { executionStarted: false, planContractCreated: false, admissionDecision: 'resolution_required', resolutionRequired: true, candidates: requirementPlans.slice(0, 8).map(summarizePlanContract) },
+                  });
+                  return result(facade as unknown as Record<string, unknown>);
+                }
+                const facade = buildFacadeResult({
+                  summary: `PLAN_EXTENSION_REQUIRES_REPLAN: ${relatedPlan.planId} remains the serial authority. Extend/replan and supersede that authority rather than creating a second active Plan draft.`,
+                  data: { plan: summarizePlanContract(relatedPlan), executionStarted: false, planContractCreated: false, admissionDecision: 'extend_existing', resolutionRequired: false },
+                  suggestedNextActions: [{ label: 'Read active Plan', tool: 'rh_work', operation: 'plan_get', payload: { plan_id: relatedPlan.planId }, risk: 'readonly', confidence: 'high' }],
+                });
+                return result(facade as unknown as Record<string, unknown>);
+              }
               const plan = createPlanContract(store, {
                 planId: String(args.plan_id ?? ''),
                 repoId: repository.repoId,
+                requirementId: requestedRequirementId,
                 scopeKey: String(args.scope_key ?? ''),
                 sourceRevision: String(args.source_revision ?? ''),
                 goal: String(args.objective ?? ''),
@@ -3545,8 +3882,8 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
                 })),
               });
               const facade = buildFacadeResult({
-                summary: `PlanContract ${plan.planId} created as draft; no execution was started.`,
-                data: { plan: summarizePlanContract(plan), executionStarted: false },
+                summary: `PlanContract ${plan.planId} created as draft after authority preflight; no execution was started.`,
+                data: { plan: summarizePlanContract(plan), executionStarted: false, planContractCreated: true, admissionDecision: 'create_new' },
                 suggestedNextActions: [{ label: 'Approve reviewed plan', tool: 'rh_work', operation: 'plan_approve', payload: { plan_id: plan.planId }, risk: 'workspace_write', confidence: 'medium' }],
               });
               return result(facade as unknown as Record<string, unknown>);
@@ -3652,7 +3989,43 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
 
         if (operation === 'finalize') {
           const workId = String(args.work_id ?? '').trim();
-          const before = workId ? getWorkContract(store, workId) : undefined;
+          let before = workId ? getWorkContract(store, workId) : undefined;
+          if (before && !before.completionReceipt && args.reconcile_historical_delivery === true) {
+            try {
+              const identity = authenticatedFacadeControllerIdentity(ctx, args);
+              const owner = getControllerSession(store, workId);
+              if (!owner || (owner.principalId?.trim() || owner.controllerId) !== identity.principalId) {
+                throw new Error(`DIRECT_EDIT_WORK_RECONCILIATION_CONTROLLER_CLAIM_REQUIRED: ${workId}`);
+              }
+              const historicalHandle = readWorkHandle(ctx.controllerHome, repository.repoId, workId);
+              if (historicalHandle?.managedWorktree) throw new Error(`DIRECT_EDIT_WORK_RECONCILIATION_MANAGED_CLEANUP_REQUIRED: ${workId}`);
+              const reconciliation = acceptReviewedDirectEditWorkReconciliation({
+                controllerHome: ctx.controllerHome,
+                repoId: repository.repoId,
+                checkoutId: before.checkoutId ?? repository.activeCheckoutId,
+                repoRoot: repository.canonicalRoot,
+                workId,
+                targetBranch: typeof args.target_branch === 'string' && args.target_branch.trim() ? args.target_branch.trim() : repository.defaultBranch || 'main',
+                targetRevision: String(args.reconcile_target_revision ?? ''),
+                comparedPaths: Array.isArray(args.reconcile_compared_paths) ? args.reconcile_compared_paths.map(String) : [],
+                reviewer: identity.principalId,
+                rationale: String(args.reconcile_rationale ?? ''),
+                cleanupOwnershipProof: String(args.reconcile_cleanup_proof ?? ''),
+              });
+              if (historicalHandle && historicalHandle.state !== 'cleaned') {
+                const finalization: WorkHandleState['finalization'] = { validation: 'done', commit: 'done', merge: 'skipped', branchCleanup: 'skipped', worktreeCleanup: 'skipped' };
+                const delivered = historicalHandle.state === 'committed' || historicalHandle.state === 'merged' || historicalHandle.state === 'failed_terminal_cleanup'
+                  ? historicalHandle
+                  : transitionWorkHandle(ctx.controllerHome, historicalHandle, 'committed', { expectedHead: reconciliation.receipt.targetRevision, finalization, failureReason: undefined });
+                transitionWorkHandle(ctx.controllerHome, delivered, 'cleaned', { expectedHead: reconciliation.receipt.targetRevision, finalization, failureReason: undefined });
+              }
+              releaseControllerSession(store, workId, owner.controllerId);
+              before = getWorkContract(store, workId);
+            } catch (error) {
+              const blocked = buildFacadeResult({ status: 'blocked', summary: error instanceof Error ? error.message : 'Historical Work delivery reconciliation failed.', data: { workId, lifecycleClosed: false } });
+              return result(blocked as unknown as Record<string, unknown>, true);
+            }
+          }
           if (before && !before.completionReceipt) {
             try {
               const physical = await finalizeFacadeWorkHandle(ctx, repository, args, 'finalize');
@@ -3708,12 +4081,28 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
         }
 
         const facade = runGoalWorkloop({ ...workloopCtx, sourceRevision: workloopCtx.sourceRevision ?? undefined }, operation as 'start' | 'continue', args);
+        const facadeData = facade.data && typeof facade.data === 'object' ? facade.data as Record<string, unknown> : {};
+        const facadeWorkId = contextText(contextRecord(facadeData.work).workId, 200);
+        if (facade.status === 'ok' && facadeWorkId) {
+          try {
+            const handle = ensureFacadeWorkHandle(ctx, repository, facadeWorkId, args);
+            if (handle) facadeData.executionHandle = { workId: handle.workId, checkoutId: handle.checkoutId, managedWorktree: handle.managedWorktree, state: handle.state };
+            if (facadeData.workContractCreated === true) {
+              const owner = claimNewFacadeWork(ctx, repository, facadeWorkId, args);
+              facadeData.controllerSession = owner;
+              facadeData.ownershipClaimed = true;
+            }
+          } catch (error) {
+            const blocked = buildFacadeResult({ status: 'blocked', summary: `WORK_HANDLE_MATERIALIZATION_FAILED: ${error instanceof Error ? error.message : String(error)}`, data: { ...facadeData, workId: facadeWorkId, executionStarted: false } });
+            return result(blocked as unknown as Record<string, unknown>, true);
+          }
+        }
         const response = resumedControllerSession
           ? {
               ...facade,
               summary: `Controller ownership resumed for ${resumedControllerSession.workId}. ${facade.summary}`,
               data: {
-                ...(facade.data && typeof facade.data === 'object' ? facade.data : {}),
+                ...facadeData,
                 ownershipResumed: true,
                 controllerSession: resumedControllerSession,
               },
@@ -3781,6 +4170,7 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
         const accepted = acceptSubmittedWorkContract(ctx.controllerHome, {
           requestId,
           repoId: repository.repoId,
+          parentWorkId: typeof args.parent_work_id === 'string' && args.parent_work_id.trim() ? args.parent_work_id.trim() : undefined,
           semanticKey,
           operation: {
             name: operation,
@@ -5254,9 +5644,6 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
           case 'recovery.workspace_auth_login_prepare':
             payload = { skipped: true, nextTool: 'workspace_auth_login_prepare', reason: 'Auth login is a non-secret handoff and should be prepared through the dedicated typed tool.' };
             break;
-          case 'recovery.browser_domain_access_preview':
-            payload = { skipped: true, nextTool: 'web_domain_access_preview', reason: 'Browser access must be granted by domain key before snapshot or interaction.' };
-            break;
           case 'recovery.external_filesystem_grant_preview':
             payload = { skipped: true, nextTool: 'external_filesystem_grant_preview', reason: 'External filesystem access must be converted into a named read-only target first.' };
             break;
@@ -5489,6 +5876,7 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
           pluginId,
           actionId,
           requestId,
+          workId: typeof args.work_id === 'string' && args.work_id.trim() ? args.work_id.trim() : undefined,
           args: actionArguments,
           timeoutMs: typeof args.timeout_ms === 'number' ? args.timeout_ms : undefined,
           signal: ctx.signal,
@@ -5500,7 +5888,7 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
         const action = manifest.actions.find((entry) => entry.actionId === actionId);
         if (action && isDirectPluginReadAction(action)) {
           const direct = await executeAssistantPluginReadDirect(ctx.controllerHome, repository, request);
-          return result({
+          const value = {
             accepted: true,
             direct: true,
             durable: false,
@@ -5521,10 +5909,11 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
               },
             },
             next: 'Continue with the returned bounded result; use rh_context capability detail only when the typed action schema/policy is needed.',
-          });
+          };
+          return resultWithPluginArtifactImages(value, ctx.controllerHome, repository.repoId, direct.result);
         }
         const submitted = await submitAssistantPluginAction(ctx.controllerHome, repository, request);
-        return result({
+        const value = {
           accepted: true,
           deduplicated: submitted.deduplicated,
           direct: true,
@@ -5539,6 +5928,7 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
           scope: repository.repoId === '__controller__' ? 'controller' : 'repository',
           receiptId: submitted.receipt.receiptId,
           requestId: submitted.receipt.requestId,
+          ...(submitted.receipt.workId ? { workId: submitted.receipt.workId } : {}),
           result: submitted.result,
           detail: {
             tool: 'rh_context',
@@ -5549,7 +5939,8 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
             },
           },
           next: 'Continue with the returned bounded plugin result; use rh_context capability detail only when the typed action schema/policy is needed.',
-        });
+        };
+        return resultWithPluginArtifactImages(value, ctx.controllerHome, repository.repoId, submitted.result);
       }
       case 'toolchain_plugin_summary': {
         const pluginId = String(args.plugin_id ?? '').trim();
@@ -5559,97 +5950,10 @@ export async function callRuntimeTool(ctx: MultiRepositoryMcpToolContext, name:
           plugin: summarizePluginForLowInterception(manifest),
           nonOpaque: true,
           next: manifest.pluginId === 'browser'
-            ? 'Use web_targets_list, web_domain_access_preview, or web_target_snapshot instead of raw browser action names.'
+            ? 'Use rh_context for browser capability schemas and plugin_action_execute for typed HTTP(S) browser actions.'
             : undefined,
         });
       }
-      case 'web_targets_list': {
-        const repository = selected(ctx, args);
-        const manifest = getAssistantPluginManifest(ctx.controllerHome, repository, 'browser');
-        return result({
-          pluginId: 'browser',
-          enabled: manifest.enabled,
-          healthState: manifest.health.state,
-          ready: manifest.health.ready,
-          targets: listWebTargets(repository.canonicalRoot, manifest),
-          safety: {
-            arbitraryUrlAccepted: false,
-            returnsRawConfig: false,
-            nextTool: 'web_target_snapshot',
-          },
-        });
-      }
-      case 'web_target_snapshot': {
-        const repository = selected(ctx, args);
-        const manifest = getAssistantPluginManifest(ctx.controllerHome, repository, 'browser');
-        const url = resolveWebTargetUrl(repository.canonicalRoot, String(args.target_key ?? '').trim(), args.path, args.query, manifest);
-        const capture = args.capture === 'screenshot' ? 'screenshot' : args.capture === 'text' ? 'text' : 'title';
-        const actionId = capture === 'screenshot' ? 'screenshot' : 'open_page';
-        const actionArguments: Record<string, unknown> = {
-          url,
-          wait_until: typeof args.wait_until === 'string' ? args.wait_until : 'domcontentloaded',
-          timeout_ms: typeof args.timeout_ms === 'number' ? args.timeout_ms : undefined,
-          ...(capture === 'text' ? { extract_text: true, max_chars: typeof args.max_chars === 'number' ? args.max_chars : 4000 } : {}),
-          ...(capture === 'screenshot' ? { full_page: args.full_page === true } : {}),
-        };
-        const requestId = String(args.request_id ?? '').trim();
-        if (!requestId) throw new Error('REQUEST_ID_REQUIRED: web_target_snapshot requires request_id');
-        const submitted = await submitAssistantPluginAction(ctx.controllerHome, repository, {
-          pluginId: 'browser',
-          actionId,
-          requestId,
-          args: actionArguments,
-          timeoutMs: typeof args.timeout_ms === 'number' ? args.timeout_ms : undefined,
-          origin: { surface: 'mcp', actor: 'web_target_snapshot', correlationId: requestId },
-        });
-        return result({
-          accepted: true,
-          deduplicated: submitted.deduplicated,
-          webTarget: {
-            targetKey: String(args.target_key ?? '').trim(),
-            capture,
-            path: typeof args.path === 'string' ? args.path : '/',
-            arbitraryUrlAccepted: false,
-          },
-          job: summarizeWork(submitted.job, repository.canonicalRoot),
-          next: `Call work_status_digest with work_ref ${submitted.job.jobId}.`,
-        });
-      }
-      case 'web_domain_access_preview': {
-        const repository = selected(ctx, args);
-        const manifest = getAssistantPluginManifest(ctx.controllerHome, repository, 'browser');
-        return result({
-          preview: previewBrowserDomainAccess(repository.canonicalRoot, args.domain, args.reason, manifest),
-          next: 'After human review, call web_domain_access_apply with confirm_authorization=true.',
-        });
-      }
-      case 'web_domain_access_apply': {
-        const repository = selected(ctx, args);
-        if (args.confirm_authorization !== true) throw new Error('CONFIRM_AUTHORIZATION_REQUIRED: web_domain_access_apply requires confirm_authorization=true');
-        const manifest = getAssistantPluginManifest(ctx.controllerHome, repository, 'browser');
-        const preview = previewBrowserDomainAccess(repository.canonicalRoot, args.domain, args.reason, manifest);
-        const providedTicket = typeof args.preview_ticket_id === 'string' ? args.preview_ticket_id.trim() : '';
-        if (providedTicket && providedTicket !== preview.ticketId) throw new Error('DOMAIN_ACCESS_TICKET_MISMATCH');
-        const requestId = String(args.request_id ?? '').trim();
-        if (!requestId) throw new Error('REQUEST_ID_REQUIRED: web_domain_access_apply requires request_id');
-        const allowedDomains = mergeAllowedDomains(repository.canonicalRoot, args.domain, manifest);
-        const submitted = await submitAssistantPluginAction(ctx.controllerHome, repository, {
-          pluginId: 'browser',
-          actionId: 'configure',
-          requestId,
-          args: { enabled: true, allowed_domains: allowedDomains },
-          confirmAuthorization: true,
-          origin: { surface: 'mcp', actor: 'web_domain_access_apply', correlationId: requestId },
-        });
-        return result({
-          accepted: true,
-          deduplicated: submitted.deduplicated,
-          preview,
-          allowedDomainCount: allowedDomains.length,
-          job: summarizeWork(submitted.job, repository.canonicalRoot),
-          next: `Call work_status_digest with work_ref ${submitted.job.jobId}.`,
-        });
-      }
       case 'work_result_summary': {
         const repository = selected(ctx, args);
         const jobId = String(args.job_id ?? '').trim();