@moretea-labs/forge 1.8.0 → 1.8.2

package/src/cli/commands/brain-assistant.ts

@@ -1,7 +1,8 @@
 import { readFileSync, statSync } from 'fs';
 import type { Command } from 'commander';
 import { recordExperience, retractExperience, supersedeExperience, type ExperienceDraft } from '../../../packages/kernel/memory/api/index';
-import { controllerExperienceStore } from '../../runtime/control-plane/persistence/experience-store';
+import { controllerExperienceStore, workExperienceProvenance } from '../../runtime/control-plane/persistence/experience-store';
+import { getWorkContract } from '../../../packages/kernel/work/api/index';
 import { prepareAssistantWorkContext } from '../../runtime/context/assistant-work-context';
 
 function readBoundedJson(path: string): unknown {
@@ -17,21 +18,34 @@ export function addBrainAssistantCommands(brain: Command): void {
     .action((options: { controllerHome: string; repoId: string; workId: string; query?: string; channel?: string; account?: string; locale?: string }) => {
       console.log(JSON.stringify(prepareAssistantWorkContext({ ...options, applicability: { channel: options.channel, account: options.account, locale: options.locale } }) ?? { status: 'project_contract_missing' }, null, 2));
     });
-  const experience = brain.command('experience').description('Submit or withdraw Controller-authored, evidence-backed experience');
+  const experience = brain.command('experience').description('Submit or withdraw Work-authored, evidence-backed advisory experience');
   for (const operation of ['record', 'supersede', 'retract'] as const) {
     experience.command(operation)
       .requiredOption('--controller-home <path>').requiredOption('--repo-id <id>').requiredOption('--work-id <id>')
-      .requiredOption('--controller-id <id>').requiredOption('--authority-env <name>', 'Environment variable containing the current Controller capability')
-      .requiredOption('--input <path>', 'Bounded JSON API input; never include the Controller capability')
-      .action((options: { controllerHome: string; repoId: string; workId: string; controllerId: string; authorityEnv: string; input: string }) => {
-        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(options.authorityEnv)) throw new Error('BRAIN_AUTHORITY_ENV_INVALID');
-        const authorityId = process.env[options.authorityEnv];
-        if (!authorityId) throw new Error('BRAIN_CONTROLLER_AUTHORITY_REQUIRED');
-        const store = controllerExperienceStore({ ...options, identity: { workId: options.workId, controllerId: options.controllerId, authorityId } });
-        const data = readBoundedJson(options.input);
-        const result = operation === 'record' ? recordExperience(store, data as ExperienceDraft)
-          : operation === 'supersede' ? supersedeExperience(store, data as Parameters<typeof supersedeExperience>[1])
-            : retractExperience(store, data as Parameters<typeof retractExperience>[1]);
+      .requiredOption('--input <path>', 'Bounded JSON API input; source Work provenance is derived by Forge')
+      .action((options: { controllerHome: string; repoId: string; workId: string; input: string }) => {
+        const work = getWorkContract({ controllerHome: options.controllerHome, repoId: options.repoId }, options.workId);
+        if (!work) throw new Error(`BRAIN_WORK_NOT_FOUND: ${options.workId}`);
+        const sourceRoundId = workExperienceProvenance(work);
+        const store = controllerExperienceStore({ ...options, identity: { workId: options.workId } });
+        const raw = readBoundedJson(options.input);
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw new Error('BRAIN_INPUT_OBJECT_REQUIRED');
+        const data = raw as Record<string, unknown>;
+        const result = operation === 'record'
+          ? recordExperience(store, { ...data, sourceWorkId: options.workId, sourceRoundId } as ExperienceDraft)
+          : operation === 'supersede'
+            ? (() => {
+                const input = data as Parameters<typeof supersedeExperience>[1];
+                return supersedeExperience(store, {
+                  ...input,
+                  draft: { ...input.draft, sourceWorkId: options.workId, sourceRoundId },
+                });
+              })()
+            : retractExperience(store, {
+                ...(data as Parameters<typeof retractExperience>[1]),
+                sourceWorkId: options.workId,
+                sourceRoundId,
+              });
         console.log(JSON.stringify(result, null, 2));
       });
   }

package/src/cli/commands/brain.ts

@@ -14,7 +14,7 @@ import { configuredBrainRoot } from './brain-root';
 import { addBrainAssistantCommands } from './brain-assistant';
 import { resolveRepoPreferredControllerHome } from '../repositories/controller-home';
 import { findRegisteredRepositoryByCheckoutRoot } from '../repositories/registry';
-import { getWorkContract, validateWorkSemantics } from '../../../packages/kernel/work/api/index';
+import { getWorkContract, semanticWorkState } from '../../../packages/kernel/work/api/index';
 
 export type BrainLifecycle = 'always-sync' | 'archive-only' | 'never-sync';
 export type BrainCategory = 'decisions' | 'runbooks' | 'patterns' | 'references';
@@ -561,38 +561,36 @@ function modernBrainPromotionSource(repoRoot: string, opts: BrainPromoteOptions,
     return { sources: [], sections: [], relatedPlan: work.planId ?? '', terminalAt: '', outcome: '', sourceWork: workId, completionReceipt: '', workScope: '' };
   }
   const workScope = `${work.scopeRef.kind}:${work.scopeRef.id}`;
-  if (work.status !== 'completed' || !work.completionReceipt) {
-    issue(issues, 'error', `Brain promotion requires a completed Work with a durable completion receipt: ${workId}`);
+  if (semanticWorkState(work) !== 'completed') {
+    issue(issues, 'error', `Brain promotion requires a semantically completed Work: ${workId}`);
     return { sources: [], sections: [], relatedPlan: work.planId ?? '', terminalAt: '', outcome: '', sourceWork: workId, completionReceipt: '', workScope };
   }
-  try {
-    validateWorkSemantics(work);
-  } catch (error) {
-    issue(issues, 'error', `Work completion evidence is invalid for Brain promotion: ${error instanceof Error ? error.message : String(error)}`);
-    return { sources: [], sections: [], relatedPlan: work.planId ?? '', terminalAt: '', outcome: '', sourceWork: workId, completionReceipt: work.completionReceipt.receiptId, workScope };
-  }
   const receipt = work.completionReceipt;
-  const repositoryDetails = ('targetRevision' in receipt)
+  const semanticResultRefs = [...new Set((work.semanticResultRefs ?? []).map((value) => value.trim()).filter(Boolean))];
+  const repositoryDetails = receipt && 'targetRevision' in receipt
     ? [`- Target revision: ${receipt.targetRevision}`, `- Changed paths: ${receipt.changedPaths.length}`]
     : [];
+  const legacyReceiptDetails = receipt
+    ? [`- Legacy completion receipt: ${receipt.receiptId}`, `- Legacy completion source: ${receipt.source}`]
+    : ['- Legacy completion receipt: none (not required for semantic completion)'];
   const section = [
     `## Source: work:${work.workId}`,
     '',
     `- Objective: ${work.objective}`,
     `- Completion outcome: ${work.completionOutcome ?? 'completed'}`,
-    `- Completion receipt: ${receipt.receiptId}`,
-    `- Completion authority: ${receipt.source}`,
+    `- Semantic result refs: ${semanticResultRefs.length ? semanticResultRefs.join(', ') : '(none recorded)'}`,
     `- Work scope: ${workScope}`,
+    ...legacyReceiptDetails,
     ...repositoryDetails,
     '',
     'This entry is promoted from validated durable Work metadata. Raw process logs, credentials, and chat history are not copied into Brain.',
     '',
   ].join('\n');
   return {
-    sources: [`work:${work.workId}`, `completion:${receipt.receiptId}`],
-    sections: [section], relatedPlan: work.planId ?? '', terminalAt: receipt.recordedAt,
+    sources: [`work:${work.workId}`, ...semanticResultRefs, ...(receipt ? [`completion:${receipt.receiptId}`] : [])],
+    sections: [section], relatedPlan: work.planId ?? '', terminalAt: work.semanticUpdatedAt ?? work.updatedAt,
     outcome: work.completionOutcome ?? 'completed', sourceWork: work.workId,
-    completionReceipt: receipt.receiptId, workScope,
+    completionReceipt: receipt?.receiptId ?? '', workScope,
   };
 }
 

package/src/cli/commands/chatgpt.ts

@@ -13,12 +13,7 @@ import {
 } from '../chatgpt-browser/engine';
 import type { BrowserProviderName, BrowserSessionStatus, NativeBrowserChannel, ThinkingLevel } from '../chatgpt-browser/types';
 import { durableControllerHome } from '../repositories/controller-home';
-import {
-  runWorkChatgptContinuation,
-  type ChatgptAutomationReasoning,
-  type ChatgptAutomationTabPolicy,
-} from '../../runtime/control-plane/launcher/chatgpt-work-continuation';
-import { closeChatgptControllerRoundFromSource, continueChatgptControllerRoundFromSource, openChatgptControllerRoundFromSource } from '../../runtime/control-plane/launcher/chatgpt-round-continuation';
+import { closeChatgptControllerRoundFromSource } from '../../runtime/control-plane/launcher/chatgpt-round-continuation';
 
 interface BrowserCommonOptions {
   repo?: string;
@@ -81,43 +76,6 @@ interface BrowserConsultOptions extends BrowserCommonOptions {
   headless?: boolean;
 }
 
-interface WorkChatgptContinueOptions extends BrowserCommonOptions {
-  controllerHome: string;
-  repoId: string;
-  workId: string;
-  prompt: string;
-  title?: string;
-  session?: string;
-  conversationUrl?: string;
-  model?: string;
-  reasoning?: string;
-  tabPolicy?: string;
-  timeoutMs?: string;
-  controllerAuthorityId?: string;
-  relayScopeId?: string;
-}
-
-interface SourceRoundOpenOptions extends BrowserCommonOptions {
-  controllerHome?: string;
-  repoId: string;
-  workId: string;
-  controllerId: string;
-  principalId: string;
-  controllerInstanceId?: string;
-  continuationPrompt?: string;
-  timeoutMs?: string;
-}
-
-interface SourceRoundContinueOptions extends BrowserCommonOptions {
-  controllerHome?: string;
-  repoId: string;
-  workId: string;
-  controllerAuthorityId: string;
-  relayScopeId: string;
-  reason?: string;
-  timeoutMs?: string;
-}
-
 interface SourceRoundCloseOptions extends BrowserCommonOptions {
   controllerHome?: string;
   repoId: string;
@@ -156,18 +114,6 @@ interface BrowserFollowupOptions extends BrowserCommonOptions {
   oracleBin?: string;
 }
 
-function parseAutomationReasoning(value?: string): ChatgptAutomationReasoning | undefined {
-  if (value === undefined) return undefined;
-  if (value === 'medium' || value === 'high' || value === 'xhigh') return value;
-  throw new Error(`invalid --reasoning "${value}" (expected: medium, high, xhigh)`);
-}
-
-function parseAutomationTabPolicy(value?: string): ChatgptAutomationTabPolicy | undefined {
-  if (value === undefined) return undefined;
-  if (value === 'auto' || value === 'reuse' || value === 'new') return value;
-  throw new Error(`invalid --tab-policy "${value}" (expected: auto, reuse, new)`);
-}
-
 function parseProvider(value?: string): BrowserProviderName {
   if (value === undefined || value === 'oracle') return 'oracle';
   if (value === 'native') return 'native';
@@ -435,114 +381,6 @@ export function buildChatgptCommand(): Command {
       });
     });
 
-  const workContinue = new Command('work-continue')
-    .description('Internal: continue one Forge Work in its bound ChatGPT Web conversation')
-    .option('--repo <path>', 'Repository root for the Work browser session', '.')
-    .requiredOption('--controller-home <path>', 'Explicit Controller Home containing the authoritative Work and conversation binding')
-    .requiredOption('--repo-id <repo-id>', 'Stable Forge repository id')
-    .requiredOption('--work-id <work-id>', 'Stable Forge Work id')
-    .requiredOption('--prompt <text>', 'Bounded continuation prompt')
-    .option('--title <title>', 'Human-readable local conversation alias')
-    .option('--session <session-id>', 'Saved browser session to seed or resume the Work binding')
-    .option('--conversation-url <url>', 'Explicit ChatGPT conversation URL to seed the binding')
-    .option('--model <label>', 'Requested ChatGPT automation model', 'gpt-5.6')
-    .option('--reasoning <level>', 'Reasoning level: medium|high|xhigh', 'high')
-    .option('--tab-policy <policy>', 'Browser tab policy: auto|reuse|new', 'auto')
-    .option('--timeout-ms <ms>', 'Assistant timeout in milliseconds')
-    .option('--controller-authority-id <id>', 'Durable ControllerRound authority for source-mode continuation')
-    .option('--relay-scope-id <id>', 'Durable ControllerRound relay scope paired with controller authority')
-    .action((rawOpts: WorkChatgptContinueOptions) => {
-      void runChatgptAction(async () => {
-        const result = await runWorkChatgptContinuation({
-          controllerHome: durableControllerHome(rawOpts.controllerHome),
-          repoId: rawOpts.repoId,
-          repoRoot: resolveRepoRoot(rawOpts.repo),
-          workId: rawOpts.workId,
-          prompt: rawOpts.prompt,
-          controllerAuthorityId: rawOpts.controllerAuthorityId,
-          relayScopeId: rawOpts.relayScopeId,
-          title: rawOpts.title,
-          browserSessionId: rawOpts.session,
-          conversationUrl: rawOpts.conversationUrl,
-          model: rawOpts.model,
-          reasoning: parseAutomationReasoning(rawOpts.reasoning),
-          tabPolicy: parseAutomationTabPolicy(rawOpts.tabPolicy),
-          timeoutMs: parsePositiveInteger('timeout-ms', rawOpts.timeoutMs),
-        });
-        console.log(JSON.stringify({
-          status: result.status,
-          provider: result.provider,
-          sessionId: result.browserSessionId,
-          conversationUrl: result.conversationUrl,
-          conversationId: result.conversationId,
-          localAlias: result.localAlias,
-          resumedFromBinding: result.resumedFromBinding,
-          model: result.model,
-          reasoning: result.reasoning,
-          tabPolicy: result.tabPolicy,
-          executionPreferenceVerified: result.executionPreferenceVerified,
-          error: result.error,
-        }, null, 2));
-      });
-    });
-  chatgpt.addCommand(workContinue, { hidden: true });
-
-  const roundOpen = new Command('round-open')
-    .description('Internal: open and dispatch one ChatGPT ControllerRound from current source')
-    .option('--repo <path>', 'Repository root used by the ChatGPT Browser delivery host', '.')
-    .option('--controller-home <path>', 'Explicit Controller Home containing ControllerRound authority; defaults to canonical user-level Forge Controller Home')
-    .requiredOption('--repo-id <repo-id>', 'Stable Forge repository id')
-    .requiredOption('--work-id <work-id>', 'Forge Work id to dispatch')
-    .requiredOption('--controller-id <id>', 'Authenticated ChatGPT controller id/principal identity')
-    .requiredOption('--principal-id <id>', 'Authenticated ChatGPT principal id')
-    .option('--controller-instance-id <id>', 'Source launcher instance identity')
-    .option('--continuation-prompt <text>', 'Bounded source-mode continuation instruction')
-    .option('--timeout-ms <ms>', 'Assistant dispatch timeout in milliseconds')
-    .action((rawOpts: SourceRoundOpenOptions) => {
-      void runChatgptAction(async () => {
-        const result = await openChatgptControllerRoundFromSource({
-          controllerHome: durableControllerHome(rawOpts.controllerHome),
-          repoId: rawOpts.repoId,
-          repoRoot: resolveRepoRoot(rawOpts.repo),
-          workId: rawOpts.workId,
-          controllerId: rawOpts.controllerId,
-          principalId: rawOpts.principalId,
-          controllerInstanceId: rawOpts.controllerInstanceId,
-          continuationPrompt: rawOpts.continuationPrompt,
-          timeoutMs: parsePositiveInteger('timeout-ms', rawOpts.timeoutMs),
-        });
-        console.log(JSON.stringify(result, null, 2));
-      });
-    });
-  chatgpt.addCommand(roundOpen, { hidden: true });
-
-  const roundContinue = new Command('round-continue')
-    .description('Internal: close one claimed ChatGPT ControllerRound and immediately dispatch its successor from current source')
-    .option('--repo <path>', 'Repository root used by the ChatGPT Browser delivery host', '.')
-    .option('--controller-home <path>', 'Explicit Controller Home containing ControllerRound authority; defaults to canonical user-level Forge Controller Home')
-    .requiredOption('--repo-id <repo-id>', 'Stable Forge repository id')
-    .requiredOption('--work-id <work-id>', 'Currently claimed Forge Work id')
-    .requiredOption('--controller-authority-id <id>', 'Exact durable ControllerRound authority')
-    .requiredOption('--relay-scope-id <id>', 'Exact durable ControllerRound relay scope')
-    .option('--reason <text>', 'Bounded semantic continuation reason')
-    .option('--timeout-ms <ms>', 'Assistant dispatch timeout in milliseconds')
-    .action((rawOpts: SourceRoundContinueOptions) => {
-      void runChatgptAction(async () => {
-        const result = await continueChatgptControllerRoundFromSource({
-          controllerHome: durableControllerHome(rawOpts.controllerHome),
-          repoId: rawOpts.repoId,
-          repoRoot: resolveRepoRoot(rawOpts.repo),
-          workId: rawOpts.workId,
-          controllerAuthorityId: rawOpts.controllerAuthorityId,
-          relayScopeId: rawOpts.relayScopeId,
-          reason: rawOpts.reason,
-          timeoutMs: parsePositiveInteger('timeout-ms', rawOpts.timeoutMs),
-        });
-        console.log(JSON.stringify(result, null, 2));
-      });
-    });
-  chatgpt.addCommand(roundContinue, { hidden: true });
-
   const roundClose = new Command('round-close')
     .description('Internal: reconcile and close one claimed ChatGPT ControllerRound from current source without dispatching a successor')
     .option('--controller-home <path>', 'Explicit Controller Home containing ControllerRound authority; defaults to canonical user-level Forge Controller Home')

package/src/cli/commands/doctor.ts

@@ -2,7 +2,7 @@
  * `forge doctor` — read-only readiness diagnostics.
  *
  * Built-in checks: PATH resolution, CLI version, per-host install detection,
- * Codex user-level trust state count, and target-aware CodeGraph readiness.
+ * Codex user-level trust state count, and current-source tool readiness.
  * Never mutates.
  */
 
@@ -11,7 +11,6 @@ import * as os from 'os';
 import * as path from 'path';
 import { spawnSync } from 'child_process';
 import { ALL_TARGETS } from '../installer/targets/registry';
-import { checkCodegraph, type CodegraphCheckResult } from '../tools/codegraph';
 import { CLI_VERSION } from './status';
 import { runSecurityScan, type SecurityScanReport } from './security';
 import { isOptIn, resolveHooksDir, resolveRepoRoot } from '../hook/runtime';
@@ -225,142 +224,6 @@ function checkCodexTrustState(): DoctorCheckResult {
   }
 }
 
-function doctorStatusForCodegraph(status: CodegraphCheckResult['status']): CheckStatus {
-  if (status === 'present') return 'ok';
-  if (status === 'missing') return 'fail';
-  return 'warn';
-}
-
-function formatCodegraphDetail(result: CodegraphCheckResult): string {
-  const raw = result.raw as Record<string, any>;
-  const indexStatus = raw.project_index?.status ?? 'unknown';
-  const codexMcpStatus = raw.mcp_hosts?.codex?.status ?? 'unknown';
-  const claudeMcpStatus = raw.mcp_hosts?.claude?.status ?? 'unknown';
-  const bits = [
-    result.reason,
-    `source=${result.resolution.source}`,
-    `version=${result.resolution.version ?? 'unknown'}`,
-    `codex-mcp=${codexMcpStatus}`,
-    `claude-mcp=${claudeMcpStatus}`,
-    `index=${indexStatus}`,
-  ];
-  if (result.resolution.globalFallbackUsed) bits.push('global-fallback=true');
-  const remediation = codegraphRemediation(result);
-  if (remediation) bits.push(`remediation=${remediation}`);
-  return bits.join('; ');
-}
-
-function codegraphRemediation(result: CodegraphCheckResult): string | null {
-  if (result.status === 'present') return null;
-
-  const raw = result.raw as Record<string, any>;
-  if (result.resolution.source === 'missing') {
-    return String(raw.install_command ?? 'bash scripts/ensure-codegraph.sh');
-  }
-  if (result.resolution.globalFallbackUsed) {
-    return String(raw.install_command ?? 'bun install');
-  }
-  if (raw.mcp_hosts?.codex?.status !== 'configured' || raw.mcp_hosts?.claude?.status !== 'configured') {
-    return String(raw.mcp_install_command ?? 'forge tools configure codegraph --target both --location global');
-  }
-  if (raw.project_index?.status === 'not-initialized') {
-    return String(raw.init_command ?? 'bash scripts/ensure-codegraph.sh --init');
-  }
-  if (raw.project_index?.status === 'stale') {
-    return String(raw.sync_command ?? 'bash scripts/ensure-codegraph.sh --sync');
-  }
-  return String(raw.ensure_command ?? raw.sync_command ?? 'bash scripts/ensure-codegraph.sh --check');
-}
-
-interface CodegraphProbe {
-  result?: CodegraphCheckResult;
-  error?: Error;
-}
-
-function probeCodegraph(cwd: string): CodegraphProbe {
-  try {
-    return { result: checkCodegraph({ repoRoot: cwd, host: 'both' }) };
-  } catch (err) {
-    return { error: err as Error };
-  }
-}
-
-function checkCodegraphReadiness(probe: CodegraphProbe): DoctorCheckResult {
-  const id = 'codegraph-readiness';
-  const describe = 'CodeGraph CLI, MCP, and project index readiness';
-  if (probe.result) {
-    return {
-      id,
-      describe,
-      status: doctorStatusForCodegraph(probe.result.status),
-      detail: formatCodegraphDetail(probe.result),
-    };
-  }
-  return {
-    id,
-    describe,
-    status: 'fail',
-    detail: `error checking CodeGraph readiness: ${probe.error?.message ?? 'unknown error'}`,
-  };
-}
-
-function checkCodegraphMcpHost(probe: CodegraphProbe, host: 'codex' | 'claude'): DoctorCheckResult {
-  const id = `${host}-codegraph-mcp`;
-  const describe = `${host === 'codex' ? 'Codex' : 'Claude Code'} CodeGraph MCP config`;
-  if (!probe.result) {
-    return {
-      id,
-      describe,
-      status: 'fail',
-      detail: `error checking CodeGraph MCP config: ${probe.error?.message ?? 'unknown error'}`,
-    };
-  }
-
-  const raw = probe.result.raw as Record<string, any>;
-  const entry = raw.mcp_hosts?.[host];
-  if (entry?.status === 'configured') {
-    return { id, describe, status: 'ok', detail: entry.reason ?? 'configured' };
-  }
-  return {
-    id,
-    describe,
-    status: 'warn',
-    detail: `${entry?.reason ?? 'missing'}; remediation=forge tools configure codegraph --target ${host} --location global`,
-  };
-}
-
-function checkCodegraphIndex(probe: CodegraphProbe): DoctorCheckResult {
-  const id = 'codegraph-index';
-  const describe = 'CodeGraph project index';
-  if (!probe.result) {
-    return {
-      id,
-      describe,
-      status: 'fail',
-      detail: `error checking CodeGraph index: ${probe.error?.message ?? 'unknown error'}`,
-    };
-  }
-
-  const raw = probe.result.raw as Record<string, any>;
-  const indexStatus = raw.project_index?.status ?? 'unknown';
-  const status: CheckStatus = indexStatus === 'up-to-date'
-    ? 'ok'
-    : indexStatus === 'stale' || indexStatus === 'unknown'
-      ? 'warn'
-      : 'fail';
-  const remediation = indexStatus === 'not-initialized'
-    ? raw.init_command
-    : indexStatus === 'stale'
-      ? raw.sync_command
-      : raw.ensure_command;
-  return {
-    id,
-    describe,
-    status,
-    detail: `index=${indexStatus}${remediation ? `; remediation=${remediation}` : ''}`,
-  };
-}
-
 function checkSecurityConfig(report: SecurityScanReport): DoctorCheckResult {
   const id = 'security-config';
   const describe = 'Local hook and VS Code automatic task security scan';
@@ -451,7 +314,6 @@ function checkHookScriptDrift(cwd: string): DoctorCheckResult {
 
 export function runDoctor(cwd: string = process.cwd()): DoctorReport {
   const checks: DoctorCheckResult[] = [];
-  const codegraphProbe = probeCodegraph(cwd);
   const securityReport = runSecurityScan({ cwd });
   checks.push(checkPath());
   checks.push(checkVersion());
@@ -462,10 +324,6 @@ export function runDoctor(cwd: string = process.cwd()): DoctorReport {
     }
   }
   checks.push(checkCodexTrustState());
-  checks.push(checkCodegraphReadiness(codegraphProbe));
-  checks.push(checkCodegraphMcpHost(codegraphProbe, 'codex'));
-  checks.push(checkCodegraphMcpHost(codegraphProbe, 'claude'));
-  checks.push(checkCodegraphIndex(codegraphProbe));
   checks.push(checkSecurityConfig(securityReport));
   checks.push(checkHookScriptDrift(cwd));
   checks.push(checkBootstrapLifecycle());