@moretea-labs/forge 1.8.0 → 1.8.2

package/adapters/mcp/tool-mapping/legacy-tool-service.ts

@@ -1,169 +1,35 @@
 import type { CallToolResult, McpToolDefinition } from '../../../packages/protocols/mcp/tool-contract';
 export type { CallToolResult, McpToolDefinition } from '../../../packages/protocols/mcp/tool-contract';
 import { createHash } from "crypto";
-import {
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  statSync,
-  writeFileSync,
-  appendFileSync,
-} from "fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, appendFileSync } from "fs";
 import { basename, dirname, join } from "path";
-import { runProcess } from "../../../src/effects/process-runner";
-import {
-  beginEditSession,
-  applyEditOperations,
-  createEditSavepoint,
-  EditSessionPatchError,
-  finalizeEditSession,
-  getEditSession,
-  getEditSessionDiff,
-  listEditSessions,
-  PREFERRED_EDIT_PATCH_BATCH_OPERATIONS,
-  rollbackEditSession,
-  verifyEditSession,
-} from "../../../src/cli/editing/edit-session";
-import {
-  EDIT_OPERATION_INPUT_SCHEMA,
-  normalizeEditOperations,
-} from "../../../src/cli/editing/edit-operation-contract";
-import {
-  cancelAgentJob,
-  getAgentJob,
-  getAgentJobEvents,
-  getAgentJobLog,
-  listAgentJobs,
-} from "../../../src/cli/agent-jobs/job-manager";
-import {
-  classifyGitHubCopilotPreflight,
-  classifyLocalExecutorHealth,
-  executorHealthCode,
-  isExecutorHealthError,
-  type ExecutorHealth,
-} from "../../../src/cli/agent-jobs/executor-health";
-import { integrateAgentJob, taskRunDiff } from "../../../src/cli/agent-jobs/integration";
-import {
-  appendTask,
-  archiveIssue,
-  createIssue,
-  getIssue,
-  getIssueEffectiveView,
-  getIssueReadView,
-  inspectIssueReadiness,
-  inspectTaskReadiness,
-  acceptVerifiedTask,
-  listIssueEffectiveViews,
-  listIssues,
-  projectIssueEffectiveView,
-  planIssue,
-  projectBoard,
-  recordTaskVerification,
-  restoreIssue,
-  setTaskDependencies,
-  splitTask,
-  supersedeTask,
-  updateIssue,
-  updateTask,
-} from "../../../src/cli/controller/issue-store";
-import { applyMigratedIssueDecision } from '../../../src/cli/controller/migrated-issue-decision';
-import { legacyIssueAuthorityRetired } from '../../../src/cli/controller/legacy-issue-cutover';
-import {
-  listControllerChecks,
-} from "../../../src/cli/controller/check-runner";
-import { normalizeCheckIds } from '../../../src/runtime/control-plane/facade/check-normalization';
+import { beginEditSession, applyEditOperations, createEditSavepoint, EditSessionPatchError, finalizeEditSession, getEditSession, getEditSessionDiff, listEditSessions, PREFERRED_EDIT_PATCH_BATCH_OPERATIONS, rollbackEditSession } from "../../../src/cli/editing/edit-session";
+import { EDIT_OPERATION_INPUT_SCHEMA, normalizeEditOperations } from "../../../src/cli/editing/edit-operation-contract";
+import { listAgentJobs } from "../../../src/cli/agent-jobs/job-manager";
+import { listControllerChecks } from "../../../src/cli/controller/check-runner";
 import { buildExecutionDiagnostics, buildRequirementBoard } from '../../../src/runtime/control-plane/facade/requirement-board';
-import { acceptVerifiedTaskFromControllerWork } from '../../../src/runtime/control-plane/execution/work-task-receipt';
 import { getWorkContract } from '../../../packages/kernel/work/api';
 import { admitDirectEditWorkContract } from '../../../src/runtime/control-plane/facade/repository-work-admission';
-import { decideRoute } from '../../../src/runtime/control-plane/routing/route-policy';
 import { listCapabilityDescriptors, summarizeCapabilityGroups } from '../../../src/runtime/control-plane/facade/capability-registry';
-import {
-  getControllerTimeline,
-  getProjectProgress,
-  getTaskProgressDetail,
-  getTaskProgressReadView,
-} from "../../../src/cli/controller/progress";
-import { exportControllerWorklog, parseWorklogCategory } from "../../../src/cli/controller/worklog";
-import { inspectProjectGovernance, reconcileProjectGovernance } from "../../../src/cli/controller/governance";
-import { assessWorkMode, parseExplicitTaskMode } from "../../../src/cli/controller/work-mode";
-import { taskExecutionPolicy } from "../../../src/cli/controller/execution-policy";
-import { finishEditSession, finishTaskRun } from "../../../src/cli/controller/completion-orchestrator";
-import { buildControllerTaskLedgerProjection } from "../../../src/cli/controller/task-ledger";
-import { buildControllerContextPack } from "../../../src/cli/controller/context-pack";
-import { loadControllerProjectState, saveControllerProjectState } from "../../../src/cli/controller/project-state";
-import {
-  FORGE_MCP_SCHEMA_VERSION,
-  FORGE_TOOL_SURFACE,
-  FORGE_VERSION,
-  forgeToolSurfaceFingerprint,
-  MIN_AGENT_TIMEOUT_MS,
-  formatDurationMs,
-  normalizeAgentTimeoutMs,
-} from "../../../src/cli/controller/runtime-config";
-import { DEFAULT_CONTROLLER_TOOL_NAMES, PREFERRED_FACADE_TOOL_NAMES } from "../toolset-names";
+import { exportControllerWorklog, listControllerWorklogEvents, parseWorklogCategory } from "../../../src/cli/controller/worklog";
+import { FORGE_MCP_SCHEMA_VERSION, FORGE_TOOL_SURFACE, FORGE_VERSION, forgeToolSurfaceFingerprint, MIN_AGENT_TIMEOUT_MS, formatDurationMs, normalizeAgentTimeoutMs } from "../../../src/cli/controller/runtime-config";
+import { PREFERRED_FACADE_TOOL_NAMES } from "../toolset-names";
 import { buildLocalConnectorStatusForRepo } from "../../../src/cli/local-bridge/connector-freshness";
-import type {
-  ControllerAgent,
-  ControllerTask,
-  IssueKind,
-  IssueStatus,
-  TaskDraft,
-  TaskRisk,
-  TaskCommandEvidence,
-  TaskStatus,
-  TaskVerification,
-} from "../../../src/cli/controller/types";
-import {
-  gitDiff,
-  gitSnapshot,
-  searchRepository,
-} from "../../../src/cli/repository/inspector";
-import {
-  closeGitHubIssue,
-  getGitHubStatus,
-  publishIssueToGitHub,
-  refreshGitHubIssue,
-} from "../../../src/cli/github/github";
-import {
-  getGitHubPluginStatus,
-  saveGitHubPluginConfig,
-} from "../../../src/cli/github/plugin";
-import {
-  getLocalBridgeJobEvents,
-  getLocalBridgeJobSnapshot,
-  listLocalBridgeJobs,
-  readLocalBridgeJobOutput,
-  reconcileLocalBridgeJobs,
-} from "../../../src/cli/local-bridge/job-store";
+import { gitDiff, gitSnapshot, searchRepository } from "../../../src/cli/repository/inspector";
+import { getGitHubStatus } from "../../../src/cli/github/github";
+import { getGitHubPluginStatus, saveGitHubPluginConfig } from "../../../src/cli/github/plugin";
+import { getLocalBridgeJobEvents, getLocalBridgeJobSnapshot, listLocalBridgeJobs, readLocalBridgeJobOutput, reconcileLocalBridgeJobs } from "../../../src/cli/local-bridge/job-store";
 import { runHelper } from "../../../src/cli/runtime/helper-runner";
-import {
-  listSessions,
-  openSession,
-  readSession,
-  runBrowserConsult,
-  runBrowserFollowup,
-} from "../../../src/cli/chatgpt-browser/engine";
-import type {
-  BrowserProviderName,
-  NativeBrowserChannel,
-  ThinkingLevel,
-} from "../../../src/cli/chatgpt-browser/types";
+import { listSessions, openSession, readSession, runBrowserConsult, runBrowserFollowup } from "../../../src/cli/chatgpt-browser/engine";
+import type { BrowserProviderName, NativeBrowserChannel, ThinkingLevel } from "../../../src/cli/chatgpt-browser/types";
 import { hashMcpInput, tryWriteMcpAuditEntry } from "../audit";
-import { loadMcpRuntimeState } from "../auth";
 import { resolveLocalBridgeSurface, summarizeRecentJobs } from "../../../src/runtime/shared/local-bridge-surface";
 import { resolveRepoPreferredControllerHome } from "../../../src/cli/repositories/controller-home";
 import { resolveRepositoryCheckStorage } from '../../../src/runtime/execution/process-runtime/check-storage';
 import { resolveRepositorySelection } from '../../../src/cli/repositories/registry';
 import { ensureRepositoryRuntimeStorageBinding } from '../../../src/cli/repositories/runtime-storage';
-import { executionIdentityForRepository } from '../../../src/runtime/control-plane/execution/execution-identity';
-import { runPersistedCheckViaProcessRuntime } from '../runtime-gateway/persisted-check-process';
-import { getProcessRecord } from '../../../src/runtime/execution/process-runtime/store';
-import { processCheckCompletionReceipt } from '../../../src/runtime/execution/process-runtime/check-receipt';
-import { normalizeMcpRelativePath, resolveMcpPath } from "../paths";
+import { resolveMcpPath } from "../paths";
 import { currentGitBranch, isForgeAdopted } from "../repo";
-import { repositoryToolNames } from "./repository-tools";
 import { redactMcpText } from "../redaction";
 import type { McpPolicy } from "../types";
 
@@ -179,10 +45,14 @@ export interface McpToolContext {
   principalId?: string;
   /** Authenticated transport controller/provider type. */
   controllerType?: 'chatgpt' | 'codex' | 'claude' | 'grok' | 'human';
+  /** Host-provided ChatGPT session correlation. Never authorization and never a canonical conversation URL. */
+  hostConversationSessionId?: string;
   controllerInstanceId?: string;
   /** Bound repository identity for session cache keys. */
   repoId?: string;
   checkoutId?: string;
+  /** Canonical tools/list projection supplied by the MCP registry; never authored by the client. */
+  publishedToolNames?: readonly string[];
   /** Request-scoped MCP cancellation; never persisted or reused across calls. */
   signal?: AbortSignal;
 }
@@ -219,30 +89,6 @@ function errorResult(
   return result;
 }
 
-function dispatchErrorResult(
-  code: string,
-  message: string,
-  options: {
-    requestId?: string;
-    retryable?: boolean;
-    details?: unknown;
-  } = {},
-): CallToolResult {
-  const payload = {
-    accepted: false,
-    code,
-    message: redactMcpText(message).text,
-    retryable: options.retryable === true,
-    requestId: options.requestId,
-    details: options.details,
-  };
-  const result = textResult({
-    error: payload,
-    ...payload,
-  });
-  result.isError = true;
-  return result;
-}
 
 function audit(
   ctx: McpToolContext,
@@ -324,433 +170,25 @@ function knownRunPathReplacements(
     .map(([from, to]) => ({ from, to }));
 }
 
-function redactRunText(
-  text: string,
-  repoRoot: string,
-  run: Partial<{
-    executionRoot: string;
-    worktree: string;
-    worktreePath: string;
-  }>,
-  maxChars: number,
-): { text: string; truncated: boolean; redactions: Array<{ type: string; count: number }> } {
-  let scrubbed = text;
-  for (const entry of knownRunPathReplacements(repoRoot, run)) {
-    scrubbed = scrubbed.split(entry.from).join(entry.to);
-  }
-  scrubbed = scrubbed
-    .replace(/\/(?:private\/)?tmp\/[^\s"']+/g, "<abs-path>")
-    .replace(/\/(?:private\/)?var\/folders\/[^\s"']+/g, "<abs-path>")
-    .replace(/\/Users\/[^\s"']+/g, "<abs-path>")
-    .replace(/[A-Za-z]:\\[^\s"']+/g, "<abs-path>");
-  const redacted = redactMcpText(scrubbed);
-  if (redacted.text.length <= maxChars) {
-    return { text: redacted.text, truncated: false, redactions: redacted.redactions };
-  }
-  return {
-    text: redacted.text.slice(-maxChars),
-    truncated: true,
-    redactions: redacted.redactions,
-  };
-}
 
-function maybeTail(
-  value: string | undefined,
-  repoRoot: string,
-  run: Partial<{
-    executionRoot: string;
-    worktree: string;
-    worktreePath: string;
-  }>,
-  maxChars: number,
-): { text: string; truncated: boolean; redactions: Array<{ type: string; count: number }> } | undefined {
-  if (!value) return undefined;
-  return redactRunText(value, repoRoot, run, maxChars);
-}
 
-function summarizeAgentRun(
-  repoRoot: string,
-  run: Record<string, unknown>,
-  options: {
-    includePaths?: boolean;
-    includeOutput?: boolean;
-    tailChars?: number;
-  } = {},
-): Record<string, unknown> {
-  const tailChars = Math.min(Math.max(options.tailChars ?? 4096, 256), 16 * 1024);
-  const base: Record<string, unknown> = {
-    runId: run.runId,
-    issueId: run.issueId,
-    taskId: run.taskId,
-    agent: run.agent,
-    provider: run.provider,
-    executionMode: run.executionMode,
-    executionClass: run.executionClass,
-    allowedPaths: run.allowedPaths,
-    status: run.status,
-    closureState: run.closureState,
-    closureUpdatedAt: run.closureUpdatedAt,
-    preservationReason: run.preservationReason,
-    preservationDetails: typeof run.preservationDetails === "string"
-      ? redactRunText(run.preservationDetails, repoRoot, {
-        executionRoot: typeof run.executionRoot === "string" ? run.executionRoot : undefined,
-        worktree: typeof run.worktree === "string" ? run.worktree : undefined,
-        worktreePath: typeof run.worktreePath === "string" ? run.worktreePath : undefined,
-      }, 1000).text
-      : run.preservationDetails,
-    branch: run.branch,
-    baseRevision: run.baseRevision,
-    changedFiles: Array.isArray(run.changedFiles) ? run.changedFiles.slice(0, 100) : run.changedFiles,
-    exitCode: run.exitCode,
-    error: typeof run.error === "string"
-      ? redactRunText(run.error, repoRoot, {
-        executionRoot: typeof run.executionRoot === "string" ? run.executionRoot : undefined,
-        worktree: typeof run.worktree === "string" ? run.worktree : undefined,
-        worktreePath: typeof run.worktreePath === "string" ? run.worktreePath : undefined,
-      }, 1000).text
-      : run.error,
-    executorHealth: run.executorHealth,
-    timeoutMs: run.timeoutMs,
-    deadlineAt: run.deadlineAt,
-    startupDeadlineAt: run.startupDeadlineAt,
-    lastHeartbeatAt: run.lastHeartbeatAt,
-    progress: run.progress,
-    autoIntegrate: run.autoIntegrate,
-    autoIntegrationError: typeof run.autoIntegrationError === "string"
-      ? redactRunText(run.autoIntegrationError, repoRoot, {
-        executionRoot: typeof run.executionRoot === "string" ? run.executionRoot : undefined,
-        worktree: typeof run.worktree === "string" ? run.worktree : undefined,
-        worktreePath: typeof run.worktreePath === "string" ? run.worktreePath : undefined,
-      }, 1000).text
-      : run.autoIntegrationError,
-    worktreeCleanedAt: run.worktreeCleanedAt,
-    cleanupBranchDeletedAt: run.cleanupBranchDeletedAt,
-    diffArtifactPath: run.diffArtifactPath,
-    terminationReason: run.terminationReason,
-    createdAt: run.createdAt,
-    startedAt: run.startedAt,
-    finishedAt: run.finishedAt,
-    integratedSessionId: run.integratedSessionId,
-    integratedAt: run.integratedAt,
-    timing: run.timing,
-    github: run.github && typeof run.github === "object"
-      ? {
-        owner: (run.github as Record<string, unknown>).owner,
-        repo: (run.github as Record<string, unknown>).repo,
-        taskId: (run.github as Record<string, unknown>).taskId,
-        state: (run.github as Record<string, unknown>).state,
-        url: (run.github as Record<string, unknown>).url,
-        pullRequestUrl: (run.github as Record<string, unknown>).pullRequestUrl,
-        baseRef: (run.github as Record<string, unknown>).baseRef,
-        model: (run.github as Record<string, unknown>).model,
-        createPullRequest: (run.github as Record<string, unknown>).createPullRequest,
-      }
-      : run.github,
-    detail: {
-      pathsIncluded: options.includePaths === true,
-      outputIncluded: options.includeOutput !== false,
-      next: {
-        log: "Call get_task_run_log for a larger bounded tail.",
-        diff: "Call get_task_diff to inspect Git changes from an isolated worktree.",
-      },
-    },
-  };
-  if (options.includeOutput !== false) {
-    const stdout = maybeTail(
-      typeof run.stdoutTail === "string" ? run.stdoutTail : undefined,
-      repoRoot,
-      {
-        executionRoot: typeof run.executionRoot === "string" ? run.executionRoot : undefined,
-        worktree: typeof run.worktree === "string" ? run.worktree : undefined,
-        worktreePath: typeof run.worktreePath === "string" ? run.worktreePath : undefined,
-      },
-      tailChars,
-    );
-    const stderr = maybeTail(
-      typeof run.stderrTail === "string" ? run.stderrTail : undefined,
-      repoRoot,
-      {
-        executionRoot: typeof run.executionRoot === "string" ? run.executionRoot : undefined,
-        worktree: typeof run.worktree === "string" ? run.worktree : undefined,
-        worktreePath: typeof run.worktreePath === "string" ? run.worktreePath : undefined,
-      },
-      tailChars,
-    );
-    if (stdout) {
-      base.stdoutTail = stdout.text;
-      base.stdoutTailTruncated = stdout.truncated;
-    }
-    if (stderr) {
-      base.stderrTail = stderr.text;
-      base.stderrTailTruncated = stderr.truncated;
-    }
-    const redactions = [...(stdout?.redactions ?? []), ...(stderr?.redactions ?? [])];
-    if (redactions.length > 0) base.redactions = redactions;
-  }
-  if (options.includePaths === true) {
-    Object.assign(base, {
-      repoRoot: run.repoRoot,
-      executionRoot: run.executionRoot,
-      worktree: run.worktree,
-      worktreePath: run.worktreePath,
-      promptPath: run.promptPath,
-      stdoutPath: run.stdoutPath,
-      stderrPath: run.stderrPath,
-      resultPath: run.resultPath,
-      eventsPath: run.eventsPath,
-      controllerPid: run.controllerPid,
-      controllerEpoch: run.controllerEpoch,
-      controllerEpochPath: run.controllerEpochPath,
-      launchPid: run.launchPid,
-      workerPid: run.workerPid,
-      agentPid: run.agentPid,
-    });
-  }
-  return base;
-}
 
-function summarizeRunList(
-  repoRoot: string,
-  runs: Array<Record<string, unknown>>,
-  includePaths = false,
-): Array<Record<string, unknown>> {
-  return runs.map((run) => summarizeAgentRun(repoRoot, run, { includePaths, includeOutput: false }));
-}
 
-function compactDispatchRun(run: Record<string, unknown>): Record<string, unknown> {
-  const runId = typeof run.runId === "string" ? run.runId : String(run.runId ?? "");
-  const detail: Record<string, unknown> = runId
-    ? {
-      get_task_run: { run_id: runId },
-      get_task_run_log: { run_id: runId },
-      get_task_run_events: { run_id: runId },
-      get_task_diff: { run_id: runId },
-    }
-    : {};
-  return {
-    runId: run.runId,
-    issueId: run.issueId,
-    taskId: run.taskId,
-    status: run.status,
-    agent: run.agent,
-    provider: run.provider,
-    executionMode: run.executionMode,
-    executionClass: run.executionClass,
-    timeoutMs: run.timeoutMs,
-    startedAt: run.startedAt,
-    deadlineAt: run.deadlineAt,
-    finishedAt: run.finishedAt,
-    integratedSessionId: run.integratedSessionId,
-    autoIntegrationError: run.autoIntegrationError,
-    worktreeCleanedAt: run.worktreeCleanedAt,
-    accepted: run.accepted,
-    reused: run.reused,
-    github: run.github,
-    error: run.error,
-    detail,
-  };
-}
 
-function compactTaskView(task: Record<string, unknown>): Record<string, unknown> {
-  return {
-    id: task.id,
-    title: task.title,
-    status: task.status,
-    effectiveStatus: task.effectiveStatus,
-    declaredStatus: task.declaredStatus,
-    latestRunId: task.latestRunId,
-    latestRunStatus: task.latestRunStatus,
-    activeRunId: task.activeRunId,
-    activeRunStatus: task.activeRunStatus,
-    verificationStatus: task.verificationStatus,
-    dispatchable: task.dispatchable,
-    retryable: task.retryable,
-    requiresExplicitRetry: task.requiresExplicitRetry,
-  };
-}
 
-function compactIssueView(issue: Record<string, unknown>): Record<string, unknown> {
-  const id = typeof issue.id === "string" ? issue.id : String(issue.id ?? "");
-  const tasks = Array.isArray(issue.tasks) ? issue.tasks as Array<Record<string, unknown>> : [];
-  return {
-    id: issue.id,
-    title: issue.title,
-    status: issue.status,
-    lifecycleStatus: issue.lifecycleStatus,
-    github: issue.github,
-    taskCount: tasks.length,
-    tasks: tasks.map((task) => compactTaskView(task)),
-    detail: id ? { get_issue: { issue_id: id } } : {},
-  };
-}
 
 const PROJECT_BOARD_RECENT_ISSUE_LIMIT = 5;
 const PROJECT_BOARD_TASK_LIMIT = 8;
 
-function compactProjectBoardText(value: unknown, maxChars = 96): unknown {
-  if (typeof value !== "string" || value.length <= maxChars) return value;
-  return `${value.slice(0, Math.max(0, maxChars - 1))}…`;
-}
 
-function compactProjectBoardTask(
-  task: Record<string, unknown>,
-  options: { includeLifecycle?: boolean } = {},
-): Record<string, unknown> {
-  const compact: Record<string, unknown> = {
-    issueId: task.issueId,
-    taskId: task.taskId,
-    id: task.id,
-    title: compactProjectBoardText(task.title),
-    agent: task.agent,
-    effectiveStatus: task.effectiveStatus,
-    executionClass: task.executionClass,
-    approval: task.approval,
-  };
-  if (options.includeLifecycle) {
-    Object.assign(compact, {
-      status: task.status,
-      declaredStatus: task.declaredStatus,
-      statusReason: task.statusReason,
-      verificationStatus: task.verificationStatus,
-      dispatchable: task.dispatchable,
-      queueable: task.queueable,
-      retryable: task.retryable,
-      requiresExplicitRetry: task.requiresExplicitRetry,
-    });
-  }
-  return compact;
-}
 
-function compactProjectBoardIssue(
-  issue: Record<string, unknown>,
-  options: { includeTasks?: boolean } = {},
-): Record<string, unknown> {
-  const tasks = Array.isArray(issue.tasks) ? issue.tasks as Array<Record<string, unknown>> : [];
-  const taskCounts = tasks.reduce<Record<string, number>>((counts, task) => {
-    const status = typeof task.effectiveStatus === "string" ? task.effectiveStatus : "unknown";
-    counts[status] = (counts[status] ?? 0) + 1;
-    return counts;
-  }, {});
-  const compact: Record<string, unknown> = {
-    id: issue.id,
-    title: compactProjectBoardText(issue.title),
-    kind: issue.kind,
-    status: issue.status,
-    lifecycleStatus: issue.lifecycleStatus,
-    updatedAt: issue.updatedAt,
-    isCurrent: issue.isCurrent === true,
-    taskCount: tasks.length,
-    taskCounts,
-    readyTaskCount: tasks.filter((task) => task.dispatchable === true).length,
-    queueableTaskCount: tasks.filter((task) => task.queueable === true).length,
-  };
-  if (options.includeTasks) {
-    compact.tasks = tasks
-      .slice(0, PROJECT_BOARD_TASK_LIMIT)
-      .map((task) => compactProjectBoardTask(task, { includeLifecycle: true }));
-    compact.taskTruncatedCount = Math.max(0, tasks.length - PROJECT_BOARD_TASK_LIMIT);
-  }
-  return compact;
-}
 
-function summarizeProjectBoard(board: Record<string, unknown>): Record<string, unknown> {
-  const issues = Array.isArray(board.issues) ? board.issues as Array<Record<string, unknown>> : [];
-  const readyTasks = Array.isArray(board.readyTasks) ? board.readyTasks as Array<Record<string, unknown>> : [];
-  const queueableTasks = Array.isArray(board.queueableTasks) ? board.queueableTasks as Array<Record<string, unknown>> : [];
-  const currentIssue = issues.find((issue) => issue.isCurrent === true);
-  const recentIssueCandidates = currentIssue
-    ? issues.filter((issue) => issue !== currentIssue)
-    : issues;
-  const recentIssues = recentIssueCandidates.slice(0, PROJECT_BOARD_RECENT_ISSUE_LIMIT);
-  return {
-    detailLevel: "summary",
-    issueCount: issues.length,
-    archivedIssueCount: board.archivedIssueCount,
-    counts: board.counts,
-    declaredCounts: board.declaredCounts,
-    archivedCounts: board.archivedCounts,
-    currentIssueId: board.currentIssueId,
-    currentIssue: currentIssue ? compactProjectBoardIssue(currentIssue, { includeTasks: true }) : undefined,
-    recentIssues: recentIssues.map((issue) => compactProjectBoardIssue(issue)),
-    recentIssueTruncatedCount: Math.max(0, recentIssueCandidates.length - recentIssues.length),
-    readyTaskCount: readyTasks.length,
-    readyTasks: readyTasks.slice(0, PROJECT_BOARD_TASK_LIMIT).map((task) => compactProjectBoardTask(task)),
-    readyTaskTruncatedCount: Math.max(0, readyTasks.length - PROJECT_BOARD_TASK_LIMIT),
-    queueableTaskCount: queueableTasks.length,
-    queueableTasks: queueableTasks.slice(0, PROJECT_BOARD_TASK_LIMIT).map((task) => compactProjectBoardTask(task)),
-    queueableTaskTruncatedCount: Math.max(0, queueableTasks.length - PROJECT_BOARD_TASK_LIMIT),
-    detailPointer: {
-      tool: "get_project_board",
-      arguments: { detail_level: "detail" },
-    },
-  };
-}
 
 const UPDATE_TASK_SUMMARY_TASK_LIMIT = 12;
 
-function compactUpdatedTaskView(task: Record<string, unknown>): Record<string, unknown> {
-  return {
-    ...compactTaskView(task),
-    title: compactProjectBoardText(task.title),
-  };
-}
 
-function summarizeUpdatedIssue(
-  issue: Record<string, unknown>,
-  taskId: string,
-): Record<string, unknown> {
-  const tasks = Array.isArray(issue.tasks) ? issue.tasks as Array<Record<string, unknown>> : [];
-  const updatedTask = tasks.find((task) => task.id === taskId);
-  return {
-    detailLevel: "summary",
-    id: issue.id,
-    title: compactProjectBoardText(issue.title),
-    status: issue.status,
-    lifecycleStatus: issue.lifecycleStatus,
-    github: issue.github,
-    taskCount: tasks.length,
-    tasks: tasks.slice(0, UPDATE_TASK_SUMMARY_TASK_LIMIT).map(compactUpdatedTaskView),
-    taskTruncatedCount: Math.max(0, tasks.length - UPDATE_TASK_SUMMARY_TASK_LIMIT),
-    updatedTask: updatedTask ? compactUpdatedTaskView(updatedTask) : undefined,
-    detailPointer: {
-      tool: "get_issue",
-      arguments: { issue_id: issue.id, detail_level: "full" },
-    },
-  };
-}
 
-function dispatchExecutorHealthResult(
-  health: ExecutorHealth,
-  options: { requestId?: string; retryable?: boolean } = {},
-): CallToolResult {
-  return dispatchErrorResult(executorHealthCode(health), health.message, {
-    requestId: options.requestId,
-    retryable: options.retryable,
-    details: { executorHealth: health },
-  });
-}
 
-function taskExecutorHealth(
-  ctx: McpToolContext,
-  task: ControllerTask,
-  agent: ControllerAgent,
-  githubRepo?: string,
-): ExecutorHealth | null {
-  if (agent === "github-copilot") {
-    return classifyGitHubCopilotPreflight(
-      getGitHubStatus(ctx.repoRoot, githubRepo),
-      task,
-    );
-  }
-  return classifyLocalExecutorHealth(
-    agent,
-    {
-      agentRunner: ctx.policy.execution.agentRunner,
-      allowedAgents: ctx.policy.execution.allowedAgents,
-    },
-    task,
-  );
-}
 
 function listFilesUnder(
   repoRoot: string,
@@ -829,28 +267,7 @@ function timestampPrefix(date = new Date()): string {
   return `${yyyy}${mm}${dd}-${hh}${min}`;
 }
 
-function parseControllerAgent(value: unknown): ControllerAgent | null {
-  const normalized = String(value ?? "")
-    .trim()
-    .toLowerCase();
-  return normalized === "codex" ||
-    normalized === "claude" ||
-    normalized === "github-copilot"
-    ? normalized
-    : null;
-}
 
-function resolveDispatchAgent(
-  ctx: McpToolContext,
-  task: ControllerTask,
-  requested: unknown,
-): ControllerAgent | null {
-  const hasExplicitRequest = requested !== undefined && requested !== null && String(requested).trim() !== "";
-  if (hasExplicitRequest) return parseControllerAgent(requested);
-  if (task.recommendedAgent) return task.recommendedAgent;
-  const firstLocal = ctx.policy.execution.allowedAgents[0];
-  return firstLocal ?? task.recommendedAgent ?? null;
-}
 
 function runnerTimeoutMs(ctx: McpToolContext, value: unknown): number {
   return normalizeAgentTimeoutMs(value, {
@@ -1000,50 +417,8 @@ interface TaskVerificationLeaseConflict {
   blockingProcessId?: string;
 }
 
-function taskVerificationLeaseConflict(record: {
-  error?: { message?: unknown };
-}): TaskVerificationLeaseConflict | undefined {
-  const message = typeof record.error?.message === "string" ? record.error.message.trim() : "";
-  if (!message.startsWith("PROCESS_LEASE_CONFLICT:")) return undefined;
-  const match = /^PROCESS_LEASE_CONFLICT:\s*(.+?)@process:([A-Za-z0-9._-]+)$/.exec(message);
-  return {
-    message,
-    resourceKey: match?.[1],
-    blockingProcessId: match?.[2],
-  };
-}
 
-function taskVerificationRetryRequestId(
-  requestBase: string,
-  checkId: string,
-  conflictedProcessId: string,
-): string {
-  const stableBase = requestBase.replace(/:retry:[a-f0-9]{16}$/i, "");
-  const retryToken = createHash("sha256")
-    .update(`${stableBase}\0${checkId}\0${conflictedProcessId}`)
-    .digest("hex")
-    .slice(0, 16);
-  return `${stableBase}:retry:${retryToken}`;
-}
 
-function controllerTaskDrafts(value: unknown): TaskDraft[] {
-  return taskObjects(value).map((task) => ({
-    title: String(task.title ?? "").trim(),
-    objective: String(task.objective ?? "").trim(),
-    dependsOn: stringList(task.depends_on ?? task.dependsOn),
-    allowedPaths: stringList(task.allowed_paths ?? task.allowedPaths),
-    forbiddenPaths: stringList(task.forbidden_paths ?? task.forbiddenPaths),
-    checks: stringList(task.checks),
-    acceptanceCriteria: stringList(
-      task.acceptance_criteria ?? task.acceptanceCriteria,
-    ),
-    risk: (["readonly", "low", "medium", "high", "destructive"].includes(String(task.risk))
-      ? String(task.risk)
-      : "medium") as TaskRisk,
-    recommendedAgent:
-      parseControllerAgent(task.agent ?? task.recommendedAgent) ?? undefined,
-  }));
-}
 
 function renderPrdFromIdeaBody(args: Record<string, unknown>): string {
   const title = String(args.title ?? "Untitled PRD").trim() || "Untitled PRD";
@@ -1575,18 +950,12 @@ export function buildMcpToolDefinitions(
       {
         name: "controller_context",
         description:
-          "Return one compact controller start-work context: Git status, current Issue focus, active Runs and Jobs, recommended execution mode, and available checks.",
+          "Return one compact controller start-work context: Git status, current Issue focus, active Runs and Jobs, and available checks.",
         inputSchema: {
           type: "object",
           properties: {
             description: { type: "string" },
-            mode: { type: "string", enum: ["direct", "plan", "debug", "review", "release", "scale", "-direct", "-plan", "-debug", "-review", "-release", "-scale"] },
             known_paths: { type: "array", items: { type: "string" } },
-            expected_files: { type: "number" },
-            expected_changed_lines: { type: "number" },
-            requires_investigation: { type: "boolean" },
-            requires_parallelism: { type: "boolean" },
-            requires_long_running_checks: { type: "boolean" },
             needs_dependencies: { type: "boolean" },
             risk: { type: "string", enum: ["readonly", "low", "medium", "high", "destructive"] },
           },
@@ -1765,101 +1134,6 @@ export function buildMcpToolDefinitions(
         inputSchema: EMPTY_SCHEMA,
         annotations: readOnly,
       },
-      {
-        name: "list_issues",
-        description: "List controller-managed issues and task summaries.",
-        inputSchema: EMPTY_SCHEMA,
-        annotations: readOnly,
-      },
-      {
-        name: "get_project_board",
-        description: "Return the bounded Requirement Board by default. Explicit detail/full mode returns bounded Execution Diagnostics without exposing the full legacy Task/Run/Process ledger.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            detail_level: { type: "string", enum: ["summary", "detail", "full"] },
-            requirement_id: { type: "string" },
-          },
-          additionalProperties: false,
-        },
-        annotations: readOnly,
-      },
-      {
-        name: "get_project_progress",
-        description:
-          "Return evidence-gate completion, effective status, blockers, throughput, current-focus progress, and attention items without lifecycle-percentage estimates.",
-        inputSchema: EMPTY_SCHEMA,
-        annotations: readOnly,
-      },
-      {
-        name: "get_project_governance",
-        description:
-          "Return the current execution focus, evidence-driven execution queue, dead dependencies, pending review/acceptance, duplicate active Issues, and closeout anomalies.",
-        inputSchema: EMPTY_SCHEMA,
-        annotations: readOnly,
-      },
-      {
-        name: "reconcile_project_governance",
-        description:
-          "Apply only safe governance repairs: replace superseded dependencies, return failed attempts to a retryable Task state, close fully completed Issues, and select the sole active Issue as focus.",
-        inputSchema: EMPTY_SCHEMA,
-        annotations: write,
-      },
-      {
-        name: "get_project_state",
-        description: "Return the current execution focus and Issue creation policy.",
-        inputSchema: EMPTY_SCHEMA,
-        annotations: readOnly,
-      },
-      {
-        name: "set_current_issue",
-        description: "Select the one active Issue that is allowed to drive the execution queue.",
-        inputSchema: {
-          type: "object",
-          properties: { issue_id: { type: "string" } },
-          required: ["issue_id"],
-          additionalProperties: false,
-        },
-        annotations: write,
-      },
-      {
-        name: "archive_issue",
-        description: "Move a done or cancelled Issue out of the current workspace while retaining its full evidence history.",
-        inputSchema: {
-          type: "object",
-          properties: { issue_id: { type: "string" } },
-          required: ["issue_id"],
-          additionalProperties: false,
-        },
-        annotations: write,
-      },
-      {
-        name: "restore_issue",
-        description: "Restore an archived Issue to the normal controller views.",
-        inputSchema: {
-          type: "object",
-          properties: { issue_id: { type: "string" } },
-          required: ["issue_id"],
-          additionalProperties: false,
-        },
-        annotations: write,
-      },
-      {
-        name: "get_task_progress_detail",
-        description:
-          "Return one Task with effective progress, bounded Run and timeline summaries by default, and full detail on demand.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            issue_id: { type: "string" },
-            task_id: { type: "string" },
-            detail_level: { type: "string", enum: ["summary", "full"] },
-          },
-          required: ["issue_id", "task_id"],
-          additionalProperties: false,
-        },
-        annotations: readOnly,
-      },
       {
         name: "get_worklog_timeline",
         description:
@@ -1926,345 +1200,135 @@ export function buildMcpToolDefinitions(
         annotations: write,
       },
       {
-        name: "get_issue",
-        description: "Read one controller issue by ID with bounded task summaries by default and full detail on demand.",
+        name: "github_status",
+        description:
+          "Check GitHub CLI authentication, repository mapping, Projects readiness, and cloud-agent session support.",
         inputSchema: {
           type: "object",
-          properties: {
-            issue_id: { type: "string" },
-            detail_level: { type: "string", enum: ["summary", "full"] },
-          },
-          required: ["issue_id"],
+          properties: { repo: { type: "string" } },
           additionalProperties: false,
         },
         annotations: readOnly,
       },
       {
-        name: "github_status",
+        name: "begin_edit_session",
         description:
-          "Check GitHub CLI authentication, repository mapping, Projects readiness, and cloud-agent session support.",
+          "Open a bounded direct-edit session tied to a purpose and optional Issue/Task.",
         inputSchema: {
           type: "object",
-          properties: { repo: { type: "string" } },
+          properties: {
+            purpose: { type: "string" },
+            work_id: { type: "string", description: "Optional existing WorkContract. Omit to create lightweight direct-control Work lineage." },
+            issue_id: { type: "string" },
+            task_id: { type: "string" },
+            allowed_paths: { type: "array", items: { type: "string" } },
+            max_files: { type: "number" },
+            max_changed_lines: { type: "number" },
+            checks: { type: "array", items: { type: "string" }, description: "Named checks to run before finalization." },
+          },
+          required: ["purpose"],
           additionalProperties: false,
         },
-        annotations: readOnly,
+        annotations: write,
       },
       {
-        name: "publish_issue_to_github",
+        name: "apply_patch",
         description:
-          "Create or update the controller Issue in GitHub, optionally mirroring Tasks as sub-issues and adding all items to a GitHub Project.",
+          "Append one bounded patch batch to an active edit session. Prefer batches of 100 operations or fewer and pass expected_revision to avoid stale revisions.",
         inputSchema: {
           type: "object",
           properties: {
-            issue_id: { type: "string" },
-            repo: { type: "string" },
-            labels: { type: "array", items: { type: "string" } },
-            include_tasks: { type: "boolean" },
-            project_owner: { type: "string" },
-            project_number: { type: "number" },
+            session_id: { type: "string" },
+            expected_revision: { type: "number", description: "Optional current revision precondition for the edit session." },
+            operations: {
+              type: "array",
+              items: EDIT_OPERATION_INPUT_SCHEMA,
+            },
           },
-          required: ["issue_id"],
+          required: ["session_id", "operations"],
           additionalProperties: false,
         },
         annotations: {
           readOnlyHint: false,
-          openWorldHint: true,
+          openWorldHint: false,
           destructiveHint: false,
         },
       },
       {
-        name: "refresh_github_issue",
-        description:
-          "Refresh the linked GitHub Issue metadata and remote state.",
+        name: "get_edit_session",
+        description: "Read an edit session, revisions, savepoints, and operation manifest.",
         inputSchema: {
           type: "object",
-          properties: { issue_id: { type: "string" } },
-          required: ["issue_id"],
+          properties: { session_id: { type: "string" } },
+          required: ["session_id"],
           additionalProperties: false,
         },
         annotations: readOnly,
       },
       {
-        name: "close_github_issue",
-        description:
-          "Close the linked GitHub Issue after local controller acceptance.",
+        name: "list_edit_sessions",
+        description: "List recent direct-edit sessions with revision, changed-file, and check summaries.",
         inputSchema: {
           type: "object",
-          properties: { issue_id: { type: "string" } },
-          required: ["issue_id"],
+          properties: { limit: { type: "number" } },
           additionalProperties: false,
         },
-        annotations: {
-          readOnlyHint: false,
-          openWorldHint: true,
-          destructiveHint: true,
-        },
+        annotations: readOnly,
       },
       {
-        name: "inspect_issue_readiness",
-        description:
-          "Score launch readiness, list blockers and warnings, and summarize executable Tasks. Agent selection happens at dispatch time.",
+        name: "get_edit_session_diff",
+        description: "Read the current aggregate localized diff for one direct-edit session.",
         inputSchema: {
           type: "object",
-          properties: { issue_id: { type: "string" } },
-          required: ["issue_id"],
+          properties: { session_id: { type: "string" } },
+          required: ["session_id"],
           additionalProperties: false,
         },
         annotations: readOnly,
       },
       {
-        name: "inspect_task_readiness",
-        description:
-          "Evaluate launch readiness for one Task only. Other Issues, focus selection, unrelated Tasks, and missing named checks do not block it.",
+        name: "create_edit_savepoint",
+        description: "Name the current edit revision so later patch batches can be rolled back to it.",
         inputSchema: {
           type: "object",
           properties: {
-            issue_id: { type: "string" },
-            task_id: { type: "string" },
-            retry_from_run_id: { type: "string" },
-            approve_destructive: { type: "boolean" },
+            session_id: { type: "string" },
+            name: { type: "string" },
           },
-          required: ["issue_id", "task_id"],
+          required: ["session_id", "name"],
           additionalProperties: false,
         },
-        annotations: readOnly,
+        annotations: write,
       },
       {
-        name: "prepare_issue_launch",
-        description:
-          "Return an Issue Launcher preview without starting any agent session.",
+        name: "verify_edit_session",
+        description: "Verify the current edit revision through persisted Process Runtime checks. Retries with the same request_id reuse the original process and terminal receipts are attached to the exact revision.",
         inputSchema: {
           type: "object",
           properties: {
-            issue_id: { type: "string" },
-            max_parallel: { type: "number" },
+            session_id: { type: "string" },
+            check_ids: { type: "array", items: { type: "string" } },
+            request_id: { type: "string" },
+            reviewer: { type: "string" },
+            note: { type: "string" },
           },
-          required: ["issue_id"],
+          required: ["session_id"],
           additionalProperties: false,
         },
-        annotations: readOnly,
+        annotations: write,
       },
       {
-        name: "assess_work_request",
+        name: "rollback_edit_session",
         description:
-          "Choose direct_edit, quick_agent, or issue_task before creating work. Prefer repository search plus bounded direct edits for low/medium-risk changes, even when exact files need discovery; use an Agent only when direct patches are not safe or practical.",
+          "Rollback an active edit session completely, to a prior revision, or to a named savepoint.",
         inputSchema: {
           type: "object",
           properties: {
-            description: { type: "string" },
-            mode: { type: "string", enum: ["direct", "plan", "debug", "review", "release", "scale", "-direct", "-plan", "-debug", "-review", "-release", "-scale"] },
-            known_paths: { type: "array", items: { type: "string" } },
-            expected_files: { type: "number" },
-            expected_changed_lines: { type: "number" },
-            requires_investigation: { type: "boolean" },
-            requires_parallelism: { type: "boolean" },
-            requires_long_running_checks: { type: "boolean" },
-            needs_dependencies: { type: "boolean" },
-            risk: { type: "string", enum: ["readonly", "low", "medium", "high", "destructive"] },
+            session_id: { type: "string" },
+            to_revision: { type: "number", description: "Keep revisions up to this value; omit for full rollback." },
+            savepoint: { type: "string", description: "Rollback to a named savepoint." },
           },
-          required: ["description"],
-          additionalProperties: false,
-        },
-        annotations: readOnly,
-      },
-      {
-        name: "create_issue",
-        description:
-          "Create a durable Issue only for broad, long-running, dependency-aware, parallel, protected-path, or high-risk work. File discovery by itself is not a reason to create an Issue or start an Agent; search first and use bounded direct edits when practical.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            title: { type: "string" },
-            kind: {
-              type: "string",
-              enum: ["bug", "feature", "governance", "investigation"],
-            },
-            summary: { type: "string" },
-            goals: { type: "array", items: { type: "string" } },
-            non_goals: { type: "array", items: { type: "string" } },
-            acceptance_criteria: { type: "array", items: { type: "string" } },
-            related_artifacts: { type: "array", items: { type: "string" } },
-            tasks: { type: "array", items: taskItemSchema },
-            allow_while_focused: { type: "boolean", description: "Explicitly allow a separate Issue while another Issue is the current execution focus." },
-            allow_duplicate: { type: "boolean", description: "Explicitly allow an active Issue with the same normalized title." },
-            allow_when_paused: { type: "boolean", description: "Explicitly override a paused Issue-creation policy." },
-          },
-          required: ["title"],
-          additionalProperties: false,
-        },
-        annotations: write,
-      },
-      {
-        name: "update_issue",
-        description: "Update issue intent, artifacts, or lifecycle status.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            issue_id: { type: "string" },
-            title: { type: "string" },
-            summary: { type: "string" },
-            status: {
-              type: "string",
-              enum: [
-                "backlog",
-                "analysis",
-                "planned",
-                "launch_blocked",
-                "in_progress",
-                "review",
-                "done",
-                "cancelled",
-              ],
-            },
-            goals: { type: "array", items: { type: "string" } },
-            non_goals: { type: "array", items: { type: "string" } },
-            acceptance_criteria: { type: "array", items: { type: "string" } },
-            related_artifacts: { type: "array", items: { type: "string" } },
-          },
-          required: ["issue_id"],
-          additionalProperties: false,
-        },
-        annotations: write,
-      },
-      {
-        name: "plan_issue",
-        description:
-          "Replace the pre-execution task plan for an Issue with ordered dependency-aware tasks.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            issue_id: { type: "string" },
-            tasks: { type: "array", items: taskItemSchema },
-          },
-          required: ["issue_id", "tasks"],
-          additionalProperties: false,
-        },
-        annotations: write,
-      },
-      {
-        name: "append_task",
-        description:
-          "Append a stable Task to an Issue after execution has already started.",
-        inputSchema: {
-          type: "object",
-          properties: { issue_id: { type: "string" }, task: taskItemSchema },
-          required: ["issue_id", "task"],
-          additionalProperties: false,
-        },
-        annotations: write,
-      },
-      {
-        name: "split_task",
-        description:
-          "Supersede one not-running Task with two or more smaller replacement Tasks while preserving downstream dependencies.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            issue_id: { type: "string" },
-            task_id: { type: "string" },
-            tasks: { type: "array", minItems: 2, items: taskItemSchema },
-          },
-          required: ["issue_id", "task_id", "tasks"],
-          additionalProperties: false,
-        },
-        annotations: write,
-      },
-      {
-        name: "supersede_task",
-        description:
-          "Mark a Task as superseded and optionally link replacement Task IDs.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            issue_id: { type: "string" },
-            task_id: { type: "string" },
-            replacement_task_ids: { type: "array", items: { type: "string" } },
-          },
-          required: ["issue_id", "task_id"],
-          additionalProperties: false,
-        },
-        annotations: write,
-      },
-      {
-        name: "set_task_dependencies",
-        description:
-          "Replace one Task dependency list and revalidate the Issue DAG.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            issue_id: { type: "string" },
-            task_id: { type: "string" },
-            depends_on: { type: "array", items: { type: "string" } },
-          },
-          required: ["issue_id", "task_id", "depends_on"],
-          additionalProperties: false,
-        },
-        annotations: write,
-      },
-      {
-        name: "update_task",
-        description: "Update one task status or append a controller note.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            issue_id: { type: "string" },
-            task_id: { type: "string" },
-            status: {
-              type: "string",
-              enum: [
-                "backlog",
-                "analysis",
-                "planned",
-                "ready",
-                "launch_blocked",
-                "running",
-                "blocked",
-                "review",
-                "integrated",
-                "verifying",
-                "changes_requested",
-                "verified",
-                "done",
-                "cancelled",
-                "superseded",
-              ],
-            },
-            note: { type: "string" },
-            detail_level: { type: "string", enum: ["summary", "detail", "full"] },
-          },
-          required: ["issue_id", "task_id"],
-          additionalProperties: false,
-        },
-        annotations: write,
-      },
-      {
-        name: "dispatch_task",
-        description:
-          "Execute one Task with an agent selected at dispatch time. Task definitions remain executor-neutral; Codex, Claude, and GitHub Copilot are optional implementation tools.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            issue_id: { type: "string" },
-            task_id: { type: "string" },
-            request_id: { type: "string" },
-            agent: {
-              type: "string",
-              enum: ["codex", "claude", "github-copilot"],
-            },
-            timeout_ms: agentTimeoutSchema,
-            isolate: {
-              type: "boolean",
-              description:
-                "Optional. Omit for automatic placement: use the current workspace when no local Run is active and a worktree only for concurrency. false forces the current workspace and is rejected during concurrency; true forces a worktree.",
-            },
-            github_repo: { type: "string" },
-            base_ref: { type: "string" },
-            model: { type: "string" },
-            create_pull_request: { type: "boolean" },
-            approve_destructive: { type: "boolean", description: "Explicit same-request authorization for destructive or irreversible execution." },
-          },
-          required: ["issue_id", "task_id"],
+          required: ["session_id"],
           additionalProperties: false,
         },
         annotations: {
@@ -2274,62 +1338,40 @@ export function buildMcpToolDefinitions(
         },
       },
       {
-        name: "launch_issue",
+        name: "finalize_edit_session",
         description:
-          "Execute independent Tasks from one Issue with an optional runtime agent override. Task definitions do not permanently bind an agent.",
+          "Close an active edit session. Configured checks must pass; sessions without configured checks finalize directly.",
         inputSchema: {
           type: "object",
           properties: {
-            issue_id: { type: "string" },
-            max_parallel: { type: "number" },
-            request_id: { type: "string" },
-            agent: { type: "string", enum: ["codex", "claude", "github-copilot"], description: "Optional runtime executor override for selected Tasks." },
-            timeout_ms: agentTimeoutSchema,
-            isolate: {
-              type: "boolean",
-              description:
-                "Optional. Omit for automatic placement: use the current workspace when no local Run is active and a worktree only for concurrency. false forces the current workspace and is rejected during concurrency; true forces a worktree.",
-            },
-            github_repo: { type: "string" },
-            base_ref: { type: "string" },
-            model: { type: "string" },
-            create_pull_request: { type: "boolean" },
-            approve_destructive: { type: "boolean", description: "Explicit same-request authorization for destructive or irreversible execution." },
+            session_id: { type: "string" },
+            reviewer: { type: "string" },
+            note: { type: "string" },
+            confirm_authorization: { type: "boolean", description: "Required when post-diff assurance detects protected paths or high semantic risk." },
           },
-          required: ["issue_id"],
+          required: ["session_id"],
           additionalProperties: false,
         },
-        annotations: {
-          readOnlyHint: false,
-          openWorldHint: true,
-          destructiveHint: false,
-        },
+        annotations: write,
       },
+    );
+  }
+
+  if (policy.execution.fixedWorkflowCheck) {
+    tools.push({
+      name: "run_workflow_check",
+      description: "Run the fixed forge strict workflow check.",
+      inputSchema: EMPTY_SCHEMA,
+      annotations: write,
+    });
+  }
+  if (opts.enableChatgptBrowser === true) {
+    tools.push(
       {
-        name: "dispatch_ready_tasks",
+        name: "run_chatgpt_browser_consult",
         description:
-          "Execute up to max_parallel independent Tasks with an optional runtime agent override.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            issue_id: { type: "string" },
-            max_parallel: { type: "number" },
-            request_id: { type: "string" },
-            agent: { type: "string", enum: ["codex", "claude", "github-copilot"], description: "Optional runtime executor override for selected Tasks." },
-            timeout_ms: agentTimeoutSchema,
-            isolate: {
-              type: "boolean",
-              description:
-                "Optional. Omit for automatic placement: use the current workspace when no local Run is active and a worktree only for concurrency. false forces the current workspace and is rejected during concurrency; true forces a worktree.",
-            },
-            github_repo: { type: "string" },
-            base_ref: { type: "string" },
-            model: { type: "string" },
-            create_pull_request: { type: "boolean" },
-            approve_destructive: { type: "boolean", description: "Explicit same-request authorization for destructive or irreversible execution." },
-          },
-          additionalProperties: false,
-        },
+          "Run a local ChatGPT Web browser consult through forge. This may create a real ChatGPT Web conversation unless dryRun is true.",
+        inputSchema: browserRunSchema,
         annotations: {
           readOnlyHint: false,
           openWorldHint: true,
@@ -2337,522 +1379,97 @@ export function buildMcpToolDefinitions(
         },
       },
       {
-        name: "get_task_run",
-        description:
-          "Read one persistent agent run with current status, bounded output tails, and opt-in path details.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            run_id: { type: "string" },
-            include_paths: { type: "boolean", description: "Opt in to full local filesystem paths and PIDs." },
-            include_output: { type: "boolean", description: "Return bounded stdout/stderr tails. Defaults to true." },
-            tail_chars: { type: "number", description: "Per-stream character budget for the bounded tails; capped at 16384." },
-          },
-          required: ["run_id"],
-          additionalProperties: false,
-        },
-        annotations: readOnly,
-      },
-      {
-        name: "get_task_run_events",
+        name: "read_chatgpt_browser_session",
         description:
-          "Read structured lifecycle events for a local or GitHub cloud Task Run.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            run_id: { type: "string" },
-            limit: { type: "number" },
-            since_event_index: { type: "number" },
-            include_heartbeats: { type: "boolean" },
-          },
-          required: ["run_id"],
-          additionalProperties: false,
-        },
+          "Read a saved forge ChatGPT browser consult session.",
+        inputSchema: browserSessionSchema,
         annotations: readOnly,
       },
       {
-        name: "get_task_run_log",
+        name: "list_chatgpt_browser_sessions",
         description:
-          "Read a bounded, redacted tail of current local output or GitHub cloud-agent session logs. GitHub logs can be watched directly in the linked Agents UI.",
+          "List saved forge ChatGPT browser consult sessions.",
         inputSchema: {
           type: "object",
-          properties: {
-            run_id: { type: "string" },
-            max_bytes: { type: "number", description: "Bounded log tail size; capped at 1 MiB." },
-          },
-          required: ["run_id"],
+          properties: { limit: { type: "number" } },
           additionalProperties: false,
         },
         annotations: readOnly,
       },
       {
-        name: "get_task_diff",
+        name: "open_chatgpt_browser_session",
         description:
-          "Inspect the Git status and diff from one isolated Task Run worktree.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            run_id: { type: "string" },
-            max_bytes: { type: "number" },
-          },
-          required: ["run_id"],
-          additionalProperties: false,
-        },
+          "Return the ChatGPT conversation URL for a saved browser session. The MCP tool does not launch the local browser.",
+        inputSchema: browserSessionSchema,
         annotations: readOnly,
       },
       {
-        name: "integrate_task_run",
-        description:
-          "Integrate one reviewed isolated Task Run into the main working tree through a rollback-capable edit session.",
-        inputSchema: {
-          type: "object",
-          properties: { run_id: { type: "string" } },
-          required: ["run_id"],
-          additionalProperties: false,
-        },
-        annotations: {
-          readOnlyHint: false,
-          openWorldHint: false,
-          destructiveHint: true,
-        },
-      },
-      {
-        name: "finish_task_run",
+        name: "continue_chatgpt_browser_session",
         description:
-          "Finish one reviewed Run in a single policy-gated step: integrate if needed, verify, accept when allowed, and clean the isolated worktree. Use decision=auto for low/medium trusted work; use approve_and_finish only for explicit human approval.",
+          "Create a follow-up ChatGPT browser consult record linked to an existing session.",
         inputSchema: {
           type: "object",
           properties: {
-            run_id: { type: "string" },
-            decision: {
-              type: "string",
-              enum: ["auto", "approve_and_finish", "request_changes", "discard"],
-            },
-            reviewer: { type: "string" },
-            note: { type: "string" },
-            cleanup: { type: "boolean" },
-            commit: { type: "boolean", description: "Create a selected-path Git commit after successful finish. Refuses to mix with pre-staged changes." },
+            sessionId: { type: "string" },
+            prompt: { type: "string" },
+            dryRun: { type: "boolean" },
           },
-          required: ["run_id"],
+          required: ["sessionId", "prompt"],
           additionalProperties: false,
         },
         annotations: {
           readOnlyHint: false,
-          openWorldHint: false,
+          openWorldHint: true,
           destructiveHint: false,
         },
       },
-      {
-        name: "list_task_runs",
-        description: "List recent persistent agent runs.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            limit: { type: "number" },
-            include_paths: { type: "boolean", description: "Opt in to full local filesystem paths and PIDs." },
-          },
-          additionalProperties: false,
-        },
-        annotations: readOnly,
-      },
-      {
-        name: "cancel_task_run",
-        description: "Cancel a queued or running local agent task.",
-        inputSchema: {
-          type: "object",
-          properties: { run_id: { type: "string" } },
-          required: ["run_id"],
-          additionalProperties: false,
-        },
-        annotations: {
-          readOnlyHint: false,
-          openWorldHint: false,
-          destructiveHint: true,
-        },
-      },
-      {
-        name: "retry_task_run",
-        description:
-          "Create a new run for a failed, blocked, cancelled, or change-requested task.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            run_id: { type: "string" },
-            timeout_ms: agentTimeoutSchema,
-            isolate: {
-              type: "boolean",
-              description:
-                "Optional. Omit for automatic placement: use the current workspace when no local Run is active and a worktree only for concurrency. false forces the current workspace and is rejected during concurrency; true forces a worktree.",
-            },
-          },
-          required: ["run_id"],
-          additionalProperties: false,
-        },
-        annotations: write,
-      },
-      {
-        name: "verify_task",
-        description:
-          "Record task-local completion evidence. Declared checks execute through persisted Process Runtime receipts; retries reuse the same processes and reported command evidence can satisfy risk-adaptive verification.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            issue_id: { type: "string" },
-            task_id: { type: "string" },
-            run_id: { type: "string" },
-            integrated_revision: { type: "string" },
-            reviewed_diff_hash: { type: "string" },
-            reviewer: { type: "string" },
-            request_id: { type: "string", description: "Stable idempotency key for Process Runtime checks; retries reuse the original processes." },
-            check_results: {
-              type: "array",
-              items: {
-                type: "object",
-                properties: {
-                  check_id: { type: "string" },
-                  ok: { type: "boolean", description: "Deprecated compatibility field. The Controller executes the named check and uses the actual outcome." },
-                  summary: { type: "string" },
-                },
-                required: ["check_id"],
-                additionalProperties: false,
-              },
-            },
-            reported_commands: {
-              type: "array",
-              items: {
-                type: "object",
-                properties: {
-                  command: { type: "array", items: { type: "string" }, minItems: 1 },
-                  cwd: { type: "string" },
-                  ok: { type: "boolean" },
-                  exit_code: { type: "number" },
-                  stdout: { type: "string" },
-                  stderr: { type: "string" },
-                  artifact_path: { type: "string" },
-                  executed_at: { type: "string" },
-                },
-                required: ["command", "ok"],
-                additionalProperties: false,
-              },
-            },
-            acceptance_results: {
-              type: "array",
-              items: {
-                type: "object",
-                properties: {
-                  criterion: { type: "string" },
-                  ok: { type: "boolean" },
-                  evidence: { type: "string" },
-                },
-                required: ["criterion", "ok"],
-                additionalProperties: false,
-              },
-            },
-          },
-          required: ["issue_id", "task_id", "reviewer"],
-          additionalProperties: false,
-        },
-        annotations: write,
-      },
-      {
-        name: "accept_task",
-        description:
-          "Accept a verified task, mark it done, and unlock dependent tasks.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            issue_id: { type: "string" },
-            task_id: { type: "string" },
-            work_id: { type: "string" },
-            note: { type: "string" },
-          },
-          required: ["issue_id", "task_id"],
-          additionalProperties: false,
-        },
-        annotations: write,
-      },
-      {
-        name: "request_task_changes",
-        description:
-          "Return a reviewed task for another focused execution run.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            issue_id: { type: "string" },
-            task_id: { type: "string" },
-            note: { type: "string" },
-          },
-          required: ["issue_id", "task_id", "note"],
-          additionalProperties: false,
-        },
-        annotations: write,
-      },
-      {
-        name: "begin_edit_session",
-        description:
-          "Open a bounded direct-edit session tied to a purpose and optional Issue/Task.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            purpose: { type: "string" },
-            work_id: { type: "string", description: "Optional existing WorkContract. Omit to create lightweight direct-control Work lineage." },
-            issue_id: { type: "string" },
-            task_id: { type: "string" },
-            allowed_paths: { type: "array", items: { type: "string" } },
-            max_files: { type: "number" },
-            max_changed_lines: { type: "number" },
-            checks: { type: "array", items: { type: "string" }, description: "Named checks to run before finalization." },
-          },
-          required: ["purpose"],
-          additionalProperties: false,
-        },
-        annotations: write,
-      },
-      {
-        name: "apply_patch",
-        description:
-          "Append one bounded patch batch to an active edit session. Prefer batches of 100 operations or fewer and pass expected_revision to avoid stale revisions.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            session_id: { type: "string" },
-            expected_revision: { type: "number", description: "Optional current revision precondition for the edit session." },
-            operations: {
-              type: "array",
-              items: EDIT_OPERATION_INPUT_SCHEMA,
-            },
-          },
-          required: ["session_id", "operations"],
-          additionalProperties: false,
-        },
-        annotations: {
-          readOnlyHint: false,
-          openWorldHint: false,
-          destructiveHint: false,
-        },
-      },
-      {
-        name: "get_edit_session",
-        description: "Read an edit session, revisions, savepoints, and operation manifest.",
-        inputSchema: {
-          type: "object",
-          properties: { session_id: { type: "string" } },
-          required: ["session_id"],
-          additionalProperties: false,
-        },
-        annotations: readOnly,
-      },
-      {
-        name: "list_edit_sessions",
-        description: "List recent direct-edit sessions with revision, changed-file, and check summaries.",
-        inputSchema: {
-          type: "object",
-          properties: { limit: { type: "number" } },
-          additionalProperties: false,
-        },
-        annotations: readOnly,
-      },
-      {
-        name: "get_edit_session_diff",
-        description: "Read the current aggregate localized diff for one direct-edit session.",
-        inputSchema: {
-          type: "object",
-          properties: { session_id: { type: "string" } },
-          required: ["session_id"],
-          additionalProperties: false,
-        },
-        annotations: readOnly,
-      },
-      {
-        name: "create_edit_savepoint",
-        description: "Name the current edit revision so later patch batches can be rolled back to it.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            session_id: { type: "string" },
-            name: { type: "string" },
-          },
-          required: ["session_id", "name"],
-          additionalProperties: false,
-        },
-        annotations: write,
-      },
-      {
-        name: "verify_edit_session",
-        description: "Verify the current edit revision through persisted Process Runtime checks. Retries with the same request_id reuse the original process and terminal receipts are attached to the exact revision.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            session_id: { type: "string" },
-            check_ids: { type: "array", items: { type: "string" } },
-            request_id: { type: "string" },
-            reviewer: { type: "string" },
-            note: { type: "string" },
-          },
-          required: ["session_id"],
-          additionalProperties: false,
-        },
-        annotations: write,
-      },
-      {
-        name: "rollback_edit_session",
-        description:
-          "Rollback an active edit session completely, to a prior revision, or to a named savepoint.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            session_id: { type: "string" },
-            to_revision: { type: "number", description: "Keep revisions up to this value; omit for full rollback." },
-            savepoint: { type: "string", description: "Rollback to a named savepoint." },
-          },
-          required: ["session_id"],
-          additionalProperties: false,
-        },
-        annotations: {
-          readOnlyHint: false,
-          openWorldHint: false,
-          destructiveHint: false,
-        },
-      },
-      {
-        name: "finalize_edit_session",
-        description:
-          "Close an active edit session. Configured checks must pass; sessions without configured checks finalize directly.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            session_id: { type: "string" },
-            reviewer: { type: "string" },
-            note: { type: "string" },
-            confirm_authorization: { type: "boolean", description: "Required when post-diff assurance detects protected paths or high semantic risk." },
-          },
-          required: ["session_id"],
-          additionalProperties: false,
-        },
-        annotations: write,
-      },
-      {
-        name: "finish_edit_session",
-        description:
-          "Verify, finalize, selected-path commit, receipt, and complete the Task bound to one Direct Edit session.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            session_id: { type: "string" },
-            decision: { type: "string", enum: ["auto", "approve_and_finish", "request_changes", "discard"] },
-            reviewer: { type: "string" },
-            note: { type: "string" },
-            check_ids: { type: "array", items: { type: "string" } },
-            commit: { type: "boolean" },
-          },
-          required: ["session_id"],
-          additionalProperties: false,
-        },
-        annotations: write,
-      },
     );
   }
+  return tools.filter((tool) => !RETIRED_LEGACY_PUBLIC_TOOLS.has(tool.name));
+}
 
-  if (policy.execution.fixedWorkflowCheck) {
-    tools.push({
-      name: "run_workflow_check",
-      description: "Run the fixed forge strict workflow check.",
-      inputSchema: EMPTY_SCHEMA,
-      annotations: write,
-    });
-  }
-  if (opts.enableChatgptBrowser === true) {
-    tools.push(
-      {
-        name: "run_chatgpt_browser_consult",
-        description:
-          "Run a local ChatGPT Web browser consult through forge. This may create a real ChatGPT Web conversation unless dryRun is true.",
-        inputSchema: browserRunSchema,
-        annotations: {
-          readOnlyHint: false,
-          openWorldHint: true,
-          destructiveHint: false,
-        },
-      },
-      {
-        name: "read_chatgpt_browser_session",
-        description:
-          "Read a saved forge ChatGPT browser consult session.",
-        inputSchema: browserSessionSchema,
-        annotations: readOnly,
-      },
-      {
-        name: "list_chatgpt_browser_sessions",
-        description:
-          "List saved forge ChatGPT browser consult sessions.",
-        inputSchema: {
-          type: "object",
-          properties: { limit: { type: "number" } },
-          additionalProperties: false,
-        },
-        annotations: readOnly,
-      },
-      {
-        name: "open_chatgpt_browser_session",
-        description:
-          "Return the ChatGPT conversation URL for a saved browser session. The MCP tool does not launch the local browser.",
-        inputSchema: browserSessionSchema,
-        annotations: readOnly,
-      },
-      {
-        name: "continue_chatgpt_browser_session",
-        description:
-          "Create a follow-up ChatGPT browser consult record linked to an existing session.",
-        inputSchema: {
-          type: "object",
-          properties: {
-            sessionId: { type: "string" },
-            prompt: { type: "string" },
-            dryRun: { type: "boolean" },
-          },
-          required: ["sessionId", "prompt"],
-          additionalProperties: false,
-        },
-        annotations: {
-          readOnlyHint: false,
-          openWorldHint: true,
-          destructiveHint: false,
-        },
-      },
-    );
-  }
-  return tools;
-}
-
-export function controllerExpectedToolNames(
-  policy: McpPolicy,
-  opts: { enableChatgptBrowser?: boolean } = {},
-): string[] {
-  const names = buildMcpToolDefinitions(policy, opts).map((tool) => tool.name);
-  if (policy.profile !== "controller") return names;
-  // The Connector readiness expectation must match the bounded default schema
-  // served by toolset.ts. Full compatibility tools are intentionally omitted.
-  return [...DEFAULT_CONTROLLER_TOOL_NAMES];
-}
-
-const RETIRED_LEGACY_MUTATION_TOOLS = new Set([
+const RETIRED_LEGACY_PUBLIC_TOOLS = new Set([
+  "list_issues",
+  "get_project_board",
+  "get_project_governance",
   "reconcile_project_governance",
+  "get_project_state",
   "set_current_issue",
   "archive_issue",
   "restore_issue",
+  "get_issue",
   "publish_issue_to_github",
   "refresh_github_issue",
   "close_github_issue",
+  "inspect_issue_readiness",
+  "inspect_task_readiness",
   "prepare_issue_launch",
   "create_issue",
+  "update_issue",
   "plan_issue",
   "append_task",
   "split_task",
   "supersede_task",
   "set_task_dependencies",
   "update_task",
+  "dispatch_task",
+  "launch_issue",
+  "dispatch_ready_tasks",
+  "get_task_run",
+  "get_task_run_events",
+  "get_task_run_log",
+  "get_task_diff",
+  "integrate_task_run",
+  "finish_task_run",
+  "list_task_runs",
+  "cancel_task_run",
+  "retry_task_run",
+  "verify_task",
+  "accept_task",
+  "request_task_changes",
   "record_task_verification",
   "accept_verified_task",
+  "finish_edit_session",
 ]);
 
 export async function callMcpTool(
@@ -2861,1617 +1478,651 @@ export async function callMcpTool(
   args: Record<string, unknown> = {},
 ): Promise<CallToolResult> {
   try {
-    if (RETIRED_LEGACY_MUTATION_TOOLS.has(name) && legacyIssueAuthorityRetired(ctx.repoRoot)) {
+    if (RETIRED_LEGACY_PUBLIC_TOOLS.has(name)) {
       audit(ctx, name, "blocked", args);
-      return errorResult(
-        "LEGACY_CONTROL_PLANE_MUTATION_RETIRED",
-        `${name} cannot mutate frozen Issue/Task/currentIssue/project-board compatibility files after SQLite cutover. Use Requirement, Plan and Work APIs.`,
-      );
+      return errorResult("UNKNOWN_TOOL", `unknown tool: ${name}`);
     }
     switch (name) {
       case "harness_status": {
         const roots = [
           "docs/spec.md",
-          "plans",
-          "tasks/current.md",
-          ".ai/harness/session",
-    ".ai/harness/controller/packets",
-    ".ai/harness/projections",
-          ".ai/harness/checks",
-        ];
-        audit(ctx, name, "ok", args);
-        return textResult({
-          repoRoot: ctx.repoRoot,
-          adopted: isForgeAdopted(ctx.repoRoot),
-          profile: ctx.policy.profile,
-          branch: currentGitBranch(ctx.repoRoot),
-          workflowRoots: roots.map((path) => ({
-            path,
-            exists: existsSync(join(ctx.repoRoot, path)),
-          })),
-        });
-      }
-      case "harness_doctor": {
-        const localConfig = existsSync(
-          join(ctx.repoRoot, ".forge", "mcp.local.json"),
-        );
-        const codexConfig = existsSync(
-          join(ctx.repoRoot, ".codex", "config.toml"),
-        );
-        audit(ctx, name, "ok", args);
-        return textResult({
-          status: isForgeAdopted(ctx.repoRoot)
-            ? "ready_local"
-            : "not_adopted",
-          repo: ctx.repoRoot,
-          profile: ctx.policy.profile,
-          mcp: {
-            localConfig,
-            policy: "builtin",
-            profile: ctx.policy.profile,
-            toolSurface:
-              ctx.policy.profile === "controller"
-                ? FORGE_TOOL_SURFACE
-                : `${ctx.policy.profile}-legacy-v1`,
-            toolCount: buildMcpToolDefinitions(ctx.policy, {
-              enableChatgptBrowser: ctx.enableChatgptBrowser === true,
-            }).length,
-            repositoryRead:
-              ctx.policy.profile === "controller"
-                ? "ordinary repository source and document files are readable; immutable secret and runtime paths remain denied"
-                : "workflow-scoped",
-            deniedPaths: ctx.policy.denyGlobs.length,
-            runner: {
-              enabled: ctx.policy.execution.agentRunner,
-              defaultTimeoutMs: ctx.policy.execution.runnerTimeoutMs,
-              maxTimeoutMs: ctx.policy.execution.runnerMaxTimeoutMs,
-            },
-          },
-          codex: {
-            configured: codexConfig,
-            fix: codexConfig
-              ? null
-              : "forge mcp setup codex --repo . --scope project",
-          },
-          chatgpt: {
-            localEndpoint: "http://127.0.0.1:8765/mcp",
-            manualStepsRequired: true,
-            guide: "docs/forge-chatgpt-mcp-setup.md",
-          },
-        });
-      }
-      case "controller_capabilities": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "controller_capabilities requires the controller profile",
-          );
-        const expectedTools = controllerExpectedToolNames(ctx.policy, {
-          enableChatgptBrowser: ctx.enableChatgptBrowser === true,
-        });
-        const preferredTools: string[] = [...PREFERRED_FACADE_TOOL_NAMES];
-        const capabilityDescriptors = listCapabilityDescriptors();
-        const connectorSnapshot = Array.isArray(args.connector_tool_names)
-          ? args.connector_tool_names.map(String)
-          : Array.isArray(args.connectorToolNames)
-            ? args.connectorToolNames.map(String)
-            : undefined;
-        const connectorFreshness = await buildLocalConnectorStatusForRepo({
-          repoRoot: ctx.repoRoot,
-          expectedTools,
-          connectorToolNames: connectorSnapshot,
-        });
-        // staleConnector only when ChatGPT snapshot is supplied and missing rh_*.
-        const missingFacadeTools = connectorFreshness.missingConnectorTools;
-        const staleConnector = connectorFreshness.status === "chatgpt_snapshot_missing_facade";
-        const payload = {
-          schemaVersion: FORGE_MCP_SCHEMA_VERSION,
-          toolSurface: FORGE_TOOL_SURFACE,
-          version: FORGE_VERSION,
-          toolSurfaceFingerprint: forgeToolSurfaceFingerprint(expectedTools),
-          executionModel: "chatgpt-controller-execution-bridge",
-          profile: ctx.policy.profile,
-          capabilities: {
-            repositoryInspection: true,
-            issueLauncher: true,
-            githubIssuesAndProjects: true,
-            localAgentRuns: ctx.policy.execution.agentRunner,
-            githubCopilotSessions: true,
-            dynamicTaskGraph: true,
-            runtimeAgentSelection: true,
-            taskAgentBinding: false,
-            structuredRunEvents: true,
-            boundedDirectEdits: true,
-            multiRevisionDirectEdits: true,
-            editSavepoints: true,
-            partialEditRollback: true,
-            directEditFirstRouting: true,
-            persistedEditDiffs: true,
-            verifiedEditFinalization: true,
-            verificationGate: true,
-            localRunWatch: true,
-            localVisualController: true,
-            hierarchicalControllerUI: true,
-            localApprovalQueue: false,
-            localRiskApprovalGate: false,
-            quickAgentSessions: true,
-            persistentTimeouts: true,
-            timeoutProgress: true,
-            connectorSchemaDiagnostics: true,
-            projectProgressAggregation: true,
-            effectiveTaskStatus: true,
-            unifiedWorklogTimeline: true,
-            exportableWorklogReports: true,
-            githubPluginConfiguration: true,
-            serverSentEventDashboard: true,
-            singleExecutionFocus: false,
-            taskLocalReadiness: true,
-            riskAdaptiveVerification: true,
-            ephemeralQuickAgentSessions: true,
-            automaticRunContinuation: true,
-            reportedCommandEvidence: true,
-            governanceDiagnostics: true,
-            safeGovernanceReconciliation: true,
-            evidenceGateProgress: true,
-            directTaskActions: true,
-            issueArchiving: true,
-            retryableRunFailures: true,
-            issueCreationGuardrails: true,
-            persistedCheckEvidence: true,
-            persistedCheckReuse: true,
-            directVerification: true,
-            controllerContextAggregation: true,
-            taskLedgerProjection: true,
-            assistantPluginRuntime: true,
-            chatgptFacadeTools: true,
-            goalWorkloop: true,
-            handoffInbox: true,
-            codexGrokDelegation: true,
-            selfHealingRepair: true,
-          },
-          runner: {
-            enabled: ctx.policy.execution.agentRunner,
-            allowedAgents: ctx.policy.execution.allowedAgents,
-            defaultTimeoutMs: ctx.policy.execution.runnerTimeoutMs,
-            defaultTimeout: formatDurationMs(
-              ctx.policy.execution.runnerTimeoutMs,
-            ),
-            maxTimeoutMs: ctx.policy.execution.runnerMaxTimeoutMs,
-            maxTimeout: formatDurationMs(
-              ctx.policy.execution.runnerMaxTimeoutMs,
-            ),
-            note: "Requested timeout values are validated explicitly and are never silently reduced to the default.",
-          },
-          preferredTools,
-          capabilityGroups: summarizeCapabilityGroups(),
-          toolArchitecture: {
-            facadeTools: preferredTools,
-            atomicTypedToolsRetained: true,
-            internalHandlersRetained: true,
-            domainSchemaLoading: 'static_stable_surface',
-            dynamicDomainSchemaLoadingSupported: false,
-            capabilityDescriptorCount: capabilityDescriptors.length,
-          },
-          toolExposure: {
-            preferred: preferredTools,
-            note: "Prefer the five rh_* workflow facades for orchestration. Typed repository, Git, Issue/Task, plugin, browser, iOS, artifact, and recovery tools remain available because the current MCP transport cannot load domain schemas per conversation.",
-            advanced: expectedTools.filter((tool) => !preferredTools.includes(tool)).slice(0, 40),
-            compatibilityRetained: true,
-          },
-          expectedTools,
-          facadeToolsPresentInExpectedTools: preferredTools.every((tool: string) => expectedTools.includes(tool)),
-          staleConnector,
-          missingFacadeTools,
-          connectorFreshness: {
-            status: connectorFreshness.status,
-            severity: connectorFreshness.severity,
-            summary: connectorFreshness.summary,
-            missingLocalTools: connectorFreshness.missingLocalTools,
-            missingConnectorTools: connectorFreshness.missingConnectorTools,
-            expectedFacadeTools: connectorFreshness.expectedFacadeTools,
-            restartRecommended: connectorFreshness.restartRecommended,
-            reconnectRecommended: connectorFreshness.reconnectRecommended,
-            suggestedActions: connectorFreshness.suggestedActions,
-          },
-          docs: [
-            "docs/architecture/current/README.md",
-            "docs/architecture/history.md",
-            "docs/operations/controller-reliability-runbook.md",
-            "docs/forge-github-issue-launcher.md",
-            "docs/forge-chatgpt-mcp-setup.md",
-          ],
-          staleConnectorHint: staleConnector
-            ? `Stale ChatGPT connector tool snapshot is missing facade tools: ${missingFacadeTools.join(", ")}. Refresh/reconnect MCP so tools/list reloads rh_status, rh_inbox, rh_context, and rh_work.`
-            : connectorFreshness.status === "unable_to_verify_chatgpt_snapshot"
-              ? `Local MCP tool surface includes preferred facade tools. ChatGPT connector snapshot was not supplied, so freshness cannot be verified from this call. If ChatGPT tools/list is missing rh_status/rh_inbox/rh_context/rh_work, reconnect MCP. Pass connector_tool_names for an exact check.`
-              : connectorFreshness.status === "stale_fingerprint"
-                ? `Local MCP process fingerprint/version may be stale. Restart controller/MCP, then reconnect ChatGPT if rh_* are still missing.`
-                : connectorFreshness.status === "local_mcp_missing_facade"
-                  ? `Local MCP tool surface is missing facade tools: ${connectorFreshness.missingLocalTools.join(", ")}. Restart controller/MCP.`
-                  : `Connector clients must match ${FORGE_TOOL_SURFACE} version ${FORGE_VERSION} / schema ${FORGE_MCP_SCHEMA_VERSION}. Prefer rh_status/rh_inbox/rh_context/rh_work. Pass connector_tool_names to detect a stale ChatGPT tool snapshot precisely.`,
-        };
-        audit(ctx, name, "ok", args);
-        return textResult(payload);
-      }
-      case "local_bridge_status": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "local_bridge_status requires the controller profile",
-          );
-        const detailLevel = args.detail_level === "detail" || args.detail === true
-          ? "detail"
-          : "summary";
-        const controllerHome = resolveRepoPreferredControllerHome(ctx.repoRoot);
-        const surface = resolveLocalBridgeSurface({
-          controllerHome,
-          repoRoot: ctx.repoRoot,
-          allowProcessScan: detailLevel === "detail",
-        });
-        const jobs = listLocalBridgeJobs(ctx.repoRoot, detailLevel === "detail" ? 12 : 20);
-        const { activeJobCount, recentJobSummary } = summarizeRecentJobs(jobs);
-        // Prefer authoritative surface; never invent a legacy 8766 endpoint.
-        const endpoint = surface.endpoint ?? null;
-        const running = surface.enabled
-          && (surface.processRunning === true
-            || (surface.endpointConfigured && surface.mode === "embedded"));
-        if (detailLevel === "summary") {
-          const payload = {
-            detailLevel: "summary",
-            repoId: ctx.repoId,
-            running,
-            ready: surface.enabled ? (surface.processRunning !== false) : true,
-            health: surface.enabled
-              ? (surface.processRunning === true || surface.mode === "embedded" ? "ready" : "warning")
-              : "disabled",
-            mode: surface.mode,
-            endpoint,
-            endpointConfigured: surface.endpointConfigured,
-            endpointReachable: null as boolean | null,
-            processRunning: surface.processRunning ?? null,
-            expectedSurface: surface.expectedSurface,
-            requiredForReadiness: surface.requiredForReadiness,
-            warnings: surface.error && surface.requiredForReadiness
-              ? [{ code: "LOCAL_BRIDGE_ERROR", message: surface.error.slice(0, 300) }]
-              : [],
-            activeJobCount,
-            recentJobSummary,
-            statusSource: surface.source,
-            nonBlocking: !surface.requiredForReadiness,
-            approvalQueue: false,
-          };
-          audit(ctx, name, "ok", args);
-          return textResult(payload);
-        }
-        const reconciliation = reconcileLocalBridgeJobs(ctx.repoRoot);
-        const payload = {
-          detailLevel: "detail",
-          endpoint,
-          endpointConfigured: surface.endpointConfigured,
-          running,
-          error: surface.error,
-          mode: surface.mode,
-          requiredForReadiness: surface.requiredForReadiness,
-          statusSource: surface.source,
-          counts: recentJobSummary,
-          activeJobCount,
-          recentJobSummary,
-          approvalQueue: false,
-          reconciliation,
-          recentJobs: jobs.map((job) => ({
-            jobId: job.jobId,
-            action: job.action,
-            status: job.status,
-            checkId: job.action === "run-check" ? (job.payload as { checkId?: string }).checkId : undefined,
-            runId: job.runId,
-            issueId: job.issueId,
-            taskId: job.taskId,
-            createdAt: job.createdAt,
-            updatedAt: job.updatedAt,
-            finishedAt: job.finishedAt,
-            revision: job.revision,
-            deadlineAt: job.deadlineAt,
-            error: job.error?.slice(0, 300),
-          })),
-          nonBlocking: !surface.requiredForReadiness,
-          fallback:
-            "Open the localhost Local Controller to launch work or inspect execution when a ChatGPT write action is unavailable.",
-        };
-        audit(ctx, name, "ok", args);
-        return textResult(payload);
-      }
-      case "controller_context": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "controller_context requires the controller profile",
-          );
-        const controllerHome = resolveRepoPreferredControllerHome(ctx.repoRoot);
-        const requirementBoard = buildRequirementBoard({ controllerHome, repoId: ctx.repoId });
-        const executionDiagnostics = buildExecutionDiagnostics({
-          controllerHome,
-          repoId: ctx.repoId,
-          detailLevel: "detail",
-        });
-        const runs = listAgentJobs(ctx.repoRoot, 8);
-        const reconciliation = reconcileLocalBridgeJobs(ctx.repoRoot);
-        const jobs = listLocalBridgeJobs(ctx.repoRoot, 8);
-        const checks = listControllerChecks(ctx.repoRoot).map((check) => ({
-          id: check.id,
-          description: check.description,
-          timeoutMs: check.timeoutMs,
-          source: check.source,
-        }));
-        const assessment = assessWorkMode({
-          description: typeof args.description === "string" && args.description.trim()
-            ? String(args.description)
-            : "Inspect the selected repository context.",
-          knownPaths: stringList(args.known_paths),
-          expectedFiles: typeof args.expected_files === "number" ? args.expected_files : undefined,
-          expectedChangedLines: typeof args.expected_changed_lines === "number" ? args.expected_changed_lines : undefined,
-          requiresInvestigation: args.requires_investigation === true,
-          requiresParallelism: args.requires_parallelism === true,
-          requiresLongRunningChecks: args.requires_long_running_checks === true,
-          needsDependencies: args.needs_dependencies === true,
-          risk: typeof args.risk === "string" ? args.risk as TaskRisk : undefined,
-          explicitMode: parseExplicitTaskMode(args.mode)
-            ?? (typeof args.description === "string" && args.description.trim() ? undefined : "direct"),
-        });
-        const modeContextPack = assessment.modeBehavior.structuralContext === "required"
-          ? buildControllerContextPack(ctx.repoRoot, ctx.policy, {
-              description: typeof args.description === "string" ? args.description : undefined,
-              knownPaths: stringList(args.known_paths),
-              structuralContext: "required",
-              maxFiles: 8,
-              maxSnippets: 20,
-            })
-          : undefined;
-        const payload = {
-          git: gitSnapshot(ctx.repoRoot),
-          requirementBoard,
-          executionDiagnostics,
-          legacyCompatibility: {
-            currentIssue: "deprecated_frozen",
-            issueTaskBoard: "deprecated_frozen",
-            authority: "controller-home-sqlite",
-          },
-          activeRuns: runs.map((run) => ({
-            runId: run.runId,
-            issueId: run.issueId,
-            taskId: run.taskId,
-            status: run.status,
-            agent: run.agent,
-            provider: run.provider,
-            executionMode: run.executionMode,
-            progress: run.progress,
-            lastHeartbeatAt: run.lastHeartbeatAt,
-            error: run.error?.slice(0, 300),
-          })),
-          localBridge: {
-            reconciliation,
-            recentJobs: jobs.map((job) => ({
-              jobId: job.jobId,
-              action: job.action,
-              status: job.status,
-              checkId: job.action === "run-check" ? (job.payload as { checkId?: string }).checkId : undefined,
-              issueId: job.issueId,
-              taskId: job.taskId,
-              updatedAt: job.updatedAt,
-            })),
-          },
-          checks,
-          recommendedExecution: assessment,
-          ...(modeContextPack ? { modeContextPack } : {}),
-        };
-        audit(ctx, name, "ok", args);
-        return textResult(payload);
-      }
-      case "quick_agent_session":
-      case "submit_local_job": {
-        if (ctx.policy.profile !== "controller") {
-          return errorResult("TOOL_DISABLED", `${name} requires the controller profile`);
-        }
-        audit(ctx, name, "blocked", args);
-        return errorResult(
-          name === "quick_agent_session" ? "AGENT_RUN_DEPRECATED" : "LOCAL_BRIDGE_JOB_RETIRED",
-          "Kernel-managed Agent and Local Bridge Jobs are retired. Create or claim WorkContract and use Process Runtime or the Thin Launcher.",
-        );
-      }
-      case "list_local_jobs": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "list_local_jobs requires the controller profile",
-          );
-        const limit = typeof args.limit === "number" ? args.limit : 50;
-        const jobs = listLocalBridgeJobs(ctx.repoRoot, limit);
-        audit(ctx, name, "ok", args);
-        return textResult({ jobs });
-      }
-      case "get_local_job": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "get_local_job requires the controller profile",
-          );
-        const jobId = String(args.job_id ?? "").trim();
-        const includeEvents = args.include_events === true;
-        const includeOutput = args.include_output === true;
-        const snapshot = getLocalBridgeJobSnapshot(ctx.repoRoot, jobId);
-        const payload = {
-          job: snapshot.job,
-          ...(snapshot.status !== "ok" ? { lookup: snapshot } : {}),
-          ...(includeEvents && snapshot.status === "ok" ? { events: getLocalBridgeJobEvents(ctx.repoRoot, jobId) } : {}),
-          ...(includeOutput
-            ? {
-                output: readLocalBridgeJobOutput(ctx.repoRoot, jobId, {
-                  stream: args.stream === "stderr" ? "stderr" : "stdout",
-                  maxBytes: typeof args.max_bytes === "number" ? args.max_bytes : undefined,
-                }),
-              }
-            : {}),
-        };
-        audit(ctx, name, "ok", args);
-        return textResult(payload);
-      }
-      case "get_local_job_output": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "get_local_job_output requires the controller profile",
-          );
-        const jobId = String(args.job_id ?? "").trim();
-        const payload = readLocalBridgeJobOutput(ctx.repoRoot, jobId, {
-          stream: args.stream === "stderr" ? "stderr" : "stdout",
-          maxBytes: typeof args.max_bytes === "number" ? args.max_bytes : undefined,
-        });
-        audit(ctx, name, "ok", args);
-        return textResult(payload);
-      }
-      case "project_snapshot": {
-        if (ctx.policy.profile !== "controller") return errorResult("TOOL_DISABLED", "project_snapshot requires the controller profile");
-        const markerPaths = [
-          ".ai/harness/active-plan",
-          ".ai/harness/active-sprint",
-          ".ai/harness/active-worktree",
-          "tasks/current.md",
-        ];
-        const markers = markerPaths.map((path) => {
-          const absolute = join(ctx.repoRoot, path);
-          if (!existsSync(absolute)) return { path, exists: false };
-          const raw = readFileSync(absolute, "utf-8");
-          return {
-            path,
-            exists: true,
-            bytes: Buffer.byteLength(raw),
-            lines: raw.split(/\r?\n/).length,
-            sha256: createHash("sha256").update(raw).digest("hex").slice(0, 16),
-            preview: redactMcpText(raw).text.slice(0, 400),
-          };
-        });
-        const controllerHome = resolveRepoPreferredControllerHome(ctx.repoRoot);
-        const requirementBoard = buildRequirementBoard({ controllerHome, repoId: ctx.repoId });
-        const executionDiagnostics = buildExecutionDiagnostics({
-          controllerHome,
-          repoId: ctx.repoId,
-          detailLevel: "detail",
-        });
-        const snapshotRuns = listAgentJobs(ctx.repoRoot, 11);
-        const runs = snapshotRuns.slice(0, 10).map((run) => ({
-          runId: run.runId,
-          issueId: run.issueId,
-          taskId: run.taskId,
-          agent: run.agent,
-          provider: run.provider,
-          executionMode: run.executionMode,
-          status: run.status,
-          progress: run.progress,
-          createdAt: run.createdAt,
-          finishedAt: run.finishedAt,
-          error: run.error?.slice(0, 300),
-        }));
-        const payload = {
-          git: gitSnapshot(ctx.repoRoot),
-          requirementBoard,
-          executionDiagnostics,
-          legacyCompatibility: {
-            currentIssue: "deprecated_frozen",
-            issueTaskBoard: "deprecated_frozen",
-            authority: "controller-home-sqlite",
-          },
-          runs,
-          markers,
-          truncated: {
-            runs: snapshotRuns.length > 10,
-          },
-        };
-        audit(ctx, name, "ok", args);
-        return textResult(payload);
-      }
-      case "search_repository": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "search_repository requires the controller profile",
-          );
-        const session = ctx.sessionId && ctx.repoId
-          ? {
-            sessionId: ctx.sessionId,
-            repoId: ctx.repoId,
-            checkoutId: ctx.checkoutId ?? ctx.repoId,
-          }
-          : undefined;
-        const result = searchRepository(ctx.repoRoot, ctx.policy, {
-          query: String(args.query ?? ""),
-          includeGlobs: stringList(args.include_globs),
-          excludeGlobs: stringList(args.exclude_globs),
-          maxResults:
-            typeof args.max_results === "number" ? args.max_results : undefined,
-          maxFiles:
-            typeof args.max_files === "number" ? args.max_files : undefined,
-          caseSensitive: args.case_sensitive === true,
-          session,
-        });
-        audit(ctx, name, "ok", args);
-        return textResult(result);
-      }
-      case "get_git_diff": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "get_git_diff requires the controller profile",
-          );
-        const path =
-          typeof args.path === "string" && args.path.trim()
-            ? args.path.trim()
-            : undefined;
-        if (path) {
-          const decision = resolveMcpPath(
-            ctx.repoRoot,
-            path,
-            ctx.policy,
-            "read",
-          );
-          if (!decision.ok)
-            return errorResult(
-              "POLICY_DENIED",
-              decision.reason ?? "path denied",
-              { path },
-            );
-        }
-        const maxBytes =
-          typeof args.max_bytes === "number"
-            ? Math.min(Math.max(Math.trunc(args.max_bytes), 1024), 512 * 1024)
-            : 128 * 1024;
-        const result = gitDiff(ctx.repoRoot, path, maxBytes);
-        const redacted = redactMcpText(result.diff);
-        audit(ctx, name, "ok", args, path);
-        return textResult({
-          ...result,
-          diff: redacted.text,
-          redactions: redacted.redactions,
-        });
-      }
-      case "list_checks": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "list_checks requires the controller profile",
-          );
-        const checks = listControllerChecks(ctx.repoRoot);
-        audit(ctx, name, "ok", args);
-        return textResult({ checks });
-      }
-      case "list_issues": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "list_issues requires the controller profile",
-          );
-        const projectState = loadControllerProjectState(ctx.repoRoot);
-        const issues = listIssueEffectiveViews(ctx.repoRoot).map((issue) => {
-          const readiness = inspectIssueReadiness(ctx.repoRoot, issue.id);
-          return {
-          id: issue.id,
-          title: issue.title,
-          kind: issue.kind,
-          status: issue.status,
-          lifecycleStatus: issue.lifecycleStatus,
-          archivedAt: issue.archivedAt,
-          isCurrent: projectState.currentIssueId === issue.id,
-          updatedAt: issue.updatedAt,
-          taskCount: issue.tasks.length,
-          taskCounts: issue.tasks.reduce<Record<string, number>>((counts, task) => {
-            counts[task.effectiveStatus] = (counts[task.effectiveStatus] ?? 0) + 1;
-            return counts;
-          }, {}),
-          declaredTaskCounts: issue.tasks.reduce<Record<string, number>>((counts, task) => {
-            counts[task.declaredStatus] = (counts[task.declaredStatus] ?? 0) + 1;
-            return counts;
-          }, {}),
-          readyTaskIds: readiness.readyTaskIds,
-          queueableTaskIds: readiness.queueableTaskIds,
-          approvalPendingTaskIds: readiness.approvalPendingTaskIds,
-        };
-        });
-        audit(ctx, name, "ok", args);
-        return textResult({ issues });
-      }
-      case "get_project_board": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "get_project_board requires the controller profile",
-          );
-        const startedAt = performance.now();
-        const controllerHome = resolveRepoPreferredControllerHome(ctx.repoRoot);
-        const detailLevel = args.detail_level === "full" ? "full" : args.detail_level === "detail" ? "detail" : "summary";
-        const payload = detailLevel === "summary"
-          ? buildRequirementBoard({ controllerHome, repoId: ctx.repoId })
-          : buildExecutionDiagnostics({
-              controllerHome,
-              repoId: ctx.repoId,
-              detailLevel,
-              requirementId: typeof args.requirement_id === "string" ? args.requirement_id : undefined,
-            });
-        audit(ctx, name, "ok", args);
-        const response = {
-          ...payload,
-          responseMeta: {
-            serverDurationMs: Number((performance.now() - startedAt).toFixed(2)),
-            structuredPayloadBytes: 0,
-          },
-        };
-        response.responseMeta.structuredPayloadBytes = Buffer.byteLength(JSON.stringify(response), "utf8");
-        return textResult(response);
-      }
-      case "get_project_progress": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult("TOOL_DISABLED", "get_project_progress requires the controller profile");
-        const progress = getProjectProgress(ctx.repoRoot);
-        audit(ctx, name, "ok", args);
-        return textResult(progress);
-      }
-      case "get_project_governance": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult("TOOL_DISABLED", "get_project_governance requires the controller profile");
-        const governance = inspectProjectGovernance(ctx.repoRoot);
-        audit(ctx, name, "ok", args);
-        return textResult(governance);
-      }
-      case "reconcile_project_governance": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult("TOOL_DISABLED", "reconcile_project_governance requires the controller profile");
-        const result = reconcileProjectGovernance(ctx.repoRoot);
-        audit(ctx, name, "ok", args, ".ai/harness/controller/project-state.json");
-        return textResult(result);
-      }
-      case "get_project_state": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult("TOOL_DISABLED", "get_project_state requires the controller profile");
-        const state = loadControllerProjectState(ctx.repoRoot);
-        audit(ctx, name, "ok", args);
-        return textResult(state);
-      }
-      case "set_current_issue": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult("TOOL_DISABLED", "set_current_issue requires the controller profile");
-        const issue = getIssue(ctx.repoRoot, String(args.issue_id ?? ""));
-        if (issue.archivedAt || ["done", "cancelled"].includes(issue.status))
-          return errorResult("ISSUE_NOT_ACTIVE", `only an active, non-archived Issue can be selected (current: ${issue.status})`);
-        const state = saveControllerProjectState(ctx.repoRoot, { currentIssueId: issue.id }, "chatgpt-controller");
-        audit(ctx, name, "ok", args, ".ai/harness/controller/project-state.json");
-        return textResult(state);
-      }
-      case "archive_issue": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult("TOOL_DISABLED", "archive_issue requires the controller profile");
-        const issue = archiveIssue(ctx.repoRoot, String(args.issue_id ?? ""));
-        audit(ctx, name, "ok", args, `tasks/issues/${issue.id}`);
-        return textResult(projectIssueEffectiveView(ctx.repoRoot, issue));
-      }
-      case "restore_issue": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult("TOOL_DISABLED", "restore_issue requires the controller profile");
-        const issue = restoreIssue(ctx.repoRoot, String(args.issue_id ?? ""));
-        audit(ctx, name, "ok", args, `tasks/issues/${issue.id}`);
-        return textResult(projectIssueEffectiveView(ctx.repoRoot, issue));
-      }
-      case "get_task_progress_detail": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult("TOOL_DISABLED", "get_task_progress_detail requires the controller profile");
-        const result = getTaskProgressReadView(
-          ctx.repoRoot,
-          String(args.issue_id ?? ""),
-          String(args.task_id ?? ""),
-          args.detail_level === "full" ? "full" : "summary",
-        );
-        audit(ctx, name, "ok", args, `tasks/issues/${result.issue.id}`);
-        return textResult(result);
-      }
-      case "get_worklog_timeline": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult("TOOL_DISABLED", "get_worklog_timeline requires the controller profile");
-        const events = getControllerTimeline(ctx.repoRoot, {
-          category: parseWorklogCategory(args.category),
-          issueId: typeof args.issue_id === "string" ? args.issue_id : undefined,
-          taskId: typeof args.task_id === "string" ? args.task_id : undefined,
-          runId: typeof args.run_id === "string" ? args.run_id : undefined,
-          editSessionId: typeof args.edit_session_id === "string" ? args.edit_session_id : undefined,
-          since: typeof args.since === "string" ? args.since : undefined,
-          until: typeof args.until === "string" ? args.until : undefined,
-          limit: typeof args.limit === "number" ? Math.trunc(args.limit) : undefined,
-        });
-        audit(ctx, name, "ok", args);
-        return textResult({ events });
-      }
-      case "export_worklog": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult("TOOL_DISABLED", "export_worklog requires the controller profile");
-        const result = exportControllerWorklog(ctx.repoRoot, {
-          format: args.format === "json" ? "json" : "markdown",
-          outputPath: typeof args.output_path === "string" ? args.output_path : undefined,
-          filter: {
-            issueId: typeof args.issue_id === "string" ? args.issue_id : undefined,
-            taskId: typeof args.task_id === "string" ? args.task_id : undefined,
-            runId: typeof args.run_id === "string" ? args.run_id : undefined,
-            editSessionId: typeof args.edit_session_id === "string" ? args.edit_session_id : undefined,
-          },
-        });
-        audit(ctx, name, "ok", args, result.path);
-        return textResult(result);
-      }
-      case "get_github_plugin_status": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult("TOOL_DISABLED", "get_github_plugin_status requires the controller profile");
-        const status = getGitHubPluginStatus(ctx.repoRoot);
-        audit(ctx, name, "ok", args, status.repository);
-        return textResult(status);
-      }
-      case "configure_github_plugin": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult("TOOL_DISABLED", "configure_github_plugin requires the controller profile");
-        const config = saveGitHubPluginConfig(ctx.repoRoot, {
-          enabled: typeof args.enabled === "boolean" ? args.enabled : undefined,
-          repository: args.clear_repository === true ? "" : typeof args.repository === "string" ? args.repository : undefined,
-          syncMode: args.sync_mode === "checkpoint" ? "checkpoint" : args.sync_mode === "manual" ? "manual" : undefined,
-          includeTasks: typeof args.include_tasks === "boolean" ? args.include_tasks : undefined,
-          projectOwner: args.clear_project === true ? "" : typeof args.project_owner === "string" ? args.project_owner : undefined,
-          projectNumber: args.clear_project === true ? null : typeof args.project_number === "number" ? args.project_number : undefined,
+          "plans",
+          "tasks/current.md",
+          ".ai/harness/session",
+    ".ai/harness/controller/packets",
+    ".ai/harness/projections",
+          ".ai/harness/checks",
+        ];
+        audit(ctx, name, "ok", args);
+        return textResult({
+          repoRoot: ctx.repoRoot,
+          adopted: isForgeAdopted(ctx.repoRoot),
+          profile: ctx.policy.profile,
+          branch: currentGitBranch(ctx.repoRoot),
+          workflowRoots: roots.map((path) => ({
+            path,
+            exists: existsSync(join(ctx.repoRoot, path)),
+          })),
         });
-        audit(ctx, name, "ok", args, "repository-registry:github");
-        return textResult(config);
-      }
-      case "get_issue": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "get_issue requires the controller profile",
-          );
-        const issue = getIssueReadView(
-          ctx.repoRoot,
-          String(args.issue_id ?? ""),
-          args.detail_level === "full" ? "full" : "summary",
-        );
-        audit(ctx, name, "ok", args, `tasks/issues/${issue.id}`);
-        return textResult(issue);
-      }
-      case "github_status": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "github_status requires the controller profile",
-          );
-        const status = getGitHubStatus(
-          ctx.repoRoot,
-          typeof args.repo === "string" ? args.repo : undefined,
-        );
-        audit(
-          ctx,
-          name,
-          status.available && status.authenticated ? "ok" : "failed",
-          args,
-          status.repository?.nameWithOwner,
-          status.errors.join("; "),
-        );
-        return textResult(status);
       }
-      case "publish_issue_to_github": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "publish_issue_to_github requires the controller profile",
-          );
-        const issue = publishIssueToGitHub(
-          ctx.repoRoot,
-          String(args.issue_id ?? ""),
-          {
-            repo: typeof args.repo === "string" ? args.repo : undefined,
-            labels: stringList(args.labels),
-            includeTasks: args.include_tasks === true,
-            projectOwner:
-              typeof args.project_owner === "string"
-                ? args.project_owner
-                : undefined,
-            projectNumber:
-              typeof args.project_number === "number"
-                ? Math.trunc(args.project_number)
-                : undefined,
-          },
+      case "harness_doctor": {
+        const localConfig = existsSync(
+          join(ctx.repoRoot, ".forge", "mcp.local.json"),
         );
-        audit(ctx, name, "ok", args, issue.github?.url);
-        return textResult(projectIssueEffectiveView(ctx.repoRoot, issue));
-      }
-      case "refresh_github_issue": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "refresh_github_issue requires the controller profile",
-          );
-        const result = refreshGitHubIssue(
-          ctx.repoRoot,
-          String(args.issue_id ?? ""),
+        const codexConfig = existsSync(
+          join(ctx.repoRoot, ".codex", "config.toml"),
         );
-        audit(ctx, name, "ok", args, result.issue.github?.url);
+        audit(ctx, name, "ok", args);
         return textResult({
-          ...result,
-          issue: projectIssueEffectiveView(ctx.repoRoot, result.issue),
+          status: isForgeAdopted(ctx.repoRoot)
+            ? "ready_local"
+            : "not_adopted",
+          repo: ctx.repoRoot,
+          profile: ctx.policy.profile,
+          mcp: {
+            localConfig,
+            policy: "builtin",
+            profile: ctx.policy.profile,
+            toolSurface:
+              ctx.policy.profile === "controller"
+                ? FORGE_TOOL_SURFACE
+                : `${ctx.policy.profile}-legacy-v1`,
+            toolCount: buildMcpToolDefinitions(ctx.policy, {
+              enableChatgptBrowser: ctx.enableChatgptBrowser === true,
+            }).length,
+            repositoryRead:
+              ctx.policy.profile === "controller"
+                ? "ordinary repository source and document files are readable; immutable secret and runtime paths remain denied"
+                : "workflow-scoped",
+            deniedPaths: ctx.policy.denyGlobs.length,
+            runner: {
+              enabled: ctx.policy.execution.agentRunner,
+              defaultTimeoutMs: ctx.policy.execution.runnerTimeoutMs,
+              maxTimeoutMs: ctx.policy.execution.runnerMaxTimeoutMs,
+            },
+          },
+          codex: {
+            configured: codexConfig,
+            fix: codexConfig
+              ? null
+              : "forge mcp setup codex --repo . --scope project",
+          },
+          chatgpt: {
+            localEndpoint: "http://127.0.0.1:8765/mcp",
+            manualStepsRequired: true,
+            guide: "docs/forge-chatgpt-mcp-setup.md",
+          },
         });
       }
-      case "close_github_issue": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "close_github_issue requires the controller profile",
-          );
-        const issue = closeGitHubIssue(
-          ctx.repoRoot,
-          String(args.issue_id ?? ""),
-        );
-        audit(ctx, name, "ok", args, issue.github?.url);
-        return textResult(projectIssueEffectiveView(ctx.repoRoot, issue));
-      }
-      case "inspect_issue_readiness": {
+      case "controller_capabilities": {
         if (ctx.policy.profile !== "controller")
           return errorResult(
             "TOOL_DISABLED",
-            "inspect_issue_readiness requires the controller profile",
+            "controller_capabilities requires the controller profile",
           );
-        const readiness = inspectIssueReadiness(
-          ctx.repoRoot,
-          String(args.issue_id ?? ""),
-        );
-        audit(
-          ctx,
-          name,
-          readiness.ready ? "ok" : "blocked",
-          args,
-          `tasks/issues/${readiness.issueId}`,
-          [...readiness.blockers, ...readiness.taskBlockers].map((item) => item.message).join("; "),
+        const expectedTools = ctx.publishedToolNames;
+        if (!expectedTools) return errorResult(
+          'MCP_TOOL_SURFACE_UNAVAILABLE',
+          'Controller capability diagnostics require the authoritative MCP registry projection.',
         );
-        return textResult(readiness);
-      }
-      case "inspect_task_readiness": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "inspect_task_readiness requires the controller profile",
-          );
-        const readiness = inspectTaskReadiness(
-          ctx.repoRoot,
-          String(args.issue_id ?? ""),
-          String(args.task_id ?? ""),
-          {
-            retryFromRunId: typeof args.retry_from_run_id === "string" ? args.retry_from_run_id : undefined,
-            approveDestructive: args.approve_destructive === true,
+        const preferredTools: string[] = [...PREFERRED_FACADE_TOOL_NAMES];
+        const capabilityDescriptors = listCapabilityDescriptors();
+        const connectorSnapshot = Array.isArray(args.connector_tool_names)
+          ? args.connector_tool_names.map(String)
+          : Array.isArray(args.connectorToolNames)
+            ? args.connectorToolNames.map(String)
+            : undefined;
+        const connectorFreshness = await buildLocalConnectorStatusForRepo({
+          repoRoot: ctx.repoRoot,
+          expectedTools,
+          connectorToolNames: connectorSnapshot,
+        });
+        // staleConnector only when ChatGPT snapshot is supplied and missing rh_*.
+        const missingFacadeTools = connectorFreshness.missingConnectorTools;
+        const staleConnector = connectorFreshness.status === "chatgpt_snapshot_missing_facade";
+        const payload = {
+          schemaVersion: FORGE_MCP_SCHEMA_VERSION,
+          toolSurface: FORGE_TOOL_SURFACE,
+          version: FORGE_VERSION,
+          toolSurfaceFingerprint: forgeToolSurfaceFingerprint(expectedTools),
+          executionModel: "chatgpt-controller-execution-bridge",
+          profile: ctx.policy.profile,
+          capabilities: {
+            repositoryInspection: true,
+            issueLauncher: true,
+            githubIssuesAndProjects: true,
+            localAgentRuns: ctx.policy.execution.agentRunner,
+            githubCopilotSessions: true,
+            dynamicTaskGraph: true,
+            runtimeAgentSelection: true,
+            taskAgentBinding: false,
+            structuredRunEvents: true,
+            boundedDirectEdits: true,
+            multiRevisionDirectEdits: true,
+            editSavepoints: true,
+            partialEditRollback: true,
+            directEditFirstRouting: true,
+            persistedEditDiffs: true,
+            verifiedEditFinalization: true,
+            verificationGate: true,
+            localRunWatch: true,
+            localVisualController: true,
+            hierarchicalControllerUI: true,
+            localApprovalQueue: false,
+            localRiskApprovalGate: false,
+            quickAgentSessions: true,
+            persistentTimeouts: true,
+            timeoutProgress: true,
+            connectorSchemaDiagnostics: true,
+            projectProgressAggregation: true,
+            effectiveTaskStatus: true,
+            unifiedWorklogTimeline: true,
+            exportableWorklogReports: true,
+            githubPluginConfiguration: true,
+            serverSentEventDashboard: true,
+            singleExecutionFocus: false,
+            taskLocalReadiness: true,
+            riskAdaptiveVerification: true,
+            ephemeralQuickAgentSessions: true,
+            automaticRunContinuation: true,
+            reportedCommandEvidence: true,
+            governanceDiagnostics: true,
+            safeGovernanceReconciliation: true,
+            evidenceGateProgress: true,
+            directTaskActions: true,
+            issueArchiving: true,
+            retryableRunFailures: true,
+            issueCreationGuardrails: true,
+            persistedCheckEvidence: true,
+            persistedCheckReuse: true,
+            directVerification: true,
+            controllerContextAggregation: true,
+            taskLedgerProjection: true,
+            assistantPluginRuntime: true,
+            chatgptFacadeTools: true,
+            goalWorkloop: true,
+            handoffInbox: true,
+            codexGrokDelegation: true,
+            selfHealingRepair: true,
           },
-        );
-        audit(
-          ctx,
-          name,
-          readiness.ready ? "ok" : "blocked",
-          args,
-          `tasks/issues/${readiness.issueId}`,
-          readiness.blockers.map((item) => item.message).join("; "),
-        );
-        return textResult(readiness);
-      }
-      case "prepare_issue_launch": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "prepare_issue_launch requires the controller profile",
-          );
-        const issueId = String(args.issue_id ?? "");
-        const issue = getIssue(ctx.repoRoot, issueId);
-        const readiness = inspectIssueReadiness(ctx.repoRoot, issueId);
-        const maxParallel = Math.min(
-          Math.max(
-            typeof args.max_parallel === "number"
-              ? Math.trunc(args.max_parallel)
-              : readiness.suggestedMaxParallel,
-            1,
-          ),
-          4,
-        );
-        const tasks = issue.tasks
-          .filter((task) => readiness.queueableTaskIds.includes(task.id))
-          .map((task) => ({
-            id: task.id,
-            title: task.title,
-            agent: task.recommendedAgent ?? "runtime-selected",
-            risk: task.risk,
-            allowedPaths: task.allowedPaths,
-            checks: task.checks,
-            acceptanceCriteria: task.acceptanceCriteria,
-            github: task.github,
-          }));
-        const preview = {
-          issue: {
-            id: issue.id,
-            title: issue.title,
-            status: issue.status,
-            github: issue.github,
+          runner: {
+            enabled: ctx.policy.execution.agentRunner,
+            allowedAgents: ctx.policy.execution.allowedAgents,
+            defaultTimeoutMs: ctx.policy.execution.runnerTimeoutMs,
+            defaultTimeout: formatDurationMs(
+              ctx.policy.execution.runnerTimeoutMs,
+            ),
+            maxTimeoutMs: ctx.policy.execution.runnerMaxTimeoutMs,
+            maxTimeout: formatDurationMs(
+              ctx.policy.execution.runnerMaxTimeoutMs,
+            ),
+            note: "Requested timeout values are validated explicitly and are never silently reduced to the default.",
+          },
+          preferredTools,
+          capabilityGroups: summarizeCapabilityGroups(),
+          toolArchitecture: {
+            facadeTools: preferredTools,
+            atomicTypedToolsRetained: true,
+            internalHandlersRetained: true,
+            domainSchemaLoading: 'static_stable_surface',
+            dynamicDomainSchemaLoadingSupported: false,
+            capabilityDescriptorCount: capabilityDescriptors.length,
+          },
+          toolExposure: {
+            preferred: preferredTools,
+            note: "Prefer the five rh_* workflow facades for orchestration. Typed repository, Git, Issue/Task, plugin, browser, iOS, artifact, and recovery tools remain available because the current MCP transport cannot load domain schemas per conversation.",
+            exposedToolCount: expectedTools.length,
+          },
+          expectedTools,
+          facadeToolsPresentInExpectedTools: preferredTools.every((tool: string) => expectedTools.includes(tool)),
+          staleConnector,
+          missingFacadeTools,
+          connectorFreshness: {
+            status: connectorFreshness.status,
+            severity: connectorFreshness.severity,
+            summary: connectorFreshness.summary,
+            missingLocalTools: connectorFreshness.missingLocalTools,
+            missingConnectorTools: connectorFreshness.missingConnectorTools,
+            expectedFacadeTools: connectorFreshness.expectedFacadeTools,
+            restartRecommended: connectorFreshness.restartRecommended,
+            reconnectRecommended: connectorFreshness.reconnectRecommended,
+            suggestedActions: connectorFreshness.suggestedActions,
           },
-          readiness,
-          maxParallel,
-          tasks,
+          docs: [
+            "docs/architecture/current/README.md",
+            "docs/architecture/history.md",
+            "docs/operations/controller-reliability-runbook.md",
+            "docs/forge-github-issue-launcher.md",
+            "docs/forge-chatgpt-mcp-setup.md",
+          ],
+          staleConnectorHint: staleConnector
+            ? `Stale ChatGPT connector tool snapshot is missing facade tools: ${missingFacadeTools.join(", ")}. Refresh/reconnect MCP so tools/list reloads rh_status, rh_inbox, rh_context, and rh_work.`
+            : connectorFreshness.status === "unable_to_verify_chatgpt_snapshot"
+              ? `Local MCP tool surface includes preferred facade tools. ChatGPT connector snapshot was not supplied, so freshness cannot be verified from this call. If ChatGPT tools/list is missing rh_status/rh_inbox/rh_context/rh_work, reconnect MCP. Pass connector_tool_names for an exact check.`
+              : connectorFreshness.status === "stale_fingerprint"
+                ? `Local MCP process fingerprint/version may be stale. Restart controller/MCP, then reconnect ChatGPT if rh_* are still missing.`
+                : connectorFreshness.status === "local_mcp_missing_facade"
+                  ? `Local MCP tool surface is missing facade tools: ${connectorFreshness.missingLocalTools.join(", ")}. Restart controller/MCP.`
+                  : `Connector clients must match ${FORGE_TOOL_SURFACE} version ${FORGE_VERSION} / schema ${FORGE_MCP_SCHEMA_VERSION}. Prefer rh_status/rh_inbox/rh_context/rh_work. Pass connector_tool_names to detect a stale ChatGPT tool snapshot precisely.`,
         };
-        audit(
-          ctx,
-          name,
-          readiness.queueable ? "ok" : "blocked",
-          args,
-          `tasks/issues/${issue.id}`,
-        );
-        return textResult(preview);
-      }
-      case "assess_work_request": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult("TOOL_DISABLED", "assess_work_request requires the controller profile");
-        const assessment = assessWorkMode({
-          description: String(args.description ?? ""),
-          knownPaths: stringList(args.known_paths),
-          expectedFiles: typeof args.expected_files === "number" ? args.expected_files : undefined,
-          expectedChangedLines: typeof args.expected_changed_lines === "number" ? args.expected_changed_lines : undefined,
-          requiresInvestigation: args.requires_investigation === true,
-          requiresParallelism: args.requires_parallelism === true,
-          requiresLongRunningChecks: args.requires_long_running_checks === true,
-          needsDependencies: args.needs_dependencies === true,
-          risk: typeof args.risk === "string" ? args.risk as TaskRisk : undefined,
-          explicitMode: parseExplicitTaskMode(args.mode),
-        });
         audit(ctx, name, "ok", args);
-        return textResult(assessment);
-      }
-      case "create_issue": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "create_issue requires the controller profile",
-          );
-        const issue = createIssue(ctx.repoRoot, {
-          title: String(args.title ?? ""),
-          kind: (args.kind ? String(args.kind) : "feature") as IssueKind,
-          summary: typeof args.summary === "string" ? args.summary : undefined,
-          goals: stringList(args.goals),
-          nonGoals: stringList(args.non_goals),
-          acceptanceCriteria: stringList(args.acceptance_criteria),
-          relatedArtifacts: stringList(args.related_artifacts),
-          tasks: controllerTaskDrafts(args.tasks),
-          allowWhileFocused: args.allow_while_focused === true,
-          allowDuplicate: args.allow_duplicate === true,
-          allowWhenPaused: args.allow_when_paused === true,
-        });
-        audit(ctx, name, "ok", args, `tasks/issues/${issue.id}`);
-        return textResult(projectIssueEffectiveView(ctx.repoRoot, issue));
+        return textResult(payload);
       }
-      case "update_issue": {
+      case "local_bridge_status": {
         if (ctx.policy.profile !== "controller")
           return errorResult(
             "TOOL_DISABLED",
-            "update_issue requires the controller profile",
+            "local_bridge_status requires the controller profile",
           );
-        const issueId = String(args.issue_id ?? "");
-        const patch = {
-          title: typeof args.title === "string" ? args.title : undefined,
-          status:
-            typeof args.status === "string"
-              ? (args.status as IssueStatus)
-              : undefined,
-          summary: typeof args.summary === "string" ? args.summary : undefined,
-          goals: Array.isArray(args.goals) ? stringList(args.goals) : undefined,
-          nonGoals: Array.isArray(args.non_goals)
-            ? stringList(args.non_goals)
-            : undefined,
-          acceptanceCriteria: Array.isArray(args.acceptance_criteria)
-            ? stringList(args.acceptance_criteria)
-            : undefined,
-          relatedArtifacts: Array.isArray(args.related_artifacts)
-            ? stringList(args.related_artifacts)
-            : undefined,
-        };
-        const migrated = applyMigratedIssueDecision(ctx.repoRoot, {
-          issueId,
-          ...patch,
+        const detailLevel = args.detail_level === "detail" || args.detail === true
+          ? "detail"
+          : "summary";
+        const controllerHome = resolveRepoPreferredControllerHome(ctx.repoRoot);
+        const surface = resolveLocalBridgeSurface({
+          controllerHome,
+          repoRoot: ctx.repoRoot,
+          allowProcessScan: detailLevel === "detail",
         });
-        if (migrated) {
-          audit(ctx, name, "ok", args, `requirements/${migrated.requirement.requirementId}`);
-          return textResult(migrated);
+        const jobs = listLocalBridgeJobs(ctx.repoRoot, detailLevel === "detail" ? 12 : 20);
+        const { activeJobCount, recentJobSummary } = summarizeRecentJobs(jobs);
+        // Prefer authoritative surface; never invent a legacy 8766 endpoint.
+        const endpoint = surface.endpoint ?? null;
+        const running = surface.enabled
+          && (surface.processRunning === true
+            || (surface.endpointConfigured && surface.mode === "embedded"));
+        if (detailLevel === "summary") {
+          const payload = {
+            detailLevel: "summary",
+            repoId: ctx.repoId,
+            running,
+            ready: surface.enabled ? (surface.processRunning !== false) : true,
+            health: surface.enabled
+              ? (surface.processRunning === true || surface.mode === "embedded" ? "ready" : "warning")
+              : "disabled",
+            mode: surface.mode,
+            endpoint,
+            endpointConfigured: surface.endpointConfigured,
+            endpointReachable: null as boolean | null,
+            processRunning: surface.processRunning ?? null,
+            expectedSurface: surface.expectedSurface,
+            requiredForReadiness: surface.requiredForReadiness,
+            warnings: surface.error && surface.requiredForReadiness
+              ? [{ code: "LOCAL_BRIDGE_ERROR", message: surface.error.slice(0, 300) }]
+              : [],
+            activeJobCount,
+            recentJobSummary,
+            statusSource: surface.source,
+            nonBlocking: !surface.requiredForReadiness,
+            approvalQueue: false,
+          };
+          audit(ctx, name, "ok", args);
+          return textResult(payload);
         }
-        const issue = updateIssue(ctx.repoRoot, issueId, patch);
-        audit(ctx, name, "ok", args, `tasks/issues/${issue.id}`);
-        return textResult(projectIssueEffectiveView(ctx.repoRoot, issue));
+        const reconciliation = reconcileLocalBridgeJobs(ctx.repoRoot);
+        const payload = {
+          detailLevel: "detail",
+          endpoint,
+          endpointConfigured: surface.endpointConfigured,
+          running,
+          error: surface.error,
+          mode: surface.mode,
+          requiredForReadiness: surface.requiredForReadiness,
+          statusSource: surface.source,
+          counts: recentJobSummary,
+          activeJobCount,
+          recentJobSummary,
+          approvalQueue: false,
+          reconciliation,
+          recentJobs: jobs.map((job) => ({
+            jobId: job.jobId,
+            action: job.action,
+            status: job.status,
+            checkId: job.action === "run-check" ? (job.payload as { checkId?: string }).checkId : undefined,
+            runId: job.runId,
+            issueId: job.issueId,
+            taskId: job.taskId,
+            createdAt: job.createdAt,
+            updatedAt: job.updatedAt,
+            finishedAt: job.finishedAt,
+            revision: job.revision,
+            deadlineAt: job.deadlineAt,
+            error: job.error?.slice(0, 300),
+          })),
+          nonBlocking: !surface.requiredForReadiness,
+          fallback:
+            "Open the localhost Local Controller to launch work or inspect execution when a ChatGPT write action is unavailable.",
+        };
+        audit(ctx, name, "ok", args);
+        return textResult(payload);
       }
-      case "plan_issue": {
+      case "controller_context": {
         if (ctx.policy.profile !== "controller")
           return errorResult(
             "TOOL_DISABLED",
-            "plan_issue requires the controller profile",
+            "controller_context requires the controller profile",
           );
-        const issue = planIssue(
-          ctx.repoRoot,
-          String(args.issue_id ?? ""),
-          controllerTaskDrafts(args.tasks),
-        );
-        audit(ctx, name, "ok", args, `tasks/issues/${issue.id}`);
-        return textResult(projectIssueEffectiveView(ctx.repoRoot, issue));
+        const controllerHome = resolveRepoPreferredControllerHome(ctx.repoRoot);
+        const requirementBoard = buildRequirementBoard({ controllerHome, repoId: ctx.repoId });
+        const executionDiagnostics = buildExecutionDiagnostics({
+          controllerHome,
+          repoId: ctx.repoId,
+          detailLevel: "detail",
+        });
+        const runs = listAgentJobs(ctx.repoRoot, 8);
+        const reconciliation = reconcileLocalBridgeJobs(ctx.repoRoot);
+        const jobs = listLocalBridgeJobs(ctx.repoRoot, 8);
+        const checks = listControllerChecks(ctx.repoRoot).map((check) => ({
+          id: check.id,
+          description: check.description,
+          timeoutMs: check.timeoutMs,
+          source: check.source,
+        }));
+        const payload = {
+          git: gitSnapshot(ctx.repoRoot),
+          requirementBoard,
+          executionDiagnostics,
+          legacyCompatibility: {
+            currentIssue: "deprecated_frozen",
+            issueTaskBoard: "deprecated_frozen",
+            authority: "controller-home-sqlite",
+          },
+          activeRuns: runs.map((run) => ({
+            runId: run.runId,
+            issueId: run.issueId,
+            taskId: run.taskId,
+            status: run.status,
+            agent: run.agent,
+            provider: run.provider,
+            executionMode: run.executionMode,
+            progress: run.progress,
+            lastHeartbeatAt: run.lastHeartbeatAt,
+            error: run.error?.slice(0, 300),
+          })),
+          localBridge: {
+            reconciliation,
+            recentJobs: jobs.map((job) => ({
+              jobId: job.jobId,
+              action: job.action,
+              status: job.status,
+              checkId: job.action === "run-check" ? (job.payload as { checkId?: string }).checkId : undefined,
+              issueId: job.issueId,
+              taskId: job.taskId,
+              updatedAt: job.updatedAt,
+            })),
+          },
+          checks,
+        };
+        audit(ctx, name, "ok", args);
+        return textResult(payload);
       }
-      case "append_task": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "append_task requires the controller profile",
-          );
-        const drafts = controllerTaskDrafts([args.task]);
-        if (drafts.length !== 1)
-          return errorResult(
-            "INVALID_TASK",
-            "append_task requires one valid task",
-          );
-        const issue = appendTask(
-          ctx.repoRoot,
-          String(args.issue_id ?? ""),
-          drafts[0],
+      case "quick_agent_session":
+      case "submit_local_job": {
+        if (ctx.policy.profile !== "controller") {
+          return errorResult("TOOL_DISABLED", `${name} requires the controller profile`);
+        }
+        audit(ctx, name, "blocked", args);
+        return errorResult(
+          name === "quick_agent_session" ? "AGENT_RUN_DEPRECATED" : "LOCAL_BRIDGE_JOB_RETIRED",
+          "Kernel-managed Agent and Local Bridge Jobs are retired. Create or claim WorkContract and use Process Runtime or the Thin Launcher.",
         );
-        audit(ctx, name, "ok", args, `tasks/issues/${issue.id}`);
-        return textResult(projectIssueEffectiveView(ctx.repoRoot, issue));
       }
-      case "split_task": {
+      case "list_local_jobs": {
         if (ctx.policy.profile !== "controller")
           return errorResult(
             "TOOL_DISABLED",
-            "split_task requires the controller profile",
+            "list_local_jobs requires the controller profile",
           );
-        const issue = splitTask(
-          ctx.repoRoot,
-          String(args.issue_id ?? ""),
-          String(args.task_id ?? ""),
-          controllerTaskDrafts(args.tasks),
-        );
-        audit(ctx, name, "ok", args, `tasks/issues/${issue.id}`);
-        return textResult(projectIssueEffectiveView(ctx.repoRoot, issue));
+        const limit = typeof args.limit === "number" ? args.limit : 50;
+        const jobs = listLocalBridgeJobs(ctx.repoRoot, limit);
+        audit(ctx, name, "ok", args);
+        return textResult({ jobs });
       }
-      case "supersede_task": {
+      case "get_local_job": {
         if (ctx.policy.profile !== "controller")
           return errorResult(
             "TOOL_DISABLED",
-            "supersede_task requires the controller profile",
+            "get_local_job requires the controller profile",
           );
-        const issue = supersedeTask(
-          ctx.repoRoot,
-          String(args.issue_id ?? ""),
-          String(args.task_id ?? ""),
-          stringList(args.replacement_task_ids),
-        );
-        audit(ctx, name, "ok", args, `tasks/issues/${issue.id}`);
-        return textResult(projectIssueEffectiveView(ctx.repoRoot, issue));
+        const jobId = String(args.job_id ?? "").trim();
+        const includeEvents = args.include_events === true;
+        const includeOutput = args.include_output === true;
+        const snapshot = getLocalBridgeJobSnapshot(ctx.repoRoot, jobId);
+        const payload = {
+          job: snapshot.job,
+          ...(snapshot.status !== "ok" ? { lookup: snapshot } : {}),
+          ...(includeEvents && snapshot.status === "ok" ? { events: getLocalBridgeJobEvents(ctx.repoRoot, jobId) } : {}),
+          ...(includeOutput
+            ? {
+                output: readLocalBridgeJobOutput(ctx.repoRoot, jobId, {
+                  stream: args.stream === "stderr" ? "stderr" : "stdout",
+                  maxBytes: typeof args.max_bytes === "number" ? args.max_bytes : undefined,
+                }),
+              }
+            : {}),
+        };
+        audit(ctx, name, "ok", args);
+        return textResult(payload);
       }
-      case "set_task_dependencies": {
+      case "get_local_job_output": {
         if (ctx.policy.profile !== "controller")
           return errorResult(
             "TOOL_DISABLED",
-            "set_task_dependencies requires the controller profile",
+            "get_local_job_output requires the controller profile",
           );
-        const issue = setTaskDependencies(
-          ctx.repoRoot,
-          String(args.issue_id ?? ""),
-          String(args.task_id ?? ""),
-          stringList(args.depends_on),
-        );
-        audit(ctx, name, "ok", args, `tasks/issues/${issue.id}`);
-        return textResult(projectIssueEffectiveView(ctx.repoRoot, issue));
+        const jobId = String(args.job_id ?? "").trim();
+        const payload = readLocalBridgeJobOutput(ctx.repoRoot, jobId, {
+          stream: args.stream === "stderr" ? "stderr" : "stdout",
+          maxBytes: typeof args.max_bytes === "number" ? args.max_bytes : undefined,
+        });
+        audit(ctx, name, "ok", args);
+        return textResult(payload);
       }
-      case "update_task": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "update_task requires the controller profile",
-          );
-        const startedAt = performance.now();
-        const taskId = String(args.task_id ?? "");
-        const issue = updateTask(
-          ctx.repoRoot,
-          String(args.issue_id ?? ""),
-          taskId,
-          {
-            status:
-              typeof args.status === "string"
-                ? (args.status as TaskStatus)
-                : undefined,
-            note: typeof args.note === "string" ? args.note : undefined,
-          },
-        );
-        const issueView = projectIssueEffectiveView(ctx.repoRoot, issue);
-        audit(ctx, name, "ok", args, `tasks/issues/${issue.id}`);
-        if (args.detail_level === "detail" || args.detail_level === "full") return textResult(issueView);
+      case "project_snapshot": {
+        if (ctx.policy.profile !== "controller") return errorResult("TOOL_DISABLED", "project_snapshot requires the controller profile");
+        const markerPaths = [
+          ".ai/harness/active-plan",
+          ".ai/harness/active-sprint",
+          ".ai/harness/active-worktree",
+          "tasks/current.md",
+        ];
+        const markers = markerPaths.map((path) => {
+          const absolute = join(ctx.repoRoot, path);
+          if (!existsSync(absolute)) return { path, exists: false };
+          const raw = readFileSync(absolute, "utf-8");
+          return {
+            path,
+            exists: true,
+            bytes: Buffer.byteLength(raw),
+            lines: raw.split(/\r?\n/).length,
+            sha256: createHash("sha256").update(raw).digest("hex").slice(0, 16),
+            preview: redactMcpText(raw).text.slice(0, 400),
+          };
+        });
+        const controllerHome = resolveRepoPreferredControllerHome(ctx.repoRoot);
+        const requirementBoard = buildRequirementBoard({ controllerHome, repoId: ctx.repoId });
+        const executionDiagnostics = buildExecutionDiagnostics({
+          controllerHome,
+          repoId: ctx.repoId,
+          detailLevel: "detail",
+        });
+        const snapshotRuns = listAgentJobs(ctx.repoRoot, 11);
+        const runs = snapshotRuns.slice(0, 10).map((run) => ({
+          runId: run.runId,
+          issueId: run.issueId,
+          taskId: run.taskId,
+          agent: run.agent,
+          provider: run.provider,
+          executionMode: run.executionMode,
+          status: run.status,
+          progress: run.progress,
+          createdAt: run.createdAt,
+          finishedAt: run.finishedAt,
+          error: run.error?.slice(0, 300),
+        }));
         const payload = {
-          ...summarizeUpdatedIssue(issueView as unknown as Record<string, unknown>, taskId),
-          responseMeta: {
-            serverDurationMs: Number((performance.now() - startedAt).toFixed(2)),
-            structuredPayloadBytes: 0,
+          git: gitSnapshot(ctx.repoRoot),
+          requirementBoard,
+          executionDiagnostics,
+          legacyCompatibility: {
+            currentIssue: "deprecated_frozen",
+            issueTaskBoard: "deprecated_frozen",
+            authority: "controller-home-sqlite",
+          },
+          runs,
+          markers,
+          truncated: {
+            runs: snapshotRuns.length > 10,
           },
         };
-        payload.responseMeta.structuredPayloadBytes = Buffer.byteLength(JSON.stringify(payload), "utf8");
+        audit(ctx, name, "ok", args);
         return textResult(payload);
       }
-      case "dispatch_task": {
-        if (ctx.policy.profile !== "controller") return errorResult("TOOL_DISABLED", "dispatch_task requires the controller profile");
-        audit(ctx, name, "blocked", args);
-        return errorResult(
-          "AGENT_RUN_DEPRECATED",
-          "Kernel-managed Agent Runs are retired. Create or claim a WorkContract through rh_work, then start an external SuperController session through the Thin Launcher.",
-        );
-      }
-      case "launch_issue": {
-        if (ctx.policy.profile !== "controller") return errorResult("TOOL_DISABLED", "launch_issue requires the controller profile");
-        audit(ctx, name, "blocked", args);
-        return errorResult(
-          "AGENT_RUN_DEPRECATED",
-          "Kernel-managed Agent Runs are retired. Convert the Issue tasks to WorkContracts and claim them through rh_work.",
-        );
-      }
-      case "dispatch_ready_tasks": {
-        if (ctx.policy.profile !== "controller") return errorResult("TOOL_DISABLED", "dispatch_ready_tasks requires the controller profile");
-        audit(ctx, name, "blocked", args);
-        return errorResult(
-          "AGENT_RUN_DEPRECATED",
-          "Kernel-managed batch dispatch is retired. Convert ready Tasks into WorkContracts, claim them explicitly, and launch peer external Controllers through the Thin Launcher.",
-          {
-            requestedIssue: typeof args.issue_id === "string" && args.issue_id.trim() ? args.issue_id.trim() : undefined,
-            currentFocus: loadControllerProjectState(ctx.repoRoot).currentIssueId,
-            focusIsInformational: true,
-          },
-        );
-      }
-      case "get_task_run": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "get_task_run requires the controller profile",
-          );
-        const run = getAgentJob(ctx.repoRoot, String(args.run_id ?? ""));
-        audit(ctx, name, "ok", args, run.promptPath);
-        return textResult(summarizeAgentRun(ctx.repoRoot, run as unknown as Record<string, unknown>, {
-          includePaths: args.include_paths === true,
-          includeOutput: args.include_output !== false,
-          tailChars: typeof args.tail_chars === "number" ? Math.trunc(args.tail_chars) : undefined,
-        }));
-      }
-      case "get_task_run_events": {
+      case "search_repository": {
         if (ctx.policy.profile !== "controller")
           return errorResult(
             "TOOL_DISABLED",
-            "get_task_run_events requires the controller profile",
+            "search_repository requires the controller profile",
           );
-        const sinceEventIndex = typeof args.since_event_index === "number"
-          ? Math.trunc(args.since_event_index)
+        const session = ctx.sessionId && ctx.repoId
+          ? {
+            sessionId: ctx.sessionId,
+            repoId: ctx.repoId,
+            checkoutId: ctx.checkoutId ?? ctx.repoId,
+          }
           : undefined;
-        const events = getAgentJobEvents(
-          ctx.repoRoot,
-          String(args.run_id ?? ""),
-          typeof args.limit === "number" ? Math.trunc(args.limit) : 200,
-          {
-            sinceIndex: sinceEventIndex,
-            includeHeartbeats: args.include_heartbeats === true,
-          },
-        );
-        audit(ctx, name, "ok", args);
-        return textResult({
-          events,
-          // Keep an existing cursor stable when no new event is available. New events
-          // that race with a read are returned on the next call instead of being lost.
-          nextSinceEventIndex: events.at(-1)?.data?.eventIndex ?? sinceEventIndex,
-          heartbeatsCollapsed: args.include_heartbeats !== true,
+        const result = searchRepository(ctx.repoRoot, ctx.policy, {
+          query: String(args.query ?? ""),
+          includeGlobs: stringList(args.include_globs),
+          excludeGlobs: stringList(args.exclude_globs),
+          maxResults:
+            typeof args.max_results === "number" ? args.max_results : undefined,
+          maxFiles:
+            typeof args.max_files === "number" ? args.max_files : undefined,
+          caseSensitive: args.case_sensitive === true,
+          session,
         });
+        audit(ctx, name, "ok", args);
+        return textResult(result);
       }
-      case "get_task_run_log": {
+      case "get_git_diff": {
         if (ctx.policy.profile !== "controller")
           return errorResult(
             "TOOL_DISABLED",
-            "get_task_run_log requires the controller profile",
+            "get_git_diff requires the controller profile",
           );
-        const log = getAgentJobLog(
-          ctx.repoRoot,
-          String(args.run_id ?? ""),
-          false,
-          typeof args.max_bytes === "number" ? Math.trunc(args.max_bytes) : 32 * 1024,
-        );
-        audit(ctx, name, "ok", args, log.url);
-        const run = getAgentJob(ctx.repoRoot, String(args.run_id ?? ""));
-        const bounded = redactRunText(
-          log.log,
-          ctx.repoRoot,
-          {
-            executionRoot: run.executionRoot,
-            worktree: run.worktree,
-            worktreePath: run.worktreePath,
-          },
-          Math.max(
-            4 * 1024,
-            Math.min(
-              typeof args.max_bytes === "number" ? Math.trunc(args.max_bytes) : 32 * 1024,
-              256 * 1024,
-            ),
-          ),
-        );
+        const path =
+          typeof args.path === "string" && args.path.trim()
+            ? args.path.trim()
+            : undefined;
+        if (path) {
+          const decision = resolveMcpPath(
+            ctx.repoRoot,
+            path,
+            ctx.policy,
+            "read",
+          );
+          if (!decision.ok)
+            return errorResult(
+              "POLICY_DENIED",
+              decision.reason ?? "path denied",
+              { path },
+            );
+        }
+        const maxBytes =
+          typeof args.max_bytes === "number"
+            ? Math.min(Math.max(Math.trunc(args.max_bytes), 1024), 512 * 1024)
+            : 128 * 1024;
+        const result = gitDiff(ctx.repoRoot, path, maxBytes);
+        const redacted = redactMcpText(result.diff);
+        audit(ctx, name, "ok", args, path);
         return textResult({
-          ...log,
-          log: bounded.text,
-          truncated: bounded.truncated,
-          redactions: bounded.redactions,
-          next: bounded.truncated
-            ? "Call get_task_run_log with a larger max_bytes value for more retained tail."
-            : undefined,
+          ...result,
+          diff: redacted.text,
+          redactions: redacted.redactions,
         });
       }
-      case "get_task_diff": {
+      case "list_checks": {
         if (ctx.policy.profile !== "controller")
           return errorResult(
             "TOOL_DISABLED",
-            "get_task_diff requires the controller profile",
+            "list_checks requires the controller profile",
           );
-        const diff = taskRunDiff(
-          ctx.repoRoot,
-          String(args.run_id ?? ""),
-          typeof args.max_bytes === "number"
-            ? Math.min(Math.max(Math.trunc(args.max_bytes), 1024), 1024 * 1024)
-            : undefined,
-        );
-        audit(ctx, name, "ok", args, diff.worktree);
-        return textResult(diff);
+        const checks = listControllerChecks(ctx.repoRoot);
+        audit(ctx, name, "ok", args);
+        return textResult({ checks });
       }
-      case "integrate_task_run": {
+      case "get_worklog_timeline": {
         if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "integrate_task_run requires the controller profile",
-          );
-        const integrated = integrateAgentJob(
-          ctx.repoRoot,
-          ctx.policy,
-          String(args.run_id ?? ""),
-        );
-        audit(
-          ctx,
-          name,
-          "ok",
-          args,
-          `controller-home://repositories/${editExecutionIdentity(ctx).repoId}/edit-sessions/${integrated.session.sessionId}`,
-        );
-        return textResult(integrated);
+          return errorResult("TOOL_DISABLED", "get_worklog_timeline requires the controller profile");
+        const events = listControllerWorklogEvents(ctx.repoRoot, {
+          category: parseWorklogCategory(args.category),
+          issueId: typeof args.issue_id === "string" ? args.issue_id : undefined,
+          taskId: typeof args.task_id === "string" ? args.task_id : undefined,
+          runId: typeof args.run_id === "string" ? args.run_id : undefined,
+          editSessionId: typeof args.edit_session_id === "string" ? args.edit_session_id : undefined,
+          since: typeof args.since === "string" ? args.since : undefined,
+          until: typeof args.until === "string" ? args.until : undefined,
+          limit: typeof args.limit === "number" ? Math.trunc(args.limit) : undefined,
+        });
+        audit(ctx, name, "ok", args);
+        return textResult({ events });
       }
-      case "list_task_runs": {
+      case "export_worklog": {
         if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "list_task_runs requires the controller profile",
-          );
-        const runs = listAgentJobs(
-          ctx.repoRoot,
-          typeof args.limit === "number" ? args.limit : 50,
-        );
-        audit(ctx, name, "ok", args);
-        return textResult({
-          runs: summarizeRunList(
-            ctx.repoRoot,
-            runs as unknown as Array<Record<string, unknown>>,
-            args.include_paths === true,
-          ),
+          return errorResult("TOOL_DISABLED", "export_worklog requires the controller profile");
+        const result = exportControllerWorklog(ctx.repoRoot, {
+          format: args.format === "json" ? "json" : "markdown",
+          outputPath: typeof args.output_path === "string" ? args.output_path : undefined,
+          filter: {
+            issueId: typeof args.issue_id === "string" ? args.issue_id : undefined,
+            taskId: typeof args.task_id === "string" ? args.task_id : undefined,
+            runId: typeof args.run_id === "string" ? args.run_id : undefined,
+            editSessionId: typeof args.edit_session_id === "string" ? args.edit_session_id : undefined,
+          },
         });
+        audit(ctx, name, "ok", args, result.path);
+        return textResult(result);
       }
-      case "cancel_task_run": {
+      case "get_github_plugin_status": {
         if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "cancel_task_run requires the controller profile",
-          );
-        const run = cancelAgentJob(ctx.repoRoot, String(args.run_id ?? ""));
-        audit(ctx, name, "ok", args, run.promptPath);
-        return textResult(run);
+          return errorResult("TOOL_DISABLED", "get_github_plugin_status requires the controller profile");
+        const status = getGitHubPluginStatus(ctx.repoRoot);
+        audit(ctx, name, "ok", args, status.repository);
+        return textResult(status);
       }
-      case "retry_task_run": {
+      case "configure_github_plugin": {
         if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "retry_task_run requires the controller profile",
-          );
-        // Fail closed before Task/provider side effects. Historical Runs remain readable.
-        audit(ctx, name, "failed", args, undefined, "AGENT_RUN_RETIRED");
-        return errorResult(
-          "AGENT_RUN_RETIRED",
-          "Kernel-managed Agent Run retry is disabled. Create or claim a WorkContract and start an external SuperController through Thin Launcher.",
-        );
-      }
-      case "finish_task_run": {
-        if (ctx.policy.profile !== "controller") return errorResult("TOOL_DISABLED", "finish_task_run requires the controller profile");
-        const runId = String(args.run_id ?? "").trim();
-        if (!runId) return errorResult("RUN_ID_REQUIRED", "finish_task_run requires run_id");
-        const decision = typeof args.decision === "string" ? args.decision : "auto";
-        if (!["auto", "approve_and_finish", "request_changes", "discard"].includes(decision)) {
-          return errorResult("INVALID_DECISION", "decision must be auto, approve_and_finish, request_changes, or discard");
-        }
-        const finished = finishTaskRun(ctx.repoRoot, {
-          runId,
-          decision: decision as "auto" | "approve_and_finish" | "request_changes" | "discard",
-          reviewer: typeof args.reviewer === "string" ? args.reviewer : undefined,
-          note: typeof args.note === "string" ? args.note : undefined,
-          cleanup: typeof args.cleanup === "boolean" ? args.cleanup : undefined,
-          commit: typeof args.commit === "boolean" ? args.commit : undefined,
-        });
-        audit(ctx, name, ["blocked", "needs_decision"].includes(finished.action) ? "failed" : "ok", args, `tasks/issues/${finished.issueId}`, finished.reason);
-        return textResult(finished);
-      }
-      case "verify_task": {
-        if (ctx.policy.profile !== "controller") return errorResult("TOOL_DISABLED", "verify_task requires the controller profile");
-        const issueId = String(args.issue_id ?? "");
-        const taskId = String(args.task_id ?? "");
-        const current = getIssue(ctx.repoRoot, issueId);
-        const task = current.tasks.find((entry) => entry.id === taskId);
-        if (!task) return errorResult("TASK_NOT_FOUND", `task not found: ${issueId}/${taskId}`);
-        const policy = taskExecutionPolicy(task);
-        const evidenceRunId = typeof args.run_id === "string" ? args.run_id : task.runIds.at(-1);
-        let evidenceRun: ReturnType<typeof getAgentJob> | undefined;
-        if (evidenceRunId) {
-          evidenceRun = getAgentJob(ctx.repoRoot, evidenceRunId);
-          if (evidenceRun.issueId !== issueId || evidenceRun.taskId !== taskId) return errorResult("RUN_TASK_MISMATCH", `Run ${evidenceRunId} does not belong to ${issueId}/${taskId}`);
-          if (evidenceRun.status !== "succeeded") return errorResult("RUN_NOT_SUCCEEDED", `verification requires a succeeded Run (current: ${evidenceRun.status})`);
-          if (evidenceRun.provider === "local" && evidenceRun.worktree !== ctx.repoRoot && !evidenceRun.integratedSessionId) return errorResult("RUN_NOT_INTEGRATED", "integrate the isolated local Run before recording verification");
-          if (evidenceRun.provider === "github" && evidenceRun.github?.createPullRequest !== false && !evidenceRun.github?.pullRequestUrl) return errorResult("GITHUB_PR_NOT_READY", "GitHub cloud verification requires the linked pull request to be available");
-        }
-
-        const requestedCheckInputs = taskObjects(args.check_results).map((entry) => ({
-          checkId: String(entry.check_id ?? "").trim(),
-          requestedSummary: typeof entry.summary === "string" ? entry.summary : undefined,
-        })).filter((entry) => entry.checkId);
-        const registryChecks = listControllerChecks(ctx.repoRoot);
-        const requestedCheckIds = task.checks.length > 0 ? task.checks : requestedCheckInputs.map((entry) => entry.checkId);
-        const normalizedChecks = normalizeCheckIds(requestedCheckIds, registryChecks);
-        const checkIds = normalizedChecks.validCheckIds;
-        const checkResults: TaskVerification['checkResults'] = [];
-        if (checkIds.length > 0) {
-          const controllerHome = resolveRepoPreferredControllerHome(ctx.repoRoot);
-          const repository = resolveRepositorySelection({
-            explicitPath: ctx.repoRoot,
-            controllerHome,
-            allowSoleRepository: true,
-          });
-          if (!repository) return errorResult('TASK_CHECK_REPOSITORY_UNRESOLVED', 'verify_task could not resolve the repository checkout');
-          const taskCheckRequestBase = typeof args.request_id === 'string' && args.request_id.trim()
-            ? args.request_id.trim()
-            : `verify-task:${issueId}:${taskId}:${createHash('sha256').update(JSON.stringify({ checkIds, revision: args.integrated_revision ?? evidenceRun?.integratedSessionId ?? 'current' })).digest('hex').slice(0, 16)}`;
-          for (const [index, checkId] of checkIds.entries()) {
-            const processRequestId = `${taskCheckRequestBase}:check:${index + 1}:${createHash('sha256').update(checkId).digest('hex').slice(0, 12)}`;
-            const facade = await runPersistedCheckViaProcessRuntime({
-              controllerHome,
-              repoId: repository.repoId,
-              checkoutId: repository.activeCheckoutId,
-              repoRoot: repository.canonicalRoot,
-              executionIdentity: executionIdentityForRepository(repository),
-              checkId,
-              requestId: processRequestId,
-              commandId: processRequestId,
-              verificationBinding: { issueId, taskId },
-            });
-            if (facade.mode === 'durable' || !facade.process) {
-              return errorResult('TASK_CHECK_DURABLE_REQUIRED', facade.durable?.reason ?? `check requires durable workflow: ${checkId}`);
-            }
-            if (!facade.process.completed) {
-              return textResult({
-                accepted: true,
-                status: 'verification_running',
-                issueId,
-                taskId,
-                checkId,
-                requestId: taskCheckRequestBase,
-                processId: facade.process.processId,
-                next: `Retry verify_task with request_id=${taskCheckRequestBase}; the original Process will be reused.`,
-                durableSideEffects: { executionJobCount: 0, localJobCount: 0, workerSpawnCount: 0, projectionUpdateCount: 0 },
-              });
-            }
-            const record = getProcessRecord(controllerHome, repository.repoId, facade.process.processId);
-            if (!record) return errorResult('TASK_CHECK_PROCESS_MISSING', `process record not found: ${facade.process.processId}`);
-            const leaseConflict = taskVerificationLeaseConflict(record);
-            if (leaseConflict) {
-              const retryRequestId = taskVerificationRetryRequestId(
-                taskCheckRequestBase,
-                checkId,
-                facade.process.processId,
-              );
-              return textResult({
-                accepted: true,
-                status: 'verification_deferred',
-                reason: 'repository_resource_busy',
-                issueId,
-                taskId,
-                checkId,
-                requestId: taskCheckRequestBase,
-                processId: facade.process.processId,
-                conflict: {
-                  code: 'PROCESS_LEASE_CONFLICT',
-                  resourceKey: leaseConflict.resourceKey,
-                  blockingProcessId: leaseConflict.blockingProcessId,
-                },
-                retryRequestId,
-                next: `Retry verify_task with request_id=${retryRequestId} after the conflicting repository process settles.`,
-                durableSideEffects: { executionJobCount: 0, localJobCount: 0, workerSpawnCount: 0, projectionUpdateCount: 0 },
-              });
-            }
-            const receipt = processCheckCompletionReceipt(record, {
-              repoId: repository.repoId,
-              checkoutId: repository.activeCheckoutId,
-              issueId,
-              taskId,
-              checkId,
-              processId: facade.process.processId,
-            });
-            checkResults.push({
-              checkId,
-              ok: receipt.ok,
-              summary: receipt.summary,
-              receipt,
-            });
-          }
-        }
-
-        const commandEvidence: TaskCommandEvidence[] = [];
-        for (const entry of taskObjects(args.reported_commands)) {
-          const command = Array.isArray(entry.command) ? entry.command.map(String).map((part) => part.trim()).filter(Boolean) : [];
-          if (command.length === 0) return errorResult("INVALID_COMMAND_EVIDENCE", "reported command evidence requires a non-empty command argv");
-          const cwdInput = typeof entry.cwd === "string" && entry.cwd.trim() ? entry.cwd.trim() : undefined;
-          if (cwdInput && cwdInput !== "." && cwdInput !== "./") {
-            const cwdDecision = resolveMcpPath(ctx.repoRoot, cwdInput, ctx.policy, "read");
-            if (!cwdDecision.ok) {
-              const normalizedCwd = normalizeMcpRelativePath(cwdInput);
-              const missingHarnessEvidence = normalizedCwd.ok &&
-                normalizedCwd.relativePath?.startsWith(".ai/harness/") &&
-                cwdDecision.reason?.startsWith("path does not exist:");
-              if (!missingHarnessEvidence) return errorResult("COMMAND_EVIDENCE_PATH_DENIED", cwdDecision.reason ?? "reported command cwd is denied");
-            }
-          }
-          const artifactInput = typeof entry.artifact_path === "string" && entry.artifact_path.trim() ? entry.artifact_path.trim() : undefined;
-          if (artifactInput) {
-            const artifactDecision = resolveMcpPath(ctx.repoRoot, artifactInput, ctx.policy, "read");
-            if (!artifactDecision.ok) {
-              const normalizedArtifact = normalizeMcpRelativePath(artifactInput);
-              const missingHarnessEvidence = normalizedArtifact.ok &&
-                normalizedArtifact.relativePath?.startsWith(".ai/harness/") &&
-                artifactDecision.reason?.startsWith("path does not exist:");
-              if (!missingHarnessEvidence) return errorResult("COMMAND_EVIDENCE_ARTIFACT_DENIED", artifactDecision.reason ?? "reported command artifact is denied");
-            }
-          }
-          commandEvidence.push({
-            command,
-            cwd: cwdInput,
-            ok: entry.ok === true,
-            exitCode: typeof entry.exit_code === "number" ? Math.trunc(entry.exit_code) : undefined,
-            stdout: typeof entry.stdout === "string" ? entry.stdout.slice(-32 * 1024) : undefined,
-            stderr: typeof entry.stderr === "string" ? entry.stderr.slice(-32 * 1024) : undefined,
-            artifactPath: artifactInput,
-            reportedBy: String(args.reviewer ?? "").trim(),
-            executedAt: typeof entry.executed_at === "string" ? entry.executed_at : new Date().toISOString(),
-            source: "reported",
-          });
-        }
-
-        let acceptanceResults: TaskVerification["acceptanceResults"] = taskObjects(args.acceptance_results).map((entry) => ({
-          criterion: String(entry.criterion ?? ""),
-          ok: entry.ok === true,
-          outcome: entry.ok === true ? "passed" as const : "failed" as const,
-          source: "reported" as const,
-          evidence: typeof entry.evidence === "string" ? entry.evidence : undefined,
-        }));
-        if (acceptanceResults.length === 0 && evidenceRun && task.acceptanceCriteria.length > 0) {
-          acceptanceResults = task.acceptanceCriteria.map((criterion) => ({
-            criterion,
-            ok: false,
-            outcome: "not_evaluated" as const,
-            source: "run_completion" as const,
-            evidence: `Successful Run ${evidenceRun!.runId}; acceptance was not independently evaluated.`,
-          }));
-        }
-        const verification: TaskVerification = {
-          runId: evidenceRunId,
-          integratedRevision: typeof args.integrated_revision === "string" ? args.integrated_revision : evidenceRun?.integratedSessionId,
-          reviewedDiffHash: typeof args.reviewed_diff_hash === "string" ? args.reviewed_diff_hash : undefined,
-          reviewer: String(args.reviewer ?? ""),
-          checkResults,
-          commandEvidence,
-          acceptanceResults,
-          verifiedAt: new Date().toISOString(),
-        };
-        const issue = recordTaskVerification(ctx.repoRoot, issueId, taskId, verification);
-        const issueView = projectIssueEffectiveView(ctx.repoRoot, issue);
-        const verifiedTask = issueView.tasks.find((entry) => entry.id === taskId);
-        audit(ctx, name, ["verified", "done"].includes(verifiedTask?.status ?? "") ? "ok" : "failed", args, `tasks/issues/${issue.id}`);
-        return textResult({
-          issueId,
-          taskId,
-          policy,
-          checkNormalization: {
-            validCheckIds: normalizedChecks.validCheckIds,
-            invalidCheckIds: normalizedChecks.invalidCheckIds,
-            warnings: normalizedChecks.warnings,
-          },
-          task: verifiedTask ? compactTaskView(verifiedTask as unknown as Record<string, unknown>) : undefined,
-          tasks: issueView.tasks.map((entry) => compactTaskView(entry as unknown as Record<string, unknown>)),
-          issue: compactIssueView(issueView as unknown as Record<string, unknown>),
+          return errorResult("TOOL_DISABLED", "configure_github_plugin requires the controller profile");
+        const config = saveGitHubPluginConfig(ctx.repoRoot, {
+          enabled: typeof args.enabled === "boolean" ? args.enabled : undefined,
+          repository: args.clear_repository === true ? "" : typeof args.repository === "string" ? args.repository : undefined,
+          syncMode: args.sync_mode === "checkpoint" ? "checkpoint" : args.sync_mode === "manual" ? "manual" : undefined,
+          includeTasks: typeof args.include_tasks === "boolean" ? args.include_tasks : undefined,
+          projectOwner: args.clear_project === true ? "" : typeof args.project_owner === "string" ? args.project_owner : undefined,
+          projectNumber: args.clear_project === true ? null : typeof args.project_number === "number" ? args.project_number : undefined,
         });
+        audit(ctx, name, "ok", args, "repository-registry:github");
+        return textResult(config);
       }
-      case "accept_task": {
-        if (ctx.policy.profile !== "controller") return errorResult("TOOL_DISABLED", "accept_task requires the controller profile");
-        const issueId = String(args.issue_id ?? "");
-        const taskId = String(args.task_id ?? "");
-        const current = getIssue(ctx.repoRoot, issueId);
-        const task = current.tasks.find((entry) => entry.id === taskId);
-        if (!task) return errorResult("TASK_NOT_FOUND", `task not found: ${issueId}/${taskId}`);
-        if (task.status === "done") return textResult(projectIssueEffectiveView(ctx.repoRoot, current));
-        if (task.status !== "verified" || !task.verification) return errorResult("TASK_NOT_VERIFIED", `task has not passed its risk-adaptive verification requirements (current: ${task.status})`);
-        const workId = typeof args.work_id === "string" ? args.work_id.trim() : "";
-        const issue = workId
-          ? acceptVerifiedTaskFromControllerWork({
-              controllerHome: resolveRepoPreferredControllerHome(ctx.repoRoot),
-              repoId: ctx.repoId ?? String(args.repo_id ?? "").trim(),
-              repoRoot: ctx.repoRoot,
-              issueId,
-              taskId,
-              workId,
-              note: typeof args.note === "string" ? args.note : undefined,
-            }).issue
-          : acceptVerifiedTask(ctx.repoRoot, issueId, taskId, typeof args.note === "string" ? args.note : "Accepted after required verification evidence.");
-        audit(ctx, name, "ok", args, `tasks/issues/${issue.id}`);
-        return textResult(projectIssueEffectiveView(ctx.repoRoot, issue));
-      }
-      case "request_task_changes": {
+      case "github_status": {
         if (ctx.policy.profile !== "controller")
           return errorResult(
             "TOOL_DISABLED",
-            "request_task_changes requires the controller profile",
-          );
-        const issueId = String(args.issue_id ?? "");
-        const taskId = String(args.task_id ?? "");
-        const current = getIssue(ctx.repoRoot, issueId);
-        const task = current.tasks.find((entry) => entry.id === taskId);
-        if (!task)
-          return errorResult(
-            "TASK_NOT_FOUND",
-            `task not found: ${issueId}/${taskId}`,
-          );
-        if (
-          !["review", "integrated", "verifying", "verified"].includes(
-            task.status,
-          )
-        )
-          return errorResult(
-            "TASK_NOT_REVIEWABLE",
-            `task must be in review, integrated, verifying, or verified before requesting changes (current: ${task.status})`,
+            "github_status requires the controller profile",
           );
-        const issue = updateTask(ctx.repoRoot, issueId, taskId, {
-          status: "changes_requested",
-          note: String(args.note ?? ""),
-        });
-        audit(ctx, name, "ok", args, `tasks/issues/${issue.id}`);
-        return textResult(projectIssueEffectiveView(ctx.repoRoot, issue));
+        const status = getGitHubStatus(
+          ctx.repoRoot,
+          typeof args.repo === "string" ? args.repo : undefined,
+        );
+        audit(
+          ctx,
+          name,
+          status.available && status.authenticated ? "ok" : "failed",
+          args,
+          status.repository?.nameWithOwner,
+          status.errors.join("; "),
+        );
+        return textResult(status);
       }
       case "begin_edit_session": {
         if (ctx.policy.profile !== "controller")
@@ -4487,19 +2138,6 @@ export async function callMcpTool(
         const checks = stringList(args.checks);
         const git = gitSnapshot(ctx.repoRoot);
         const workspaceIdentity = createHash("sha256").update(JSON.stringify(git)).digest("hex");
-        const routeDecision = decideRoute({
-          intent: {
-            objective: purpose,
-            scopeClear: allowedPaths.length > 0,
-            mutation: true,
-            expectedFiles: typeof args.max_files === "number" ? args.max_files : allowedPaths.length,
-            expectedChangedLines: typeof args.max_changed_lines === "number" ? args.max_changed_lines : undefined,
-          },
-          workspace: { knownPaths: allowedPaths, checkoutId: identity.checkoutId, fingerprint: workspaceIdentity },
-          policy: { risk: "local_repo_write", approvalConfirmed: true },
-          capabilities: {},
-          recovery: {},
-        });
         const requestedWorkId = typeof args.work_id === "string" ? args.work_id.trim() : "";
         const workId = requestedWorkId || `work-direct-${createHash("sha256").update(`${repoId}\0${purpose}\0${Date.now()}`).digest("hex").slice(0, 16)}`;
         const workStore = { controllerHome, repoId };
@@ -4514,7 +2152,6 @@ export async function callMcpTool(
             controllerInstanceId: identity.controllerInstanceId,
             baseRevision: git.head ?? undefined,
             workspaceFingerprint: workspaceIdentity,
-            routeDecision,
             objective: purpose,
             issueId: typeof args.issue_id === "string" ? args.issue_id : undefined,
             taskId: typeof args.task_id === "string" ? args.task_id : undefined,
@@ -4546,7 +2183,6 @@ export async function callMcpTool(
             checkoutId: identity.checkoutId,
             principalId: identity.principalId,
             controllerInstanceId: identity.controllerInstanceId,
-            routeDecisionFingerprint: routeDecision.inputFingerprint,
           },
         });
         audit(
@@ -4585,7 +2221,6 @@ export async function callMcpTool(
                 checkoutId: identity.checkoutId,
                 principalId: identity.principalId,
                 controllerInstanceId: identity.controllerInstanceId,
-                routeDecisionFingerprint: current.routeDecisionFingerprint,
               },
             },
           );
@@ -4705,7 +2340,6 @@ export async function callMcpTool(
               checkoutId: identity.checkoutId,
               principalId: identity.principalId,
               controllerInstanceId: identity.controllerInstanceId,
-              routeDecisionFingerprint: current.routeDecisionFingerprint,
             },
           },
         );
@@ -4718,29 +2352,6 @@ export async function callMcpTool(
         );
         return textResult(session);
       }
-      case "finish_edit_session": {
-        if (ctx.policy.profile !== "controller")
-          return errorResult(
-            "TOOL_DISABLED",
-            "finish_edit_session requires the controller profile",
-          );
-        const sessionId = String(args.session_id ?? "").trim();
-        if (!sessionId) return errorResult("SESSION_ID_REQUIRED", "finish_edit_session requires session_id");
-        const decision = typeof args.decision === "string" ? args.decision : "auto";
-        if (!["auto", "approve_and_finish", "request_changes", "discard"].includes(decision)) {
-          return errorResult("INVALID_DECISION", "decision must be auto, approve_and_finish, request_changes, or discard");
-        }
-        const finished = finishEditSession(ctx.repoRoot, {
-          sessionId,
-          decision: decision as "auto" | "approve_and_finish" | "request_changes" | "discard",
-          reviewer: typeof args.reviewer === "string" ? args.reviewer : undefined,
-          note: typeof args.note === "string" ? args.note : undefined,
-          checkIds: Array.isArray(args.check_ids) ? args.check_ids.map(String) : undefined,
-          commit: typeof args.commit === "boolean" ? args.commit : undefined,
-        });
-        audit(ctx, name, ["blocked", "needs_decision"].includes(finished.action) ? "failed" : "ok", args, `tasks/issues/${finished.issueId}`, finished.reason);
-        return textResult(finished);
-      }
       case "list_workflow_files": {
         const files = workflowFileCandidates(ctx.repoRoot)
           .filter(