@moretea-labs/forge 1.8.1 → 1.8.2

package/src/cli/commands/mcp.ts

@@ -28,7 +28,6 @@ export interface McpServeOptions {
   devRunnerAgents?: string;
   devRunnerTimeoutMs?: string;
   devRunnerMaxTimeoutMs?: string;
-  toolset?: 'facade' | 'core' | 'advanced' | 'full';
 }
 
 interface McpAccessOptions {
@@ -105,7 +104,6 @@ async function runRepositoryAccessCommand(
     repo: rawOpts.repo ?? '.',
     controllerHome: rawOpts.controllerHome,
     profile: 'controller',
-    toolset: 'core',
   });
   const result = callAccessTool(ctx, toolName, {
     repo_id: rawOpts.repoId,
@@ -170,7 +168,6 @@ export function buildMcpCommand(): Command {
     .option('--host <host>', 'HTTP bind host', '127.0.0.1')
     .option('--port <port>', 'HTTP bind port', '8765')
     .option('--profile <profile>', 'MCP profile: planner|executor|orchestrator|controller', 'controller')
-    .option('--toolset <toolset>', 'Controller toolset: facade|core|advanced|full (default advanced; facade is an explicit five-tool ChatGPT surface)')
     .option('--auth <mode>', 'HTTP auth mode: oauth|bearer|none', 'oauth')
     .option('--enable-chatgpt-browser', 'Expose tools that operate the user logged-in ChatGPT Web browser session')
     .option('--enable-dev-runner', 'Enable local Codex/Claude task runners for controller or orchestrator profiles')
@@ -191,7 +188,6 @@ export function buildMcpCommand(): Command {
             repo: rawOpts.repo ?? '.',
             controllerHome: rawOpts.controllerHome,
             profile: rawOpts.profile,
-            toolset: rawOpts.toolset,
             enableChatgptBrowser: rawOpts.enableChatgptBrowser === true,
             enableDevRunner: rawOpts.enableDevRunner,
             devRunnerAgents: rawOpts.devRunnerAgents,
@@ -206,7 +202,6 @@ export function buildMcpCommand(): Command {
             repo: rawOpts.repo,
             controllerHome: rawOpts.controllerHome,
             profile: rawOpts.profile,
-            toolset: rawOpts.toolset,
             host: rawOpts.host,
             port: parsePort(rawOpts.port),
             auth: rawOpts.auth,

package/src/cli/commands/prompt-guard-decision.ts

@@ -18,7 +18,6 @@ import {
   isAgenticPackagingIntent,
   isBugFixIntent,
   isBugOrHuntIntent,
-  isCodegraphRouteIntent,
   isDoneIntent,
   isEmbeddedApprovedPlanIntent,
   isExecutionApprovalIntent,
@@ -185,7 +184,6 @@ export function runPromptGuardVerdictFromPrompt(prompt: string): PromptGuardVerd
       plan_discussion_continuation: bit(decisionFacts.planningDiscussion),
       trigger_question: bit(isTriggerQuestionPrompt(ctx)),
       agentic_packaging: bit(isAgenticPackagingIntent(ctx)),
-      codegraph_route: bit(isCodegraphRouteIntent(ctx)),
       nontrivial_code_task: bit(isNontrivialCodeTaskIntent(ctx)),
       health_route: bit(isHealthRouteIntent(ctx)),
       spa_day: bit(isSpaDayIntent(ctx)),

package/src/cli/commands/recovery.ts

@@ -61,7 +61,6 @@ import {
   scheduleLinuxControllerHomeMigration,
   type RecoveryControllerHomeMigrationPreflight,
 } from '../../runtime/standalone-recovery/controller-home-migration';
-import { configureCodegraph, ensureCodegraph } from '../tools/codegraph';
 import { isProcessAlive } from '../../runtime/shared/process-tree';
 import { systemdUserServicePid, systemdUserUnitName, systemdUserUnitPath } from '../controller/systemd-user';
 import { installWindowsHostRecoveryPlugin } from '../../runtime/plugins/windows-host-recovery-install';
@@ -749,13 +748,11 @@ export function buildRecoveryCommand(): Command {
     .requiredOption('--repo <path>', 'Forge source repository root used for Recovery and Runtime immutable releases')
     .requiredOption('--primary-connector-service-label <label>', 'Primary OAuth/Connector launchd label')
     .option('--primary-connector-service-plist <path>', 'Absolute primary OAuth/Connector launchd plist path')
-    .option('--configure-codegraph', 'Initialize/sync CodeGraph and configure repository-scoped MCP for Codex and Claude during the bootstrap')
     .action(async (opts: {
       controllerHome: string;
       repo: string;
       primaryConnectorServiceLabel: string;
       primaryConnectorServicePlist?: string;
-      configureCodegraph?: boolean;
     }) => {
       const home = resolveControllerHome(opts.controllerHome);
       const repoRoot = resolve(opts.repo);
@@ -793,18 +790,9 @@ export function buildRecoveryCommand(): Command {
         process.exitCode = 1;
         return;
       }
-      let codegraph: Record<string, unknown> | undefined;
-      let codegraphOk = true;
-      if (opts.configureCodegraph === true) {
-        const ensured = ensureCodegraph({ repoRoot, init: true, sync: true, host: 'both' });
-        const configured = configureCodegraph({ repoRoot, target: 'both', location: 'global' });
-        codegraphOk = !ensured.actions.some((entry) => entry.status === 'failed')
-          && !configured.actions.some((entry) => entry.status === 'failed');
-        codegraph = { ensured, configured };
-      }
       const connector = await restartPrimaryConnector(refreshed);
-      const ok = connector.ok && codegraphOk;
-      output({ ok, phase: !connector.ok ? 'connector_restart' : !codegraphOk ? 'codegraph_configuration' : 'complete', recovery: installed, runtime, ...(codegraph ? { codegraph } : {}), connector });
+      const ok = connector.ok;
+      output({ ok, phase: !connector.ok ? 'connector_restart' : 'complete', recovery: installed, runtime, connector });
       if (!ok) process.exitCode = 1;
     });
 

package/src/cli/commands/repository.ts

@@ -106,7 +106,23 @@ export function buildRepositoryCommand(): Command {
     .argument('<repo-id>', 'Stable repository ID'))
     .action((repoId: string, opts: { controllerHome?: string; json?: boolean }) => {
       const repository = getRepository(repoId, opts.controllerHome, { includeRemoved: true });
-      output({ validation: validateRepository(repoId, opts.controllerHome), ...initializeRepository(repository, opts.controllerHome) }, opts.json === true);
+      const validation = validateRepository(repoId, opts.controllerHome);
+      if (opts.json === true) {
+        output({ validation, ...initializeRepository(repository, opts.controllerHome) }, true);
+        return;
+      }
+      // The default validation view is bounded even when the repository has
+      // thousands of historical checkout records. Full audit data is opt-in.
+      output({
+        validation,
+        repository: repositorySummary(repository),
+        checkouts: {
+          total: repository.checkouts.length,
+          active: repository.checkouts.filter((checkout) => !checkout.lifecycle || checkout.lifecycle === 'active').length,
+          archived: repository.checkouts.filter((checkout) => checkout.lifecycle === 'archived').length,
+          removed: repository.checkouts.filter((checkout) => checkout.lifecycle === 'removed').length,
+        },
+      }, false);
     });
 
   common(command.command('command')

package/src/cli/commands/setup-execution.ts

@@ -0,0 +1,41 @@
+/** Shared synchronous setup/adoption command execution; no Runtime or Work authority. */
+import { runProcess as runBoundedProcess } from '../../effects/process-runner';
+
+export interface SetupExecutionStep {
+  step: string;
+  status: "ok" | "skipped" | "failed";
+  command?: string[];
+  detail?: string;
+  stdout?: string;
+  stderr?: string;
+}
+
+export function runSetupProcess(command: string, args: string[], cwd: string, env?: NodeJS.ProcessEnv): SetupExecutionStep {
+  const result = runBoundedProcess(command, args, { cwd, env });
+
+  return {
+    step: "",
+    status: result.ok ? "ok" : "failed",
+    command: [...result.command],
+    stdout: result.stdout,
+    stderr: result.stderr || result.error,
+  };
+}
+
+export function withProcessEnv<T>(env: NodeJS.ProcessEnv | undefined, fn: () => T): T {
+  if (!env) return fn();
+  const previous = new Map<string, string | undefined>();
+  for (const [key, value] of Object.entries(env)) {
+    previous.set(key, process.env[key]);
+    if (value === undefined) delete process.env[key];
+    else process.env[key] = value;
+  }
+  try {
+    return fn();
+  } finally {
+    for (const [key, value] of previous) {
+      if (value === undefined) delete process.env[key];
+      else process.env[key] = value;
+    }
+  }
+}

package/src/cli/controller/completion-orchestrator.ts

@@ -6,7 +6,7 @@ import { getAgentJob, markAgentJobClosure, markAgentJobReviewedCompletion, recor
 import type { AgentJobMeta } from '../agent-jobs/types';
 import { cleanupIntegratedWorktree, cleanupNoChangeWorktree, integrateAgentJob, IntegrationReviewRequiredError, taskRunDiff } from '../agent-jobs/integration';
 import { finalizeEditSession, getEditSession, revalidateEditSessionOwnership, rollbackEditSession, verifyEditSession } from '../editing/edit-session';
-import { getMcpPolicy } from '../mcp/policy';
+import { getMcpPolicy } from '../../../adapters/mcp/policy';
 import { resolveRepoPreferredControllerHome } from '../repositories/controller-home';
 import { withControllerLock } from '../repositories/locks';
 import { listActiveLeases } from '../../runtime/resources/leases/store';

package/src/cli/controller/composite-operations.ts

@@ -2,7 +2,7 @@ import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { createHash } from 'crypto';
 import { runProcess } from '../../effects/process-runner';
-import { resolveMcpRepoRoot } from '../mcp/repo';
+import { resolveMcpRepoRoot } from '../../../adapters/mcp/repo';
 import { listControllerChecks, runControllerCheck } from './check-runner';
 import {
   compositeFailed,

package/src/cli/controller/context/instruction-context.ts

@@ -1,6 +1,6 @@
 import { readFileSync } from 'fs';
 import { posix, resolve } from 'path';
-import type { McpPolicy } from '../../mcp/types';
+import type { McpPolicy } from '../../../../adapters/mcp/types';
 import { readableFile } from './known-paths';
 
 const CONTRACT_NAMES = ['AGENTS.md', 'CLAUDE.md'] as const;

package/src/cli/controller/context/known-paths.ts

@@ -1,6 +1,6 @@
 import { existsSync, lstatSync, readdirSync, statSync } from 'fs';
-import { globMatches, resolveMcpPath } from '../../mcp/paths';
-import type { McpPolicy } from '../../mcp/types';
+import { globMatches, resolveMcpPath } from '../../../../adapters/mcp/paths';
+import type { McpPolicy } from '../../../../adapters/mcp/types';
 
 export function looksLikeGlob(path: string): boolean { return /[*?{[]/.test(path); }
 export function coveredByGlob(path: string, globs: string[]): boolean {

package/src/cli/controller/context/query-planning.ts

@@ -1,8 +1,8 @@
 import type { ControllerContextImpactDomain, ControllerContextRetrievalMode } from './types';
 
 export const DEFAULT_MAX_FILES = 8;
-export const DEFAULT_MAX_SNIPPETS = 20;
-export const DEFAULT_MAX_CHARS_PER_SNIPPET = 8000;
+export const DEFAULT_MAX_SNIPPETS = 12;
+export const DEFAULT_MAX_CHARS_PER_SNIPPET = 1800;
 export const DEFAULT_SEARCH_EXCLUDE_GLOBS = [
   '.git/**', '_ops/**', '.forge/**', '.ai/harness/**', 'node_modules/**', 'dist/**', 'coverage/**', '**/*.bak',
 ] as const;
@@ -47,13 +47,20 @@ export function pathNoisePenalty(path: string, intent: string, retrievalMode: Co
 export function textTokens(value: string): string[] {
   const split = value.replace(/([a-z0-9])([A-Z])/g, '$1 $2').split(/[^\p{L}\p{N}_./:-]+/u)
     .map((entry) => entry.trim()).filter(Boolean);
-  return Array.from(new Set(split
+  // Preserve full code needles before their broad camel-case fragments.
+  return Array.from(new Set([...codeShapedAnchors(value), ...split]
     .map((entry) => entry.replace(/^[\'"`]+|[\'"`]+$/g, ''))
     .filter((entry) => entry.length >= 3)
     .filter((entry) => !STOPWORDS.has(entry.toLowerCase()))
     .filter((entry) => !/^\d+$/.test(entry)))).slice(0, 12);
 }
 
+/** Split explicit multi-symbol input into independent exact needles before search. */
+export function explicitCodeQueries(searchTerms: readonly string[] | undefined): string[] {
+  // Camel-case fragments are hints, not separately mandatory matches.
+  return Array.from(new Set((searchTerms ?? []).flatMap(codeShapedAnchors))).slice(0, 4);
+}
+
 /** A caller-supplied symbol or path is an exact retrieval needle, not a broad hint. */
 export function isCodeShapedTerm(value: string): boolean {
   const term = value.trim();
@@ -77,7 +84,7 @@ function codeShapedAnchors(value: string): string[] {
 }
 
 /**
- * CodeGraph's semantic query cost grows materially with long natural-language
+ * Structural providers' query cost grows materially with long natural-language
  * prompts. Keep short intents exact, but compact long intents around concrete
  * code anchors plus bounded semantic tokens. This affects only structural
  * discovery; lexical search and raw-source retrieval still consume the full

package/src/cli/controller/context/rule-resolution.ts

@@ -1,7 +1,7 @@
 import { closeSync, openSync, readSync, statSync } from 'fs';
 import { extname, resolve } from 'path';
-import { globMatches } from '../../mcp/paths';
-import type { McpPolicy } from '../../mcp/types';
+import { globMatches } from '../../../../adapters/mcp/paths';
+import type { McpPolicy } from '../../../../adapters/mcp/types';
 import { readableFile } from './known-paths';
 
 export const GOVERNANCE_RULES_PATH = '.ai/context/governance-rules.json';

package/src/cli/controller/context/source-materializer.ts

@@ -1,6 +1,6 @@
-import type { McpPolicy } from '../../mcp/types';
+import type { McpPolicy } from '../../../../adapters/mcp/types';
 import { extractTypeScriptSourceSymbolsInSidecar } from '../../../runtime/context/typescript-navigation-process';
-import { redactMcpText } from '../../mcp/redaction';
+import { redactMcpText } from '../../../../adapters/mcp/redaction';
 import { readRepositoryRange, type RepositoryReadSession } from '../../repository/inspector';
 
 const DEFAULT_CONTEXT_BEFORE = 12;

package/src/cli/controller/context/structural-provider.ts

@@ -0,0 +1,84 @@
+export type StructuralReadOperation = 'status' | 'search' | 'context' | 'impact' | 'file_dependencies';
+export type StructuralProviderStatus = 'ready' | 'stale' | 'unavailable' | 'degraded';
+
+export interface StructuralNodeSummary {
+  id: string;
+  kind: string;
+  name: string;
+  qualifiedName?: string;
+  filePath: string;
+  language?: string;
+  startLine: number;
+  endLine: number;
+  signature?: string;
+}
+
+export interface StructuralIndexMetadata {
+  initialized: boolean;
+  lastIndexedAt: number | null;
+  buildVersion: string | null;
+  extractionVersion: number | null;
+  staleEngine: boolean;
+  changedFiles: {
+    added: string[];
+    modified: string[];
+    removed: string[];
+  };
+  ignoredChangedFileCount?: number;
+}
+
+export interface StructuralReadRequest {
+  operation: StructuralReadOperation;
+  query?: string;
+  nodeId?: string;
+  filePath?: string;
+  limit?: number;
+  maxNodes?: number;
+  maxDepth?: number;
+  refresh?: 'if_stale';
+}
+
+export interface StructuralReadProviderResponse {
+  schemaVersion: 1;
+  provider: 'none';
+  operation: StructuralReadOperation;
+  ok: boolean;
+  status: StructuralProviderStatus;
+  metadata?: StructuralIndexMetadata;
+  result?: Record<string, unknown>;
+  error?: {
+    code: string;
+    message: string;
+  };
+  timingsMs: {
+    total: number;
+    process?: number;
+    open?: number;
+    query?: number;
+  };
+}
+
+export function unavailableStructuralProvider(
+  _repoRoot: string,
+  request: StructuralReadRequest,
+): StructuralReadProviderResponse {
+  return {
+    schemaVersion: 1,
+    provider: 'none',
+    operation: request.operation,
+    ok: false,
+    status: 'unavailable',
+    error: {
+      code: 'STRUCTURAL_PROVIDER_UNAVAILABLE',
+      message: 'Integrated CodeGraph structural indexing has been decommissioned; use current raw source, lexical search, known_paths, or semantic_navigation.',
+    },
+    timingsMs: { total: 0 },
+  };
+}
+
+export async function unavailableStructuralProviderAsync(
+  repoRoot: string,
+  request: StructuralReadRequest,
+): Promise<StructuralReadProviderResponse> {
+  return unavailableStructuralProvider(repoRoot, request);
+}

package/src/cli/controller/context/structural.ts

@@ -1,15 +1,15 @@
-import type { CodeGraphNodeSummary, CodeGraphReadProviderResponse } from '../../../runtime/context/codegraph-read-provider';
+import type { StructuralNodeSummary, StructuralReadProviderResponse } from './structural-provider';
 
-export function structuralResult(response: CodeGraphReadProviderResponse): {
-  nodes: CodeGraphNodeSummary[];
-  entryPoints: CodeGraphNodeSummary[];
+export function structuralResult(response: StructuralReadProviderResponse): {
+  nodes: StructuralNodeSummary[];
+  entryPoints: StructuralNodeSummary[];
   relatedFiles: string[];
   truncated: boolean;
 } {
   const result = response.result ?? {};
   return {
-    nodes: Array.isArray(result.nodes) ? result.nodes as CodeGraphNodeSummary[] : [],
-    entryPoints: Array.isArray(result.entryPoints) ? result.entryPoints as CodeGraphNodeSummary[] : [],
+    nodes: Array.isArray(result.nodes) ? result.nodes as StructuralNodeSummary[] : [],
+    entryPoints: Array.isArray(result.entryPoints) ? result.entryPoints as StructuralNodeSummary[] : [],
     relatedFiles: Array.isArray(result.relatedFiles) ? result.relatedFiles.filter((value): value is string => typeof value === 'string') : [],
     truncated: result.truncated === true,
   };

package/src/cli/controller/context/types.ts

@@ -1,7 +1,6 @@
 import type { RepositoryReadSession } from '../../repository/inspector';
-import type { CodeGraphIndexMetadata, CodeGraphNodeSummary, CodeGraphReadProviderResponse } from '../../../runtime/context/codegraph-read-provider';
-import type { queryCodeGraphReadProvider, queryCodeGraphReadProviderAsync } from '../../../runtime/context/codegraph-read-provider';
 import type { MaterializedSourceSnippet } from './source-materializer';
+import type { StructuralIndexMetadata, StructuralNodeSummary, StructuralReadProviderResponse, unavailableStructuralProvider, unavailableStructuralProviderAsync } from './structural-provider';
 
 export const CONTEXT_PACK_SCHEMA_VERSION = 11;
 export type StructuralContextMode = 'off' | 'auto' | 'required';
@@ -37,8 +36,8 @@ export interface ControllerContextPackOptions {
 }
 
 export interface ControllerContextPackDependencies {
-  queryCodeGraph?: typeof queryCodeGraphReadProvider;
-  queryCodeGraphAsync?: typeof queryCodeGraphReadProviderAsync;
+  queryStructural?: typeof unavailableStructuralProvider;
+  queryStructuralAsync?: typeof unavailableStructuralProviderAsync;
 }
 
 export type ControllerContextPackSnippet = MaterializedSourceSnippet;
@@ -186,7 +185,7 @@ export interface ControllerContextPackProjection {
     };
   };
   structuralContext: {
-    provider: 'codegraph';
+    provider: 'none';
     requestedMode: StructuralContextMode;
     status: 'disabled' | 'ready' | 'stale' | 'unavailable' | 'degraded';
     requiredSatisfied: boolean;
@@ -194,11 +193,11 @@ export interface ControllerContextPackProjection {
     overlayChangedFiles: string[];
     baselineRevisionMatches: boolean;
     query?: string;
-    entryPoints: Array<Pick<CodeGraphNodeSummary, 'id' | 'kind' | 'name' | 'filePath' | 'startLine' | 'endLine'>>;
+    entryPoints: Array<Pick<StructuralNodeSummary, 'id' | 'kind' | 'name' | 'filePath' | 'startLine' | 'endLine'>>;
     relatedFiles: string[];
-    metadata?: Pick<CodeGraphIndexMetadata, 'initialized' | 'lastIndexedAt' | 'buildVersion' | 'extractionVersion' | 'staleEngine' | 'changedFiles' | 'ignoredChangedFileCount'>;
+    metadata?: Pick<StructuralIndexMetadata, 'initialized' | 'lastIndexedAt' | 'buildVersion' | 'extractionVersion' | 'staleEngine' | 'changedFiles' | 'ignoredChangedFileCount'>;
     fallbackReason?: string;
-    timingsMs?: CodeGraphReadProviderResponse['timingsMs'];
+    timingsMs?: StructuralReadProviderResponse['timingsMs'];
     truncated: boolean;
   };
   impactContext: {
@@ -212,7 +211,7 @@ export interface ControllerContextPackProjection {
     relevantChecks: string[];
     architectureContracts: string[];
     coverageGaps: string[];
-    relationSources: Array<'codegraph' | 'lexical' | 'forge_checks'>;
+    relationSources: Array<'structural' | 'lexical' | 'forge_checks'>;
     freshness: {
       structuralStatus: 'disabled' | 'ready' | 'stale' | 'unavailable' | 'degraded';
       lastIndexedAt?: number | null;