@moretea-labs/forge 1.5.0-rc.1

package/src/cli/local-bridge/facade-api.ts

@@ -0,0 +1,1877 @@
+import type { RepositoryRecord } from '../repositories/types';
+import {
+  accessModeDescriptor,
+  isAccessMode,
+  readRepositoryAccessPolicy,
+  writeRepositoryAccessPolicy,
+  type AccessMode,
+} from '../../runtime/control-plane/governance/access-policy';
+import {
+  persistControllerAccessMode,
+  resolveControllerAccessState,
+} from '../mcp/access-mode';
+import { listControllerChecks, runControllerCheck } from '../controller/check-runner';
+import { createMcpToolContext, type MultiRepositoryMcpToolContext } from '../mcp/multi-repository';
+import { readSchedulerHealthSnapshot } from '../../runtime/control-plane/global-scheduler/scheduler';
+import { observeRuntimeStatus } from '../../runtime/root/status';
+import { readForgeRuntimeStatus } from '../../runtime/control-plane/runtime-status-client';
+import { evaluateActiveRuntimeSourceDrift, readRuntimeGeneration } from '../../runtime/control-plane/runtime-generation';
+import {
+  getAssistantPluginManifest,
+  listAssistantPluginManifests,
+} from '../../runtime/plugins/store';
+import type { AssistantPluginManifest } from '../../runtime/plugins/types';
+import {
+  acknowledgeHandoffItem,
+  buildFacadeResult,
+  buildSyncOperationDigest,
+  classifyUserFacingError,
+  classifyVerificationOutcome,
+  continueGoalWorkloop,
+  delegateToCodexCerebellum,
+  dismissHandoffItem,
+  finalizeGoalWorkloop,
+  getHandoffItem,
+  getWorkContract,
+  listHandoffItems,
+  listWorkContracts,
+  normalizeCheckIds,
+  resolveHandoffItem,
+  routeWorkStart,
+  runSelfHealingLoop,
+  selectExecutionMode,
+  stopGoalWorkloop,
+  summarizeHandoffItem,
+  summarizeWorkContract,
+  verifyGoalWorkloop,
+  type ExecutionModeSelectionInput,
+  type FacadeResult,
+  type HandoffItem,
+  type SuggestedNextAction,
+  type WorkContract,
+} from '../../runtime/control-plane/facade';
+import { buildRuntimeMaintenanceStatus } from '../../runtime/recovery';
+import { applySafePatch } from '../repositories/safe-patch';
+import { withControllerLock } from '../repositories/locks';
+import { loadMcpServiceLocalConfig, loadMcpServiceRuntimeState } from '../mcp/auth';
+import {
+  buildLocalConnectorStatusForRepo,
+  EXPECTED_FACADE_TOOLS,
+  type ConnectorFreshnessReport,
+} from './connector-freshness';
+import { controllerExposedToolNames } from '../mcp/toolset';
+import {
+  statusLabelForPhase,
+  type UserFacingErrorClass,
+  type UserFacingPhase,
+} from '../../runtime/control-plane/facade/operation-digest';
+import { repositoryGitStatus } from '../repositories/structured-git';
+import { listExecutionJobs } from '../../runtime/execution/jobs/store';
+import {
+  createConnectivityObservation,
+  deriveExecutionJobTimingSnapshots,
+  recordConnectivityProbe,
+  type ConnectivityComponentObservation,
+} from '../../runtime/diagnostics/connectivity-observability';
+import type {
+  ChangedFileEntryViewModel,
+  ChangedFilesSummaryViewModel,
+  CommandCenterViewModel,
+  ConnectorFreshnessViewModel,
+  ConsoleErrorViewModel,
+  GoalLoopStatusViewModel,
+  HandoffCardViewModel,
+  ModePreviewViewModel,
+  PlainStatusTone,
+  PluginActionViewModel,
+  AccessStateViewModel,
+  PluginCardViewModel,
+  PluginSummaryViewModel,
+  RepositoryCardViewModel,
+  SuggestedActionViewModel,
+  SystemReadinessViewModel,
+  VerificationViewModel,
+  WorkSummaryViewModel,
+} from './console-view-models';
+import {
+  buildAutomationSettingsView,
+  executorRoutePreviewWithConfig,
+  executorRoutingConfigGet,
+  executorRoutingConfigReset,
+  executorRoutingConfigUpdate,
+  goalLoopPolicyGet,
+  goalLoopPolicyUpdate,
+  goalStatus as goalLoopStatusSnapshot,
+  localToolDisable,
+  localToolEnable,
+  localToolHealthCheck,
+  localToolList,
+  localToolConfigGet,
+  localToolConfigUpdate,
+  providerApiSettingsGet,
+  providerApiSettingsUpdate,
+  providerConfigGet,
+  providerConfigUpdate,
+  providerCredentialsStatus,
+  providerDisable,
+  providerEnable,
+  providerHealthCheck,
+  providerPriorityUpdate,
+  providerResetDefaults,
+  type ConfigFacadeContext,
+  type GoalLoopContext,
+} from '../../runtime/control-plane/goal-loop';
+import { listActiveOccurrences, listSchedules } from '../../runtime/workflow/schedules/store';
+
+export type ConsoleFacadeContext = {
+  controllerHome: string;
+  repository: RepositoryRecord;
+};
+
+function store(ctx: ConsoleFacadeContext) {
+  return { controllerHome: ctx.controllerHome, repoId: ctx.repository.repoId };
+}
+
+function plainMode(mode: ModePreviewViewModel['mode']): ModePreviewViewModel {
+  if (mode === 'direct_control') {
+    return {
+      mode,
+      label: '直接执行',
+      explanation: '小范围、目标清晰的改动；适合由 ChatGPT 直接监督完成。',
+      createWorkContract: false,
+      createHandoff: false,
+    };
+  }
+  if (mode === 'handoff_only') {
+    return {
+      mode,
+      label: '需要你先决定',
+      explanation: '目标不清、风险较高或缺少授权；执行前需要你的判断。',
+      createWorkContract: false,
+      createHandoff: true,
+    };
+  }
+  return {
+    mode: 'goal_workloop',
+    label: '可恢复的后台任务',
+    explanation: '多步骤或需要恢复/隔离的任务；会创建工作项并支持继续、验证与收尾。',
+    createWorkContract: true,
+    createHandoff: false,
+  };
+}
+
+function mapSuggested(actions: SuggestedNextAction[] = []): SuggestedActionViewModel[] {
+  return actions.slice(0, 8).map((action, index) => {
+    const op = action.operation;
+    const kind: SuggestedActionViewModel['kind'] =
+      op === 'continue' ? 'continue'
+        : op === 'verify' ? 'verify'
+          : op === 'finalize' ? 'finalize'
+            : op === 'stop' ? 'stop'
+              : op === 'delegate' ? 'delegate'
+                : op === 'repair' || op === 'diagnose' ? 'repair'
+                  : op === 'resolve' ? 'resolve'
+                    : op === 'dismiss' ? 'dismiss'
+                      : op === 'get' || op === 'list' ? 'open'
+                        : 'other';
+    return {
+      id: `${action.tool}-${op}-${index}`,
+      label: action.label,
+      kind,
+      tool: action.tool,
+      operation: action.operation,
+      payload: action.payload,
+      primary: index === 0,
+    };
+  });
+}
+
+function workStatusLabel(status: WorkContract['status']): { label: string; tone: PlainStatusTone; phase: UserFacingPhase } {
+  switch (status) {
+    case 'running': return { label: '进行中', tone: 'blue', phase: 'running' };
+    case 'open': return { label: '待开始', tone: 'gray', phase: 'queued' };
+    case 'blocked': return { label: '已阻塞', tone: 'red', phase: 'blocked' };
+    case 'ready': return { label: '需要你审阅', tone: 'amber', phase: 'needs_attention' };
+    case 'completed': return { label: '已完成', tone: 'green', phase: 'succeeded' };
+    case 'failed': return { label: '未通过验收', tone: 'red', phase: 'failed' };
+    case 'cancelled': return { label: '已停止', tone: 'gray', phase: 'cancelled' };
+    default: return { label: String(status), tone: 'gray', phase: 'running' };
+  }
+}
+
+const ERROR_COPY: Record<UserFacingErrorClass, { title: string; explanation: string; nextActions: string[] }> = {
+  controller_unavailable: {
+    title: '控制器暂不可用',
+    explanation: '后台控制器未就绪，暂时无法执行任务。',
+    nextActions: ['查看系统状态', '运行诊断', '重启 controller'],
+  },
+  connector_stale: {
+    title: '连接器可能过期',
+    explanation: '本地 MCP 与 ChatGPT 工具快照可能不一致；若 ChatGPT 里看不到 rh_* 请重连。',
+    nextActions: ['查看连接器诊断', '重启 MCP', '重连 ChatGPT Connector'],
+  },
+  infrastructure_failure: {
+    title: '环境/基础设施问题',
+    explanation: '失败来自运行环境（进程、存储、检查命令），不是业务验收本身。',
+    nextActions: ['运行修复诊断', '查看高级诊断', '稍后重试'],
+  },
+  acceptance_failure: {
+    title: '验收未通过',
+    explanation: '检查已运行，但结果不符合验收标准。',
+    nextActions: ['查看失败原因', '继续修改', '再次验证'],
+  },
+  invalid_check_id: {
+    title: '检查项无效',
+    explanation: '指定的检查 ID 未注册或不存在。',
+    nextActions: ['选择有效检查', '查看系统状态'],
+  },
+  approval_required: {
+    title: '需要你授权',
+    explanation: '该操作风险较高，需明确授权后才能继续。',
+    nextActions: ['查看待决定', '确认后继续'],
+  },
+  handoff_required: {
+    title: '需要你做决定',
+    explanation: '任务停在决策点，不能自动往下走。',
+    nextActions: ['打开待决定', '记录决定后继续'],
+  },
+  timeout: {
+    title: '执行超时',
+    explanation: '操作在限定时间内未完成。',
+    nextActions: ['重试', '运行诊断', '查看高级详情'],
+  },
+  policy_denied: {
+    title: '策略拒绝',
+    explanation: '当前策略不允许该操作。',
+    nextActions: ['调整范围', '查看高级诊断'],
+  },
+  not_found: {
+    title: '未找到目标',
+    explanation: '任务、仓库或资源不存在或已清理。',
+    nextActions: ['刷新控制台', '重新选择仓库或任务'],
+  },
+  unknown_failure: {
+    title: '出现未知错误',
+    explanation: '操作失败，但尚未归类到具体原因。',
+    nextActions: ['重试', '运行诊断', '查看高级详情'],
+  },
+};
+
+export function describeConsoleError(
+  errorClass: UserFacingErrorClass,
+  detail?: string,
+): ConsoleErrorViewModel {
+  const copy = ERROR_COPY[errorClass] ?? ERROR_COPY.unknown_failure;
+  const explanation = detail && detail.trim() && detail.trim() !== 'undefined'
+    ? `${copy.explanation} ${detail.trim().slice(0, 180)}`
+    : copy.explanation;
+  return {
+    errorClass,
+    title: copy.title,
+    explanation,
+    nextActions: copy.nextActions,
+  };
+}
+
+export function summarizeChangedFiles(paths: readonly string[]): ChangedFilesSummaryViewModel | undefined {
+  const unique = [...new Set(paths.map((entry) => String(entry || '').trim()).filter(Boolean))].slice(0, 40);
+  if (!unique.length) return undefined;
+  const files: ChangedFileEntryViewModel[] = unique.map((path) => {
+    let status: ChangedFileEntryViewModel['status'] = 'modified';
+    if (path.startsWith('A ') || path.includes('(new)') || path.startsWith('+')) status = 'added';
+    else if (path.startsWith('D ') || path.includes('(deleted)') || path.startsWith('-')) status = 'deleted';
+    else if (path.startsWith('R ') || path.includes(' -> ')) status = 'renamed';
+    const clean = path.replace(/^[AMD?R]\s+/, '').replace(/^\+/, '').replace(/^-/, '').trim();
+    return {
+      path: clean || path,
+      status,
+      statusLabel: status === 'added' ? '新增' : status === 'deleted' ? '删除' : status === 'renamed' ? '重命名' : '修改',
+    };
+  });
+  const added = files.filter((entry) => entry.status === 'added').length;
+  const deleted = files.filter((entry) => entry.status === 'deleted').length;
+  const modified = files.length - added - deleted;
+  const parts: string[] = [];
+  if (modified) parts.push(`修改 ${modified}`);
+  if (added) parts.push(`新增 ${added}`);
+  if (deleted) parts.push(`删除 ${deleted}`);
+  if (!parts.length) parts.push(`${files.length} 个文件`);
+  return {
+    total: files.length,
+    modified,
+    added,
+    deleted,
+    files,
+    summaryLabel: parts.join(' · '),
+  };
+}
+
+function extractChangedPathsFromWork(
+  work: WorkContract,
+  opts: { controllerHome: string; repoId: string } | null = null,
+): string[] {
+  const paths: string[] = [];
+  for (const evidence of work.evidenceRefs ?? []) {
+    const blob = `${evidence.title ?? ''} ${evidence.summary ?? ''}`;
+    for (const match of blob.matchAll(/(?:^|[\s`])([A-Za-z0-9_./-]+\.[A-Za-z0-9]+)(?:$|[\s`,])/g)) {
+      if (match[1] && !match[1].startsWith('http')) paths.push(match[1]);
+    }
+  }
+  if (opts) {
+    for (const handoffId of work.handoffRefs ?? []) {
+      try {
+        const item = getHandoffItem({ controllerHome: opts.controllerHome, repoId: opts.repoId }, handoffId);
+        for (const path of item?.currentState?.changedFiles ?? []) {
+          if (path) paths.push(path);
+        }
+      } catch {
+        // ignore missing handoffs
+      }
+    }
+  }
+  return paths;
+}
+
+function progressSteps(work: WorkContract): WorkSummaryViewModel['progressSteps'] {
+  const checks = work.checkRefs ?? [];
+  const hasPass = checks.some((entry) => entry.outcome === 'valid_pass');
+  const hasFail = checks.some((entry) => entry.outcome === 'valid_fail');
+  const hasDelegate = Boolean(work.workerRef);
+  const review = work.status === 'ready';
+  const done = work.status === 'completed';
+  const failed = work.status === 'failed';
+  const cancelled = work.status === 'cancelled';
+  return [
+    { label: '已开始', done: true, active: work.status === 'running' && !hasDelegate && !hasPass },
+    { label: '已委派助手', done: hasDelegate, active: hasDelegate && !hasPass && !review },
+    { label: '已提出修改', done: hasDelegate || hasPass || hasFail, active: false },
+    { label: '已验证', done: hasPass || hasFail, active: hasFail && !review },
+    { label: '等待审阅', done: review || done, active: review },
+    { label: done ? '已完成' : failed ? '验收失败' : cancelled ? '已停止' : '收尾', done: done || failed || cancelled, active: false },
+  ];
+}
+
+function latestVerification(work: WorkContract): VerificationViewModel | undefined {
+  const record = work.checkRefs[0];
+  if (!record) return undefined;
+  const isAcceptanceFailure = record.outcome === 'valid_fail';
+  const isInfrastructureIssue = record.outcome === 'infrastructure_failure' || record.outcome === 'invalid_check_id';
+  const tone: PlainStatusTone = record.outcome === 'valid_pass' ? 'green'
+    : isAcceptanceFailure ? 'red'
+      : isInfrastructureIssue ? 'amber'
+        : 'gray';
+  const label = record.outcome === 'valid_pass' ? '检查通过'
+    : record.outcome === 'valid_fail' ? '检查未通过'
+      : record.outcome === 'infrastructure_failure' ? '环境问题'
+        : record.outcome === 'invalid_check_id' ? '检查项无效'
+          : record.outcome === 'superseded' ? '已被后续结果覆盖'
+            : '已跳过';
+  return {
+    label,
+    tone,
+    outcome: record.outcome,
+    checkLabel: record.checkId,
+    isAcceptanceFailure,
+    isInfrastructureIssue,
+    summary: record.summary,
+  };
+}
+
+export function mapWorkSummary(
+  work: WorkContract,
+  opts: { controllerHome?: string; repoId?: string } = {},
+): WorkSummaryViewModel {
+  const status = workStatusLabel(work.status);
+  const mode = plainMode(work.mode === 'direct_control' || work.mode === 'handoff_only' ? work.mode : 'goal_workloop');
+  const verification = latestVerification(work);
+  const suggested = mapSuggested(work.suggestedNextActions);
+  const nextAction = suggested[0]?.label
+    ?? (work.status === 'ready' ? '请审阅后继续或收尾'
+      : work.status === 'running' ? '继续或运行检查'
+        : work.status === 'completed' ? '任务已完成'
+          : work.status === 'failed' ? '查看失败原因并决定是否重试'
+            : '查看任务状态');
+  const storeOpts = opts.controllerHome && opts.repoId
+    ? { controllerHome: opts.controllerHome, repoId: opts.repoId }
+    : null;
+  const changedFiles = summarizeChangedFiles(extractChangedPathsFromWork(work, storeOpts));
+  let error: ConsoleErrorViewModel | undefined;
+  if (work.status === 'failed') {
+    error = describeConsoleError(
+      verification?.isInfrastructureIssue ? 'infrastructure_failure' : 'acceptance_failure',
+      verification?.summary,
+    );
+  } else if (work.status === 'blocked' || work.status === 'ready') {
+    error = describeConsoleError(
+      'handoff_required',
+      work.suggestedNextActions[0]?.reason,
+    );
+  }
+  const latestSummary = verification?.summary
+    || work.evidenceRefs[0]?.summary
+    || work.evidenceRefs[0]?.title
+    || (work.status === 'running' ? '任务执行中…' : status.label);
+  return {
+    id: work.workId,
+    title: work.objective.slice(0, 160) || '未命名任务',
+    objective: work.objective,
+    modeLabel: mode.label,
+    mode: mode.mode,
+    accessMode: work.constraints.accessMode ?? 'full_access',
+    accessModeLabel: accessModeDescriptor(work.constraints.accessMode ?? 'full_access').shortLabel,
+    statusLabel: status.label,
+    tone: status.tone,
+    phase: status.phase,
+    phaseLabel: statusLabelForPhase(status.phase),
+    nextAction,
+    latestAction: suggested[0]?.label || nextAction,
+    latestSummary,
+    progressSteps: progressSteps(work),
+    latestVerification: verification,
+    acceptanceCriteria: work.acceptanceCriteria.slice(0, 8),
+    evidenceLabels: work.evidenceRefs.slice(0, 6).map((entry) => entry.title || entry.summary || '证据'),
+    changedFiles,
+    error,
+    delegateSummary: work.workerRef
+      ? `已委派小助手（${work.workerRef.split(':')[0] ?? 'worker'}），等待 ChatGPT 审阅后才能收尾。`
+      : undefined,
+    suggestedActions: suggested,
+    primaryActionLabel: suggested[0]?.label,
+    advanced: {
+      workId: work.workId,
+      status: work.status,
+      checkIds: work.checks,
+      handoffRefs: work.handoffRefs,
+    },
+  };
+}
+
+function handoffTone(severity: HandoffItem['severity']): PlainStatusTone {
+  if (severity === 'blocked' || severity === 'failed') return 'red';
+  if (severity === 'needs_review') return 'amber';
+  if (severity === 'ready_to_continue') return 'green';
+  return 'blue';
+}
+
+function describeHandoffDecision(item: HandoffItem): HandoffCardViewModel['decision'] {
+  const reason = item.creationReason;
+  const isApproval = reason === 'policy_approval_required' || reason === 'destructive_action_requires_confirmation';
+  const approvalAction = item.approvalAction;
+  const canApproveAndContinue = isApproval
+    && (item.status === 'pending' || item.status === 'acknowledged')
+    && approvalAction?.operation === 'start';
+  if (isApproval) {
+    const destructive = reason === 'destructive_action_requires_confirmation' || approvalAction?.risk === 'destructive';
+    const payload = approvalAction?.payload ?? {};
+    const objective = typeof payload.objective === 'string' ? payload.objective.trim() : '';
+    const allowedPaths = Array.isArray(payload.allowedPaths) ? payload.allowedPaths.map(String).filter(Boolean) : [];
+    const expectedFiles = typeof payload.expectedFiles === 'number' ? payload.expectedFiles : undefined;
+    const scopeSummary = allowedPaths.length
+      ? `允许修改：${allowedPaths.slice(0, 4).join('、')}${allowedPaths.length > 4 ? ' 等' : ''}`
+      : '修改范围仍受原任务描述和仓库策略限制';
+    const estimate = expectedFiles === undefined ? '' : `；预计涉及约 ${expectedFiles} 个文件`;
+    return {
+      type: 'approval',
+      typeLabel: destructive ? '高风险操作审批' : '执行授权',
+      requestedAction: approvalAction?.operation === 'start' && objective
+        ? `创建任务并继续处理：“${objective.slice(0, 240)}”`
+        : item.blockingDecision || item.summary,
+      necessityLabel: '必须确认',
+      necessityExplanation: destructive
+        ? '此操作包含高风险或潜在不可逆副作用，系统不能替你默认同意。'
+        : '当前安全策略要求显式授权；缩小范围或改为只读预览后可避免本次审批。',
+      impact: approvalAction?.operation === 'start'
+        ? `批准后会创建正式任务。${scopeSummary}${estimate}。`
+        : '当前审批没有保存可安全重放的具体动作，因此不能自动续跑。',
+      afterApproval: canApproveAndContinue
+        ? '系统会记录批准、立即创建任务并打开任务详情；接下来会明确显示继续、委派、验证或收尾动作，不代表任务已经完成。'
+        : '只会记录你的决定，不会自动执行。请按人工继续提示处理，或重新提交范围明确的任务。',
+      ifRejected: '相关操作保持未执行；你可以缩小范围、改成预览、补充信息或取消。',
+      canApproveAndContinue,
+      primaryActionLabel: canApproveAndContinue ? '批准并创建任务' : '仅记录决定',
+    };
+  }
+  if (reason === 'missing_authorization') {
+    return {
+      type: 'authorization',
+      typeLabel: '缺少权限',
+      requestedAction: item.blockingDecision || item.summary,
+      necessityLabel: '不是审批',
+      necessityExplanation: '系统缺少执行所需的账号、插件或仓库权限；单击“批准”不能补齐权限。',
+      impact: '补齐权限后需要重新检查任务，系统才会决定是否继续。',
+      afterApproval: '配置或授权完成后，返回任务页重新运行检查或继续任务。',
+      ifRejected: '任务保持阻塞，但不会产生额外副作用。',
+      canApproveAndContinue: false,
+      primaryActionLabel: '记录处理结果',
+    };
+  }
+  if (reason === 'invalid_objective') {
+    return {
+      type: 'clarification',
+      typeLabel: '需要补充范围',
+      requestedAction: item.blockingDecision || item.summary,
+      necessityLabel: '需要澄清',
+      necessityExplanation: '目标或修改边界不足，继续执行可能偏离你的真实需求。',
+      impact: '补充目标、允许路径和验收标准后，系统会重新选择执行方式。',
+      afterApproval: '此项不能通过“批准”自动解决，需要修改任务描述后重新提交。',
+      ifRejected: '当前请求不会执行。',
+      canApproveAndContinue: false,
+      primaryActionLabel: '记录补充说明',
+    };
+  }
+  return {
+    type: 'review',
+    typeLabel: '结果审阅',
+    requestedAction: item.blockingDecision || item.summary,
+    necessityLabel: '需要判断',
+    necessityExplanation: '系统遇到了验收失败、结果歧义或助手产出，需要你选择修复、调整范围或停止。',
+    impact: '你的决定会影响下一步采用修复、重新验证还是结束任务。',
+    afterApproval: '记录决定后，请从相关任务进入对应的修复、验证或收尾动作。',
+    ifRejected: '任务保持在审阅状态，不会自动继续。',
+    canApproveAndContinue: false,
+    primaryActionLabel: '记录审阅决定',
+  };
+}
+
+export function mapHandoffCard(item: HandoffItem): HandoffCardViewModel {
+  return {
+    id: item.id,
+    title: item.title,
+    reason: item.reason,
+    recommendedDecision: item.recommendedDecision,
+    continuationPrompt: item.recommendedContinuationPrompt || item.recommendedPrompt,
+    severityLabel: item.severity === 'needs_review' ? '需要判断'
+      : item.severity === 'blocked' ? '已阻塞'
+        : item.severity === 'failed' ? '失败'
+          : item.severity === 'ready_to_continue' ? '可继续'
+            : '提示',
+    tone: handoffTone(item.severity),
+    statusLabel: item.status === 'pending' ? '待处理'
+      : item.status === 'acknowledged' ? '已确认'
+        : item.status === 'resolved' ? '已解决'
+          : item.status === 'dismissed' ? '已忽略'
+            : item.status,
+    workTitle: item.currentState.statusSummary,
+    attemptedActions: item.attemptedActions ?? [],
+    evidenceLabels: item.evidenceRefs.map((entry) => entry.title || '证据').slice(0, 6),
+    suggestedActions: mapSuggested(item.suggestedNextActions),
+    decision: describeHandoffDecision(item),
+    advanced: {
+      handoffId: item.id,
+      workId: item.workId,
+      creationReason: item.creationReason,
+    },
+  };
+}
+
+export function previewExecutionMode(input: ExecutionModeSelectionInput & { objective?: string }): ModePreviewViewModel {
+  const selection = selectExecutionMode(input);
+  return {
+    ...plainMode(selection.mode),
+    createWorkContract: selection.createWorkContract,
+    createHandoff: selection.createHandoff,
+    explanation: selection.reason.includes('Small') || selection.reason.includes('small')
+      ? plainMode(selection.mode).explanation
+      : plainMode(selection.mode).explanation,
+  };
+}
+
+function displayPath(path: string): string {
+  const home = process.env.HOME?.trim();
+  if (home && path.startsWith(home)) return `~${path.slice(home.length)}`;
+  return path;
+}
+
+export function mapRepositoryCard(
+  repository: RepositoryRecord,
+  current: boolean,
+): RepositoryCardViewModel {
+  let branchLabel: string | undefined;
+  let dirtyLabel: string | undefined;
+  let readinessLabel: string | undefined;
+  if (current || repository.enabled !== false) {
+    try {
+      const git = repositoryGitStatus(repository);
+      branchLabel = git.branch || repository.defaultBranch || 'detached';
+      dirtyLabel = git.clean ? '工作区干净' : '有未提交变更';
+      readinessLabel = repository.enabled === false ? '已停用' : git.clean ? '可执行' : '可执行（脏工作区）';
+    } catch {
+      branchLabel = repository.defaultBranch || undefined;
+      readinessLabel = repository.enabled === false ? '已停用' : '可用';
+    }
+  }
+  return {
+    id: repository.repoId,
+    name: repository.displayName || repository.repoId,
+    path: displayPath(repository.canonicalRoot),
+    statusLabel: current ? '当前' : repository.enabled === false ? '已停用' : '可用',
+    tone: current ? 'green' : repository.enabled === false ? 'gray' : 'blue',
+    current,
+    branchLabel,
+    dirtyLabel,
+    readinessLabel,
+    advanced: {
+      repoId: repository.repoId,
+      remote: repository.remoteUrl,
+      defaultBranch: repository.defaultBranch,
+      checkoutId: repository.activeCheckoutId,
+    },
+  };
+}
+
+function mapConnectorFreshnessView(report: ConnectorFreshnessReport): ConnectorFreshnessViewModel {
+  return {
+    status: report.status,
+    severity: report.severity,
+    summary: report.summary,
+    expectedFacadeTools: report.expectedFacadeTools,
+    missingLocalTools: report.missingLocalTools,
+    missingConnectorTools: report.missingConnectorTools,
+    restartRecommended: report.restartRecommended,
+    reconnectRecommended: report.reconnectRecommended,
+    howToFix: report.howToFix,
+    suggestedActions: report.suggestedActions,
+    diagnosticScope: report.diagnosticScope,
+    localRegistryVerified: report.localRegistryVerified,
+    connectorCallability: report.connectorCallability,
+    connectorMismatch: report.connectorMismatch,
+  };
+}
+
+function accessToolGroups(_mode: AccessMode): string[] {
+  // Access mode controls approval behavior only. Tool discovery stays stable so
+  // changing Request/Full Access never requires an MCP reconnect.
+  return [
+    'status_and_readiness',
+    'repository_selection',
+    'approval_and_handoffs',
+    'access_control_plane',
+    'repository_reads',
+    'repository_writes_and_patches',
+    'commands_and_checks',
+    'git_and_branches',
+    'worktrees_and_task_runs',
+    'direct_edit_sessions',
+    'ios_xcode_and_simulator',
+    'screenshots_and_review_artifacts',
+  ];
+}
+
+function controllerAccessStateView(ctx: ConsoleFacadeContext): AccessStateViewModel {
+  const configured = resolveControllerAccessState({
+    controllerHome: ctx.controllerHome,
+    repoRoot: ctx.repository.canonicalRoot,
+  });
+  const toolCtx = createMcpToolContext({
+    repo: ctx.repository.canonicalRoot,
+    controllerHome: ctx.controllerHome,
+    profile: 'controller',
+  }) as MultiRepositoryMcpToolContext;
+  const effective = resolveControllerAccessState({
+    controllerHome: ctx.controllerHome,
+    repoRoot: ctx.repository.canonicalRoot,
+    toolsetOverride: toolCtx.toolset,
+    toolsetLocked: toolCtx.toolsetLocked,
+  });
+  const repositoryPolicy = readRepositoryAccessPolicy(ctx.controllerHome, ctx.repository.repoId);
+  const runtimeGeneration = readRuntimeGeneration(ctx.controllerHome);
+  // Runtime Source is controller-scoped; execution repository is not the current source.
+  const drift = evaluateActiveRuntimeSourceDrift(runtimeGeneration?.source);
+  return {
+    configuredAccessMode: configured.configuredAccessMode,
+    configuredAccessModeLabel: accessModeDescriptor(configured.configuredAccessMode).shortLabel,
+    effectiveAccessMode: effective.effectiveAccessMode,
+    effectiveAccessModeLabel: accessModeDescriptor(effective.effectiveAccessMode).shortLabel,
+    effectiveToolset: effective.effectiveToolset,
+    exposureRevision: configured.exposureRevision,
+    lastAppliedAt: configured.lastAppliedAt,
+    source: effective.source,
+    reconnectRequired: false,
+    schemaRefreshRequired: false,
+    toolSchemaStable: true,
+    restartRequired: drift.restartRequired,
+    repositoryPolicyMode: repositoryPolicy.mode,
+    repositoryPolicyLabel: accessModeDescriptor(repositoryPolicy.mode).shortLabel,
+    toolGroups: accessToolGroups(effective.effectiveAccessMode),
+  };
+}
+
+/**
+ * Evaluate local MCP tool-surface freshness for the console.
+ * Probes live MCP /health; does not invent ChatGPT connector tool names.
+ */
+export async function evaluateConsoleConnectorFreshness(
+  ctx: ConsoleFacadeContext,
+  opts: { connectorToolNames?: readonly string[] | null } = {},
+): Promise<ConnectorFreshnessReport> {
+  const toolCtx = createMcpToolContext({
+    repo: ctx.repository.canonicalRoot,
+    controllerHome: ctx.controllerHome,
+    profile: 'controller',
+  }) as MultiRepositoryMcpToolContext;
+  const expected = controllerExposedToolNames(toolCtx);
+  return buildLocalConnectorStatusForRepo({
+    repoRoot: ctx.repository.canonicalRoot,
+    expectedTools: expected,
+    connectorToolNames: opts.connectorToolNames,
+  });
+}
+
+export async function buildSystemReadiness(
+  ctx: ConsoleFacadeContext,
+  opts: { connectorToolNames?: readonly string[] | null } = {},
+): Promise<SystemReadinessViewModel> {
+  const runtime = observeRuntimeStatus(ctx.controllerHome);
+  const runtimeHealth = undefined;
+  const freshness = await evaluateConsoleConnectorFreshness(ctx, {
+    connectorToolNames: opts.connectorToolNames,
+  });
+  const handoffs = listHandoffItems({ ...store(ctx), status: 'all', limit: 100 });
+  const pendingHandoffCount = handoffs.filter((item) => item.status === 'pending').length;
+  const checks = listControllerChecks(ctx.repository.canonicalRoot);
+  const automation = buildAutomationReadinessSection(ctx);
+  const sections: SystemReadinessViewModel['sections'] = [
+    {
+      id: 'controller',
+      title: '控制器',
+      statusLabel: runtime.ready ? '就绪' : runtime.running ? '启动中' : '未运行',
+      tone: runtime.ready ? 'green' : 'red',
+      detail: runtime.ready
+        ? 'Canonical Runtime 已通过完整就绪检查。'
+        : runtime.reasonCodes.join('、') || 'Canonical Runtime 尚未就绪。',
+    },
+    {
+      id: 'connector',
+      title: 'ChatGPT 连接',
+      statusLabel: freshness.sectionStatusLabel,
+      tone: freshness.connectorTone,
+      detail: freshness.sectionDetail,
+    },
+    {
+      id: 'bridge',
+      title: '本地控制台',
+      statusLabel: runtime.running ? '已连接' : '不可用',
+      tone: runtime.running ? 'green' : 'red',
+      detail: runtime.running
+        ? '本地控制台正在读取同一 Canonical Runtime 状态。'
+        : 'Canonical Runtime 未运行，本地控制台不发布独立健康状态。',
+    },
+    {
+      id: 'repository',
+      title: '仓库',
+      statusLabel: ctx.repository.enabled === false ? '不可用' : '可用',
+      tone: ctx.repository.enabled === false ? 'red' : 'green',
+      detail: displayPath(ctx.repository.canonicalRoot),
+    },
+    {
+      id: 'checks',
+      title: '检查项',
+      statusLabel: checks.length ? `${checks.length} 个可用` : '未配置',
+      tone: checks.length ? 'green' : 'amber',
+      detail: checks.length ? '可运行注册检查验证结果。' : '尚未发现可用检查脚本。',
+    },
+    {
+      id: 'handoffs',
+      title: '待你决定',
+      statusLabel: pendingHandoffCount ? `${pendingHandoffCount} 项` : '无',
+      tone: pendingHandoffCount ? 'amber' : 'green',
+      detail: pendingHandoffCount ? '有事项需要你的判断后才能继续。' : '没有待处理决策。',
+    },
+    automation,
+  ];
+  const blocked = !runtime.ready;
+  const needsSetup = ctx.repository.enabled === false;
+  const state: SystemReadinessViewModel['state'] = blocked ? 'blocked' : needsSetup ? 'needs_setup' : 'ready';
+  return {
+    state,
+    label: state === 'ready' ? '就绪' : state === 'needs_setup' ? '需要设置' : '暂不可用',
+    headline: state === 'ready' ? '系统可用' : state === 'needs_setup' ? '完成设置后即可开始' : '系统暂不可用',
+    description: state === 'ready'
+      ? '你可以输入自然语言任务，或先处理待决定事项。'
+      : state === 'needs_setup'
+        ? '请先选择或注册一个可用仓库。'
+        : '请先查看系统状态并尝试诊断/修复。',
+    connectorLabel: freshness.connectorLabel,
+    connectorTone: freshness.connectorTone,
+    connectorFreshness: mapConnectorFreshnessView(freshness),
+    pendingHandoffCount,
+    runtimeHealth,
+    operationalView: undefined,
+    sections,
+  };
+}
+
+function buildAutomationReadinessSection(
+  ctx: ConsoleFacadeContext,
+): SystemReadinessViewModel['sections'][number] {
+  const schedules = listSchedules(ctx.controllerHome, ctx.repository.repoId).filter((schedule) => schedule.enabled);
+  const shadowSchedules = schedules.filter((schedule) => schedule.policy.shadowMode);
+  const liveSchedules = schedules.filter((schedule) => !schedule.policy.shadowMode);
+  const liveScheduleIds = new Set(liveSchedules.map((schedule) => schedule.scheduleId));
+  const activeLiveOccurrences = listActiveOccurrences(ctx.controllerHome, ctx.repository.repoId)
+    .filter((occurrence) => liveScheduleIds.has(occurrence.scheduleId)
+      && ['created', 'queued', 'running'].includes(occurrence.status))
+    .length;
+
+  if (schedules.length === 0) {
+    return {
+      id: 'automation',
+      title: '自治调度',
+      statusLabel: '未配置',
+      tone: 'gray',
+      detail: '当前“就绪”只表示控制器可以接受任务；没有启用中的 live schedule 在后台自治执行。',
+    };
+  }
+
+  if (liveSchedules.length === 0) {
+    return {
+      id: 'automation',
+      title: '自治调度',
+      statusLabel: `${shadowSchedules.length} 个影子计划`,
+      tone: 'amber',
+      detail: '已启用的 schedule 全部处于 shadow mode：它们只记录 would_execute / shadowed 结果，不会排队或启动 Execution Job。',
+    };
+  }
+
+  const liveLabel = shadowSchedules.length > 0
+    ? `live ${liveSchedules.length} / shadow ${shadowSchedules.length}`
+    : `${liveSchedules.length} 个 live 计划`;
+  const liveDetail = activeLiveOccurrences > 0
+    ? `当前有 ${activeLiveOccurrences} 个 live occurrence 正在 created/queued/running。`
+    : '当前没有 live occurrence 在 created/queued/running。';
+  return {
+    id: 'automation',
+    title: '自治调度',
+    statusLabel: liveLabel,
+    tone: 'green',
+    detail: `只有 live schedule 在触发条件满足时才会排队 bounded execution。${shadowSchedules.length > 0 ? ' shadow schedule 仍然只做记录。' : ''} ${liveDetail}`,
+  };
+}
+
+function riskLabel(risk: string): string {
+  if (risk === 'readonly') return '只读';
+  if (risk === 'workspace_write') return '本地写入';
+  if (risk === 'remote_write') return '远程写入';
+  if (risk === 'destructive') return '破坏性';
+  return risk || '未知';
+}
+
+function confirmationLabel(confirmation: string): string {
+  if (confirmation === 'none') return '无需确认';
+  if (confirmation === 'authorization') return '需要授权确认';
+  if (confirmation === 'strong_confirmation') return '需要强确认';
+  return confirmation || '未知';
+}
+
+function mapPluginAction(action: AssistantPluginManifest['actions'][number]): PluginActionViewModel {
+  return {
+    id: action.actionId,
+    title: action.title || action.actionId,
+    description: action.description || '',
+    risk: action.risk,
+    riskLabel: riskLabel(action.risk),
+    readOnly: action.readOnly === true || action.risk === 'readonly',
+    confirmation: action.confirmation,
+    confirmationLabel: confirmationLabel(action.confirmation),
+    canPreview: action.readOnly === true || action.risk === 'readonly' || action.actionId === 'configure' || action.actionId === 'auth_status',
+    requiredConfirmationText: action.requiredConfirmationText,
+  };
+}
+
+export function mapPluginCard(manifest: AssistantPluginManifest): PluginCardViewModel {
+  const health = manifest.health;
+  const lifecycle = manifest.lifecycle;
+  const ready = manifest.enabled !== false
+    && health.ready !== false
+    && health.state !== 'error'
+    && lifecycle.state !== 'error';
+  const needsAuthorization = [...(health.errors ?? []), ...(health.warnings ?? []), lifecycle.reason ?? '']
+    .some((entry) => /auth|token|credential|permission|scope|授权|登录/i.test(String(entry)));
+  const status: PluginCardViewModel['status'] = manifest.enabled === false
+    ? 'disabled'
+    : ready
+      ? 'ready'
+      : needsAuthorization
+        ? 'authorization_required'
+        : health.state === 'error' || lifecycle.state === 'error'
+          ? 'failed'
+          : 'needs_setup';
+  const tone: PlainStatusTone = status === 'ready'
+    ? 'green'
+    : status === 'failed'
+      ? 'red'
+      : status === 'disabled'
+        ? 'gray'
+        : 'amber';
+  const nextStep = status === 'ready'
+    ? '已连接，可用于任务执行'
+    : status === 'authorization_required'
+      ? '需要完成授权后才能使用'
+      : status === 'disabled'
+        ? '插件已禁用'
+        : '需要配置并测试连接';
+  const actions = manifest.actions.map(mapPluginAction);
+  return {
+    id: manifest.pluginId,
+    name: manifest.displayName || manifest.pluginId,
+    provider: manifest.provider,
+    status,
+    statusLabel: status === 'ready'
+      ? '可用'
+      : status === 'authorization_required'
+        ? '待授权'
+        : status === 'failed'
+          ? '异常'
+          : status === 'disabled'
+            ? '已禁用'
+            : '需配置',
+    tone,
+    enabled: manifest.enabled !== false,
+    actionCount: actions.length,
+    description: `${actions.length} 个可用动作 · ${manifest.provider}`,
+    nextStep,
+    healthLabel: health.state || 'unknown',
+    lifecycleLabel: lifecycle.state || 'unknown',
+    capabilityLabels: (manifest.capabilities ?? []).slice(0, 6).map((entry) => entry.title || entry.capabilityId),
+    actions,
+    warnings: [...(health.warnings ?? []), ...(health.errors ?? [])].slice(0, 6).map(String),
+    advanced: {
+      pluginId: manifest.pluginId,
+      provider: manifest.provider,
+      revision: manifest.revision,
+    },
+  };
+}
+
+export function listConsolePlugins(ctx: ConsoleFacadeContext): PluginCardViewModel[] {
+  return listAssistantPluginManifests(ctx.controllerHome, ctx.repository, {
+    preferStored: true,
+  }).map(mapPluginCard);
+}
+
+export function getConsolePlugin(ctx: ConsoleFacadeContext, pluginId: string): PluginCardViewModel | null {
+  try {
+    return mapPluginCard(getAssistantPluginManifest(ctx.controllerHome, ctx.repository, pluginId));
+  } catch {
+    return null;
+  }
+}
+
+export function buildPluginSummary(plugins: PluginCardViewModel[]): PluginSummaryViewModel {
+  const ready = plugins.filter((entry) => entry.status === 'ready').length;
+  const needsAttention = plugins.filter((entry) =>
+    entry.status === 'authorization_required' || entry.status === 'failed' || entry.status === 'needs_setup').length;
+  return {
+    ready,
+    total: plugins.length,
+    needsAttention,
+    lines: plugins.slice(0, 6).map((entry) => `${entry.name} · ${entry.statusLabel}`),
+  };
+}
+
+export async function buildCommandCenter(
+  ctx: ConsoleFacadeContext,
+  repositories: RepositoryCardViewModel[],
+): Promise<CommandCenterViewModel> {
+  const readiness = await buildSystemReadiness(ctx);
+  const mapWork = (work: WorkContract) => mapWorkSummary(work, {
+    controllerHome: ctx.controllerHome,
+    repoId: ctx.repository.repoId,
+  });
+  const currentRepository = repositories.find((entry) => entry.current) ?? mapRepositoryCard(ctx.repository, true);
+  const activeWork = listWorkContracts({ ...store(ctx), status: 'active', limit: 20 }).map(mapWork);
+  const allRecent = listWorkContracts({ ...store(ctx), status: 'all', limit: 12 }).map(mapWork);
+  const handoffs = listHandoffItems({ ...store(ctx), status: 'pending', limit: 20 }).map(mapHandoffCard);
+  const plugins = listConsolePlugins(ctx);
+  const pluginSummary = buildPluginSummary(plugins);
+  const goalLoop = buildGoalLoopStatusView(ctx);
+  const access = controllerAccessStateView(ctx);
+  const banner = readiness.connectorFreshness?.severity === 'warning' || readiness.connectorFreshness?.severity === 'error'
+    ? readiness.connectorFreshness.summary
+    : undefined;
+  const needsSetup = readiness.state === 'needs_setup' || ctx.repository.enabled === false || !currentRepository;
+  return {
+    schemaVersion: 1,
+    generatedAt: new Date().toISOString(),
+    accessMode: access.configuredAccessMode,
+    accessModeLabel: access.configuredAccessModeLabel,
+    accessModeDescription: accessModeDescriptor(access.configuredAccessMode).description,
+    access,
+    readiness,
+    currentRepository,
+    repositories,
+    currentWork: activeWork[0],
+    recentWork: allRecent,
+    handoffs,
+    goalLoop,
+    pluginSummary,
+    plugins,
+    modePreviewDefault: plainMode('direct_control'),
+    // Only surface confirmed warnings — never "maybe missing" when ChatGPT snapshot is unobserved.
+    warnings: banner ? [banner] : [],
+    setupGuide: needsSetup
+      ? {
+        needed: true,
+        title: '先选择或注册一个仓库',
+        body: '没有可用仓库时，无法开始开发任务。请在“仓库”页添加本地 Git 仓库并设为当前。',
+        actionLabel: '去设置仓库',
+      }
+      : { needed: false, title: '', body: '', actionLabel: '' },
+  };
+}
+
+function configCtx(ctx: ConsoleFacadeContext): ConfigFacadeContext {
+  return { controllerHome: ctx.controllerHome };
+}
+
+export function buildGoalLoopStatusView(ctx: ConsoleFacadeContext): GoalLoopStatusViewModel {
+  const goalCtx: GoalLoopContext = {
+    goalStore: store(ctx),
+    packetStore: store(ctx),
+    repoId: ctx.repository.repoId,
+    configLocation: { controllerHome: ctx.controllerHome },
+    providerEnv: { configLocation: { controllerHome: ctx.controllerHome } },
+  };
+  const snapshot = goalLoopStatusSnapshot(goalCtx) as {
+    activeGoals?: Array<Record<string, unknown>>;
+    activeCount?: number;
+    invokableProviders?: string[];
+    handoffOnlyProviders?: string[];
+    providers?: Array<Record<string, unknown>>;
+  };
+  let automationSummary: string | undefined;
+  let liveEffective: boolean | undefined;
+  try {
+    const settings = buildAutomationSettingsView(configCtx(ctx));
+    automationSummary = settings.overview.plainLanguageSummary;
+    liveEffective = settings.overview.liveModelProvidersEffective;
+  } catch {
+    automationSummary = undefined;
+  }
+
+  const goals = (snapshot.activeGoals ?? []).map((goal) => {
+    const stage = String(goal.stage ?? '');
+    const providerSelected = typeof goal.providerSelected === 'string' ? goal.providerSelected : undefined;
+    const waitingReason = typeof goal.waitingReason === 'string' ? goal.waitingReason : undefined;
+    const nextSafeAction = typeof goal.nextSafeAction === 'string' ? goal.nextSafeAction : undefined;
+    const handoffPacketAvailable = goal.handoffPacketAvailable === true;
+    return {
+      title: String(goal.title ?? ''),
+      stage,
+      currentStep: String(goal.currentStep ?? ''),
+      providerSelected,
+      waitingReason,
+      nextSafeAction,
+      handoffPacketAvailable,
+      approvalRequired: Boolean(waitingReason) || stage === 'waiting_for_user',
+      whyThisProvider: providerSelected
+        ? `Last selected provider: ${providerSelected}`
+        : 'No provider selected yet',
+      whatHappensNext: nextSafeAction
+        ?? (handoffPacketAvailable
+          ? 'Open handoff packet or configure a direct provider'
+          : 'Wait for next daemon tick or open Automation Settings'),
+      whatIsBlocked: waitingReason
+        ?? (stage === 'handoff_ready'
+          ? 'Waiting for handoff supervisor (ChatGPT is not auto-invokable)'
+          : undefined),
+    };
+  });
+  return {
+    activeCount: snapshot.activeCount ?? goals.length,
+    goals,
+    invokableProviders: snapshot.invokableProviders ?? [],
+    handoffOnlyProviders: snapshot.handoffOnlyProviders ?? [],
+    providerHealth: (snapshot.providers ?? []).map((provider) => ({
+      providerId: String(provider.providerId ?? ''),
+      status: String(provider.status ?? ''),
+      directDispatchAllowed: provider.directDispatchAllowed === true,
+      handoffOnly: provider.handoffOnly === true,
+      summary: String(provider.summary ?? ''),
+    })),
+    automationSummary,
+    liveModelProvidersEffective: liveEffective,
+    settingsPathHint: 'Model & Tool Providers',
+    nextTickHint: 'Daemon ticks active goals about every 5 seconds when the controller is running.',
+  };
+}
+
+export function getAutomationSettings(ctx: ConsoleFacadeContext) {
+  return buildAutomationSettingsView(configCtx(ctx));
+}
+
+export function consoleProviderConfigGet(ctx: ConsoleFacadeContext) {
+  return providerConfigGet(configCtx(ctx));
+}
+
+export function consoleProviderConfigUpdate(ctx: ConsoleFacadeContext, body: Record<string, unknown>) {
+  return providerConfigUpdate(configCtx(ctx), body as unknown as Parameters<typeof providerConfigUpdate>[1]);
+}
+
+export function consoleProviderEnable(ctx: ConsoleFacadeContext, providerId: string) {
+  return providerEnable(configCtx(ctx), providerId);
+}
+
+export function consoleProviderDisable(ctx: ConsoleFacadeContext, providerId: string) {
+  return providerDisable(configCtx(ctx), providerId);
+}
+
+export function consoleProviderPriority(ctx: ConsoleFacadeContext, providerId: string, direction: 'up' | 'down' | number) {
+  return providerPriorityUpdate(configCtx(ctx), providerId, direction);
+}
+
+export function consoleProviderHealth(ctx: ConsoleFacadeContext, providerId?: string) {
+  return providerHealthCheck(configCtx(ctx), providerId);
+}
+
+export function consoleProviderCredentials(ctx: ConsoleFacadeContext) {
+  return providerCredentialsStatus(configCtx(ctx));
+}
+
+export function consoleProviderReset(ctx: ConsoleFacadeContext) {
+  return providerResetDefaults(configCtx(ctx));
+}
+
+export function consoleProviderApiSettingsGet(ctx: ConsoleFacadeContext, providerId: string) {
+  return providerApiSettingsGet(configCtx(ctx), providerId);
+}
+
+export function consoleProviderApiSettingsUpdate(
+  ctx: ConsoleFacadeContext,
+  providerId: string,
+  body: Record<string, unknown>,
+) {
+  return providerApiSettingsUpdate(configCtx(ctx), providerId, {
+    baseUrl: typeof body.baseUrl === 'string' ? body.baseUrl : typeof body.base_url === 'string' ? body.base_url : undefined,
+    model: typeof body.model === 'string' ? body.model : undefined,
+    apiKey: typeof body.apiKey === 'string'
+      ? body.apiKey
+      : typeof body.api_key === 'string'
+        ? body.api_key
+        : undefined,
+    clearApiKey: body.clearApiKey === true || body.clear_api_key === true,
+  });
+}
+
+export function consoleLocalToolList(ctx: ConsoleFacadeContext) {
+  return localToolList(configCtx(ctx));
+}
+
+export function consoleLocalToolEnable(ctx: ConsoleFacadeContext, toolId: string) {
+  return localToolEnable(configCtx(ctx), toolId);
+}
+
+export function consoleLocalToolDisable(ctx: ConsoleFacadeContext, toolId: string) {
+  return localToolDisable(configCtx(ctx), toolId);
+}
+
+export function consoleLocalToolHealth(ctx: ConsoleFacadeContext, toolId?: string) {
+  return localToolHealthCheck(configCtx(ctx), toolId);
+}
+
+export function consoleLocalToolConfigGet(ctx: ConsoleFacadeContext) {
+  return localToolConfigGet(configCtx(ctx));
+}
+
+export function consoleLocalToolConfigUpdate(ctx: ConsoleFacadeContext, body: Record<string, unknown>) {
+  return localToolConfigUpdate(configCtx(ctx), body as unknown as Parameters<typeof localToolConfigUpdate>[1]);
+}
+
+export function consoleRoutingGet(ctx: ConsoleFacadeContext) {
+  return executorRoutingConfigGet(configCtx(ctx));
+}
+
+export function consoleRoutingUpdate(ctx: ConsoleFacadeContext, body: Record<string, unknown>) {
+  return executorRoutingConfigUpdate(configCtx(ctx), body as unknown as Parameters<typeof executorRoutingConfigUpdate>[1]);
+}
+
+export function consoleRoutingReset(ctx: ConsoleFacadeContext) {
+  return executorRoutingConfigReset(configCtx(ctx));
+}
+
+export function consoleRoutePreview(ctx: ConsoleFacadeContext, body: Record<string, unknown> = {}) {
+  return executorRoutePreviewWithConfig(configCtx(ctx), {
+    taskIntent: typeof body.taskIntent === 'string' ? body.taskIntent as never : typeof body.task_intent === 'string' ? body.task_intent as never : undefined,
+    risk: typeof body.risk === 'string' ? body.risk as never : undefined,
+    objective: typeof body.objective === 'string' ? body.objective : undefined,
+    externalWrite: body.externalWrite === true || body.external_write === true,
+  });
+}
+
+export function consoleGoalLoopPolicyGet(ctx: ConsoleFacadeContext) {
+  return goalLoopPolicyGet(configCtx(ctx));
+}
+
+export function consoleGoalLoopPolicyUpdate(ctx: ConsoleFacadeContext, body: Record<string, unknown>) {
+  return goalLoopPolicyUpdate(configCtx(ctx), body as unknown as Parameters<typeof goalLoopPolicyUpdate>[1]);
+}
+
+export function getConsoleAccessPolicy(ctx: ConsoleFacadeContext) {
+  const policy = readRepositoryAccessPolicy(ctx.controllerHome, ctx.repository.repoId);
+  return {
+    policy,
+    descriptor: accessModeDescriptor(policy.mode),
+    access: controllerAccessStateView(ctx),
+  };
+}
+
+export function setConsoleAccessPolicy(
+  ctx: ConsoleFacadeContext,
+  input: { mode: unknown; confirmAuthorization?: boolean; confirmationText?: string },
+) {
+  if (!isAccessMode(input.mode)) throw new Error('ACCESS_MODE_INVALID: mode must be request or full_access');
+  if (input.confirmAuthorization !== true) {
+    throw new Error('ACCESS_MODE_AUTHORIZATION_REQUIRED: changing repository access requires explicit confirmation');
+  }
+  persistControllerAccessMode(ctx.controllerHome, input.mode, ctx.repository.canonicalRoot);
+  const policy = writeRepositoryAccessPolicy(ctx.controllerHome, ctx.repository.repoId, input.mode, 'user');
+  return {
+    policy,
+    descriptor: accessModeDescriptor(policy.mode),
+    access: controllerAccessStateView(ctx),
+  };
+}
+
+export function startConsoleWork(
+  ctx: ConsoleFacadeContext,
+  input: {
+    objective: string;
+    acceptanceCriteria?: string[];
+    allowedPaths?: string[];
+    forbiddenPaths?: string[];
+    expectedFiles?: number;
+    expectedChangedLines?: number;
+    scopeClear?: boolean;
+    requiresInvestigation?: boolean;
+    requiresLongRunningChecks?: boolean;
+    requiresWorker?: boolean;
+    requiresApproval?: boolean;
+    destructive?: boolean;
+    accessMode?: AccessMode;
+    approvalConfirmed?: boolean;
+    forceMode?: 'direct_control' | 'goal_workloop' | 'handoff_only';
+    checkIds?: string[];
+  },
+): FacadeResult {
+  const checks = listControllerChecks(ctx.repository.canonicalRoot);
+  return routeWorkStart(
+    {
+      workStore: store(ctx),
+      handoffStore: store(ctx),
+      repoId: ctx.repository.repoId,
+      availableChecks: checks,
+    },
+    {
+      objective: input.objective,
+      acceptanceCriteria: input.acceptanceCriteria,
+      allowedPaths: input.allowedPaths,
+      forbiddenPaths: input.forbiddenPaths,
+      checks: input.checkIds,
+      constraints: input.accessMode ? { accessMode: input.accessMode } : undefined,
+      modeInput: {
+        objective: input.objective,
+        expectedFiles: input.expectedFiles,
+        expectedChangedLines: input.expectedChangedLines,
+        scopeClear: input.scopeClear !== false,
+        requiresInvestigation: input.requiresInvestigation === true,
+        requiresLongRunningChecks: input.requiresLongRunningChecks === true,
+        requiresWorker: input.requiresWorker === true,
+        requiresApproval: input.requiresApproval === true,
+        destructive: input.destructive === true,
+      },
+      requestedBy: 'user',
+      approvalConfirmed: input.approvalConfirmed === true,
+      forceMode: input.forceMode,
+    },
+  );
+}
+
+export function continueConsoleWork(ctx: ConsoleFacadeContext, workId: string, note?: string): FacadeResult {
+  return continueGoalWorkloop(
+    {
+      workStore: store(ctx),
+      handoffStore: store(ctx),
+      repoId: ctx.repository.repoId,
+      availableChecks: listControllerChecks(ctx.repository.canonicalRoot),
+    },
+    { workId, note },
+  );
+}
+
+export function verifyConsoleWork(
+  ctx: ConsoleFacadeContext,
+  input: { workId: string; checkId?: string; simulate?: boolean; checkFailed?: boolean; infrastructureFailed?: boolean },
+): FacadeResult {
+  const checks = listControllerChecks(ctx.repository.canonicalRoot);
+  const workloopCtx = {
+    workStore: store(ctx),
+    handoffStore: store(ctx),
+    repoId: ctx.repository.repoId,
+    availableChecks: checks,
+  };
+  const work = getWorkContract(store(ctx), input.workId);
+  const requested = input.checkId || work?.checks[0] || checks[0]?.id || '';
+  const classified = classifyVerificationOutcome({ checkId: requested, available: checks });
+  if (classified.outcome === 'invalid_check_id') {
+    return verifyGoalWorkloop(workloopCtx, { workId: input.workId, checkId: requested });
+  }
+  if (input.simulate) {
+    return verifyGoalWorkloop(workloopCtx, {
+      workId: input.workId,
+      checkId: classified.normalizedCheckId ?? requested,
+      checkFailed: input.checkFailed === true,
+      infrastructureFailed: input.infrastructureFailed === true,
+    });
+  }
+  try {
+    const executed = runControllerCheck(ctx.repository.canonicalRoot, classified.normalizedCheckId!);
+    return verifyGoalWorkloop(workloopCtx, {
+      workId: input.workId,
+      checkId: classified.normalizedCheckId!,
+      infrastructureFailed: executed.timedOut === true,
+      checkFailed: !executed.ok && !executed.timedOut,
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const facade = verifyGoalWorkloop(workloopCtx, {
+      workId: input.workId,
+      checkId: classified.normalizedCheckId ?? requested,
+      infrastructureFailed: true,
+    });
+    return {
+      ...facade,
+      warnings: [...facade.warnings, `环境执行检查失败：${message.slice(0, 160)}`],
+    };
+  }
+}
+
+export function finalizeConsoleWork(ctx: ConsoleFacadeContext, workId: string): FacadeResult {
+  return finalizeGoalWorkloop(
+    {
+      workStore: store(ctx),
+      handoffStore: store(ctx),
+      repoId: ctx.repository.repoId,
+      availableChecks: listControllerChecks(ctx.repository.canonicalRoot),
+    },
+    { workId },
+  );
+}
+
+export function stopConsoleWork(ctx: ConsoleFacadeContext, workId: string, reason?: string): FacadeResult {
+  return stopGoalWorkloop(
+    {
+      workStore: store(ctx),
+      handoffStore: store(ctx),
+      repoId: ctx.repository.repoId,
+      availableChecks: listControllerChecks(ctx.repository.canonicalRoot),
+    },
+    { workId, reason },
+  );
+}
+
+export function delegateConsoleWork(
+  ctx: ConsoleFacadeContext,
+  input: { workId?: string; target?: 'codex' | 'grok' | 'claude'; objective?: string; available?: boolean },
+): FacadeResult {
+  return delegateToCodexCerebellum(
+    { repoId: ctx.repository.repoId },
+    {
+      workId: input.workId,
+      target: input.target ?? 'codex',
+      objective: input.objective || '请协助完成当前任务',
+      available: input.available,
+      codexAvailable: input.available,
+    },
+  );
+}
+
+export function repairConsole(
+  ctx: ConsoleFacadeContext,
+  input: {
+    operation?: 'diagnose' | 'repair' | 'verify' | 'handoff';
+    dryRun?: boolean;
+    approvalConfirmed?: boolean;
+    destructive?: boolean;
+    workId?: string;
+  } = {},
+): FacadeResult {
+  let maintenanceStatus: {
+    readyForExecution?: boolean;
+    recommendedActions?: string[];
+    candidates?: Array<{ kind?: string; reason?: string; suggestedAction?: string; safe?: boolean }>;
+    warnings?: string[];
+  } | undefined;
+  try {
+    const status = buildRuntimeMaintenanceStatus(ctx.repository, ctx.controllerHome, { maxCandidates: 20 });
+    maintenanceStatus = {
+      readyForExecution: status.readyForExecution,
+      recommendedActions: status.recommendedActions,
+      candidates: status.candidates.map((candidate) => ({
+        kind: candidate.kind,
+        reason: candidate.reason,
+        suggestedAction: candidate.suggestedAction,
+        safe: candidate.safe,
+      })),
+      warnings: status.warnings,
+    };
+  } catch {
+    maintenanceStatus = {
+      readyForExecution: false,
+      warnings: ['维护状态读取失败，按环境问题处理，不记作任务验收失败。'],
+    };
+  }
+  const daemon = readForgeRuntimeStatus(ctx.controllerHome);
+  return runSelfHealingLoop(
+    { repoId: ctx.repository.repoId, handoffStore: store(ctx) },
+    {
+      operation: input.operation ?? 'diagnose',
+      dryRun: input.dryRun === undefined ? true : input.dryRun,
+      approvalConfirmed: input.approvalConfirmed === true,
+      destructive: input.destructive === true,
+      workId: input.workId,
+      maintenanceStatus,
+      diagnostics: {
+        controllerDaemonUnhealthy: daemon.status !== 'ready',
+      },
+    },
+  );
+}
+
+export function listConsoleHandoffs(ctx: ConsoleFacadeContext, status: 'pending' | 'active' | 'all' = 'pending'): HandoffCardViewModel[] {
+  return listHandoffItems({ ...store(ctx), status, limit: 50 }).map(mapHandoffCard);
+}
+
+export function getConsoleHandoff(ctx: ConsoleFacadeContext, handoffId: string): HandoffCardViewModel | undefined {
+  const item = getHandoffItem(store(ctx), handoffId);
+  return item ? mapHandoffCard(item) : undefined;
+}
+
+export function ackConsoleHandoff(ctx: ConsoleFacadeContext, handoffId: string) {
+  return mapHandoffCard(acknowledgeHandoffItem(store(ctx), handoffId));
+}
+
+export function resolveConsoleHandoff(ctx: ConsoleFacadeContext, handoffId: string, decision: string, resolver = 'user') {
+  return mapHandoffCard(resolveHandoffItem(store(ctx), handoffId, { decision, resolver }));
+}
+
+export function approveConsoleHandoff(ctx: ConsoleFacadeContext, handoffId: string, resolver = 'user') {
+  const item = getHandoffItem(store(ctx), handoffId);
+  if (!item) throw new Error(`handoff not found: ${handoffId}`);
+  const decision = describeHandoffDecision(item);
+  if (decision.type !== 'approval') throw new Error('该事项不是审批，不能使用“批准并继续”。');
+  if (!item.approvalAction || item.approvalAction.operation !== 'start') {
+    throw new Error('该审批项没有保存可安全重放的任务创建动作，请仅记录决定并按人工提示处理。');
+  }
+  if (item.status !== 'pending' && item.status !== 'acknowledged') {
+    throw new Error(`该审批已处理（${item.status}）。`);
+  }
+
+  const payload = item.approvalAction.payload;
+  const strings = (value: unknown): string[] | undefined => Array.isArray(value) ? value.map(String) : undefined;
+  const actionResult = startConsoleWork(ctx, {
+    objective: typeof payload.objective === 'string' ? payload.objective : '',
+    acceptanceCriteria: strings(payload.acceptanceCriteria),
+    allowedPaths: strings(payload.allowedPaths),
+    forbiddenPaths: strings(payload.forbiddenPaths),
+    expectedFiles: typeof payload.expectedFiles === 'number' ? payload.expectedFiles : undefined,
+    expectedChangedLines: typeof payload.expectedChangedLines === 'number' ? payload.expectedChangedLines : undefined,
+    scopeClear: payload.scopeClear !== false,
+    requiresInvestigation: payload.requiresInvestigation === true,
+    requiresLongRunningChecks: payload.requiresLongRunningChecks === true,
+    requiresWorker: payload.requiresWorker === true,
+    requiresApproval: payload.requiresApproval === true,
+    destructive: payload.destructive === true,
+    accessMode: isAccessMode(payload.accessMode) ? payload.accessMode : undefined,
+    approvalConfirmed: true,
+    forceMode: 'goal_workloop',
+    checkIds: strings(payload.checkIds),
+  });
+
+  if (actionResult.status !== 'ok') {
+    return {
+      item: mapHandoffCard(item),
+      actionResult,
+      continued: false,
+      summary: `批准已收到，但后续动作未成功：${actionResult.summary}`,
+    };
+  }
+  const resolved = resolveHandoffItem(store(ctx), handoffId, {
+    decision: `approved: ${item.approvalAction.label}`,
+    resolver,
+  });
+  return {
+    item: mapHandoffCard(resolved),
+    actionResult,
+    continued: true,
+    summary: '已批准并创建任务，页面将进入任务详情并显示后续动作。',
+  };
+}
+
+export function dismissConsoleHandoff(ctx: ConsoleFacadeContext, handoffId: string, decision = 'dismissed', resolver = 'user') {
+  return mapHandoffCard(dismissHandoffItem(store(ctx), handoffId, { decision, resolver }));
+}
+
+export function getConsoleWork(ctx: ConsoleFacadeContext, workId: string): WorkSummaryViewModel | undefined {
+  const work = getWorkContract(store(ctx), workId);
+  return work
+    ? mapWorkSummary(work, { controllerHome: ctx.controllerHome, repoId: ctx.repository.repoId })
+    : undefined;
+}
+
+export function listConsoleWork(ctx: ConsoleFacadeContext, status: 'active' | 'all' = 'active'): WorkSummaryViewModel[] {
+  return listWorkContracts({ ...store(ctx), status, limit: 50 }).map((work) =>
+    mapWorkSummary(work, { controllerHome: ctx.controllerHome, repoId: ctx.repository.repoId }));
+}
+
+/** Normalize facade/tool results into GUI-friendly operation feedback. */
+export function toConsoleOperationFeedback(result: FacadeResult): {
+  phase: string;
+  statusLabel: string;
+  summary: string;
+  terminal: boolean;
+  errorClass?: UserFacingErrorClass;
+  error?: ConsoleErrorViewModel;
+  suggestedNextActions: SuggestedActionViewModel[];
+  changedFiles?: ChangedFilesSummaryViewModel;
+} {
+  const data = (result.data ?? {}) as Record<string, unknown>;
+  const status = result.status;
+  const phase: UserFacingPhase = status === 'ok'
+    ? 'succeeded'
+    : status === 'blocked' || status === 'approval_required'
+      ? 'needs_attention'
+      : status === 'failed'
+        ? 'failed'
+        : status === 'not_found'
+          ? 'failed'
+          : 'running';
+  const errorClass = status === 'ok'
+    ? undefined
+    : classifyUserFacingError({
+      code: String(data.errorClass ?? data.code ?? ''),
+      message: result.summary || String(data.errorMessage ?? ''),
+      status,
+      infrastructure: status === 'failed' && /环境|infrastructure|daemon|timeout/i.test(result.summary),
+      acceptance: /验收|acceptance|valid_fail|未通过/i.test(result.summary),
+    });
+  const changed = Array.isArray(data.changedFiles)
+    ? summarizeChangedFiles(data.changedFiles.map(String))
+    : undefined;
+  return {
+    phase,
+    statusLabel: statusLabelForPhase(phase),
+    summary: result.summary || (status === 'ok' ? '操作已完成' : '操作未完成'),
+    terminal: phase === 'succeeded' || phase === 'failed' || phase === 'needs_attention',
+    errorClass,
+    error: errorClass ? describeConsoleError(errorClass, result.summary) : undefined,
+    suggestedNextActions: mapSuggested(result.suggestedNextActions),
+    changedFiles: changed,
+  };
+}
+
+export function buildConsoleContext(ctx: ConsoleFacadeContext, workId?: string) {
+  const checks = listControllerChecks(ctx.repository.canonicalRoot);
+  const work = workId ? getWorkContract(store(ctx), workId) : undefined;
+  return buildFacadeResult({
+    summary: work ? `任务上下文：${work.objective.slice(0, 120)}` : '仓库上下文已就绪',
+    data: {
+      repositoryName: ctx.repository.displayName,
+      checks: checks.map((check) => ({ id: check.id, description: check.description })),
+      work: work ? summarizeWorkContract(work) : undefined,
+      handoffs: listHandoffItems({ ...store(ctx), status: 'pending', limit: 10 }).map(summarizeHandoffItem),
+    },
+    suggestedNextActions: work
+      ? mapSuggested(work.suggestedNextActions).map((action) => ({
+          label: action.label,
+          tool: (action.tool as 'rh_work') || 'rh_work',
+          operation: action.operation || 'continue',
+          payload: action.payload,
+          risk: 'readonly' as const,
+        }))
+      : [{
+          label: '开始一个任务',
+          tool: 'rh_work' as const,
+          operation: 'start',
+          risk: 'readonly' as const,
+        }],
+  });
+}
+
+export function normalizeRequestedChecks(ctx: ConsoleFacadeContext, requested: string[]) {
+  return normalizeCheckIds(requested, listControllerChecks(ctx.repository.canonicalRoot));
+}
+
+const ADVANCED_SCHEDULER_STALE_MS = 10_000;
+
+function controllerObservation(ctx: ConsoleFacadeContext): ConnectivityComponentObservation {
+  const daemon = readForgeRuntimeStatus(ctx.controllerHome);
+  if (daemon.status === 'ready' && daemon.degraded !== true) {
+    return createConnectivityObservation(
+      'controller_daemon',
+      'Forge Runtime',
+      'ready',
+      'Forge Runtime 处于 ready 状态。',
+      daemon.pid ? [`pid=${daemon.pid}`] : [],
+    );
+  }
+  if (daemon.status === 'ready' || daemon.status === 'starting') {
+    return createConnectivityObservation(
+      'controller_daemon',
+      'Forge Runtime',
+      'degraded',
+      daemon.error
+        ? `Forge Runtime ${daemon.status}，并带有降级信号：${daemon.error}`
+        : `Forge Runtime 当前为 ${daemon.status}。`,
+      [daemon.error ? `daemon=${daemon.error}` : `status=${daemon.status}`],
+    );
+  }
+  return createConnectivityObservation(
+    'controller_daemon',
+    'Forge Runtime',
+    'failed',
+    daemon.error
+      ? `Forge Runtime 不可用：${daemon.error}`
+      : `Forge Runtime 当前为 ${daemon.status}。`,
+    [daemon.error ? `daemon=${daemon.error}` : `status=${daemon.status}`],
+  );
+}
+
+function schedulerObservation(ctx: ConsoleFacadeContext): ConnectivityComponentObservation {
+  const snapshot = readSchedulerHealthSnapshot(ctx.controllerHome);
+  const lastTick = snapshot.lastTickAt ? Date.parse(snapshot.lastTickAt) : Number.NaN;
+  const ageMs = Number.isFinite(lastTick) ? Date.now() - lastTick : undefined;
+  if (snapshot.loopStartedAt && typeof ageMs === 'number' && ageMs <= ADVANCED_SCHEDULER_STALE_MS) {
+    return createConnectivityObservation(
+      'scheduler',
+      'Scheduler',
+      'ready',
+      `最近一次 durable scheduler 心跳距今 ${Math.round(ageMs)}ms。`,
+      [`lastTickAt=${snapshot.lastTickAt}`],
+    );
+  }
+  if (snapshot.loopStartedAt && typeof ageMs === 'number') {
+    return createConnectivityObservation(
+      'scheduler',
+      'Scheduler',
+      'degraded',
+      `durable scheduler 心跳已陈旧（${Math.round(ageMs)}ms）。`,
+      [`lastTickAt=${snapshot.lastTickAt}`],
+    );
+  }
+  return createConnectivityObservation(
+    'scheduler',
+    'Scheduler',
+    'unknown',
+    '尚未观察到 durable scheduler 心跳。',
+    [],
+  );
+}
+
+function localMcpObservation(
+  ctx: ConsoleFacadeContext,
+  freshness: ConnectorFreshnessReport,
+): ConnectivityComponentObservation {
+  const runtime = loadMcpServiceRuntimeState(ctx.controllerHome, ctx.repository.canonicalRoot);
+  if (
+    freshness.status === 'local_mcp_updated'
+    || freshness.status === 'chatgpt_snapshot_missing_facade'
+    || freshness.status === 'unable_to_verify_chatgpt_snapshot'
+  ) {
+    return createConnectivityObservation(
+      'local_mcp',
+      'Local MCP',
+      'ready',
+      freshness.summary || 'Local MCP /health 可达且工具面匹配。',
+      runtime?.server?.lastHealthyAt ? [`lastHealthyAt=${runtime.server.lastHealthyAt}`] : [],
+    );
+  }
+  if (freshness.status === 'local_mcp_missing_facade' || freshness.status === 'stale_fingerprint') {
+    return createConnectivityObservation(
+      'local_mcp',
+      'Local MCP',
+      'degraded',
+      freshness.summary,
+      freshness.missingLocalTools.slice(0, 5).map((tool) => `missing_local_tool=${tool}`),
+    );
+  }
+  if (runtime?.status === 'running' || runtime?.status === 'degraded') {
+    return createConnectivityObservation(
+      'local_mcp',
+      'Local MCP',
+      'degraded',
+      '存在 MCP runtime 状态，但当前未确认 live /health 为 healthy。',
+      runtime.server.lastExit ? [`lastExit=${runtime.server.lastExit}`] : [],
+    );
+  }
+  return createConnectivityObservation(
+    'local_mcp',
+    'Local MCP',
+    'failed',
+    '未确认本地 MCP /health 可达。',
+    [],
+  );
+}
+
+function publicMcpObservation(ctx: ConsoleFacadeContext): ConnectivityComponentObservation {
+  const config = loadMcpServiceLocalConfig(ctx.controllerHome, ctx.repository.canonicalRoot);
+  const runtime = loadMcpServiceRuntimeState(ctx.controllerHome, ctx.repository.canonicalRoot);
+  const publicEndpoint = config?.chatgpt?.endpoint ?? runtime?.tunnel?.publicEndpoint;
+  if (!publicEndpoint) {
+    return createConnectivityObservation(
+      'public_mcp',
+      'Public MCP endpoint',
+      'unknown',
+      '当前没有配置公网 MCP endpoint。',
+      [],
+    );
+  }
+  if (runtime?.tunnel?.healthy === true && runtime.tunnel.connectorNeedsReconnect !== true) {
+    return createConnectivityObservation(
+      'public_mcp',
+      'Public MCP endpoint',
+      'ready',
+      '公网 MCP endpoint 最近一次发现检查通过。',
+      [`endpoint=${publicEndpoint}`],
+    );
+  }
+  if (runtime?.tunnel?.connectorNeedsReconnect === true) {
+    return createConnectivityObservation(
+      'public_mcp',
+      'Public MCP endpoint',
+      'degraded',
+      '公网 MCP endpoint 发生变化，ChatGPT Connector 需要重连。',
+      [`endpoint=${publicEndpoint}`],
+    );
+  }
+  if (runtime?.tunnel?.healthy === false || runtime?.status === 'degraded') {
+    return createConnectivityObservation(
+      'public_mcp',
+      'Public MCP endpoint',
+      'degraded',
+      '公网 MCP endpoint 最近一次发现检查未通过或 tunnel 处于降级状态。',
+      [`endpoint=${publicEndpoint}`],
+    );
+  }
+  return createConnectivityObservation(
+    'public_mcp',
+    'Public MCP endpoint',
+    'unknown',
+    '公网 MCP endpoint 已配置，但当前没有足够健康证据。',
+    [`endpoint=${publicEndpoint}`],
+  );
+}
+
+function localBridgeObservation(): ConnectivityComponentObservation {
+  return createConnectivityObservation(
+    'local_bridge',
+    'Local Bridge',
+    'ready',
+    '高级诊断请求已经到达 Local Bridge HTTP 进程。',
+    [],
+  );
+}
+
+function connectorSignals(ctx: ConsoleFacadeContext, freshness: ConnectorFreshnessReport): string[] {
+  const runtime = loadMcpServiceRuntimeState(ctx.controllerHome, ctx.repository.canonicalRoot);
+  const signals: string[] = [];
+  if (freshness.status === 'chatgpt_snapshot_missing_facade' || freshness.status === 'unable_to_verify_chatgpt_snapshot') {
+    signals.push(freshness.summary);
+  }
+  if (runtime?.tunnel?.connectorNeedsReconnect === true) {
+    signals.push('Public MCP endpoint changed; reconnect the ChatGPT connector.');
+  }
+  return signals;
+}
+
+async function buildConnectivityObservability(
+  ctx: ConsoleFacadeContext,
+  freshness: ConnectorFreshnessReport,
+) {
+  const jobs = listExecutionJobs(ctx.controllerHome, ctx.repository.repoId, 6);
+  return recordConnectivityProbe({
+    controllerHome: ctx.controllerHome,
+    repoId: ctx.repository.repoId,
+    observations: [
+      localMcpObservation(ctx, freshness),
+      publicMcpObservation(ctx),
+      localBridgeObservation(),
+      controllerObservation(ctx),
+      schedulerObservation(ctx),
+    ],
+    connectorSignals: connectorSignals(ctx, freshness),
+    jobTimings: deriveExecutionJobTimingSnapshots(ctx.controllerHome, ctx.repository.repoId, jobs),
+  });
+}
+
+/**
+ * Interactive safe patch for console/GUI: always sync, returns readable digest.
+ */
+export function applyConsoleSafePatch(
+  ctx: ConsoleFacadeContext,
+  input: {
+    operations: unknown;
+    purpose?: string;
+    allowedPaths?: string[];
+    sessionId?: string;
+  },
+): Record<string, unknown> {
+  const applied = withControllerLock(
+    ctx.controllerHome,
+    { scope: 'repository', repoId: ctx.repository.repoId },
+    'console:safe_patch_apply',
+    () => applySafePatch(ctx.repository, {
+      sessionId: input.sessionId,
+      purpose: input.purpose ?? 'Console interactive edit',
+      operations: input.operations,
+      allowedPaths: input.allowedPaths,
+      refreshFingerprints: true,
+      recoverStaleSession: true,
+    }),
+    60_000,
+  );
+  const changedFiles = [...new Set((applied.appliedChunks ?? []).flatMap((chunk) => chunk.paths ?? []))];
+  const ok = applied.status === 'applied';
+  const firstFailure = applied.failures?.[0];
+  const digest = buildSyncOperationDigest({
+    ok,
+    operation: 'safe_patch_apply',
+    summary: ok
+      ? `已保存修改（${changedFiles.length} 个文件）。`
+      : `修改失败：${firstFailure?.message || '请检查路径或内容后重试'}`,
+    changedFiles,
+    errorClass: ok ? undefined : classifyUserFacingError({
+      code: firstFailure?.code,
+      message: firstFailure?.message,
+    }),
+    errorMessage: firstFailure?.message,
+  });
+  return {
+    ...applied,
+    digest,
+    summary: digest.summary,
+    phase: digest.phase,
+    statusLabel: digest.statusLabel,
+    terminal: true,
+    applyMode: 'sync',
+    changedFiles,
+    errorClass: digest.errorClass,
+    errorMessage: digest.errorMessage,
+    suggestedNextActions: digest.suggestedNextActions,
+  };
+}
+
+/** Keep advanced/debug payload separate from primary console models. */
+export async function buildAdvancedDiagnosticsEnvelope(rawSnapshot: unknown, ctx: ConsoleFacadeContext) {
+  const readiness = await buildSystemReadiness(ctx);
+  const connector = await evaluateConsoleConnectorFreshness(ctx);
+  const connectivity = await buildConnectivityObservability(ctx, connector);
+  return {
+    schemaVersion: 1,
+    note: '高级诊断仅供排错。日常任务请使用控制台主流程。',
+    readinessSummary: readiness,
+    preferredTools: [...EXPECTED_FACADE_TOOLS],
+    connectorFreshness: connector,
+    connectivity,
+    raw: rawSnapshot,
+  };
+}