@moretea-labs/forge 1.8.1 → 1.8.2

package/src/runtime/root/package-connector-service.ts

@@ -1,8 +1,9 @@
+import { writeAtomicTextFile } from '../shared/atomic-text-file';
 import { createHash } from 'crypto';
-import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'fs';
+import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, statSync } from 'fs';
 import { homedir } from 'os';
 import { basename, dirname, join, resolve } from 'path';
-import { loadMcpServiceLocalConfig } from '../../cli/mcp/auth';
+import { loadMcpServiceLocalConfig } from '../../../adapters/mcp/auth';
 import { runtimeAuthorityFreeEnvironment } from '../shared/process-environment';
 import type { PackageRuntimeRelease } from './package-runtime-release';
 import { createPlatformServiceManagerHost, platformLaunchdInstalledPath, type PlatformServiceManagerHost, type SystemdUserUnitInput } from '../platform/service-manager';
@@ -49,19 +50,22 @@ export interface PackageConnectorServiceResult {
   releaseRoot?: string;
 }
 
+export interface PackageConnectorCutoverDrainMarker {
+  schemaVersion: 1;
+  sessionId: string;
+  stableReleaseId: string;
+  connectorEndpoint: string;
+  connectorInstalledAt: string;
+  ownerPid: number;
+  armedAt: string;
+}
+
 export type PackageConnectorAuthMode = 'oauth' | 'none';
 
 function xml(value: string): string {
   return value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;');
 }
 
-function atomicWrite(path: string, content: string, mode = 0o600): void {
-  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-  const temporary = `${path}.${process.pid}.tmp`;
-  writeFileSync(temporary, content, { encoding: 'utf8', mode });
-  renameSync(temporary, path);
-}
-
 export function packageConnectorServicePaths(controllerHome: string, accountHome = process.env.HOME ?? homedir()): PackageConnectorServicePaths {
   const home = resolve(controllerHome);
   const label = forgeConnectorPersistentServiceLabel(home);
@@ -78,6 +82,114 @@ export function packageConnectorServicePaths(controllerHome: string, accountHome
   };
 }
 
+const PACKAGE_CONNECTOR_CUTOVER_DRAIN_TTL_MS = 10 * 60_000;
+
+export function packageConnectorCutoverDrainMarkerPath(controllerHome: string): string {
+  return join(packageConnectorServicePaths(controllerHome).serviceRoot, 'cutover-draining.json');
+}
+
+function removePackageConnectorCutoverDrainMarker(controllerHome: string): void {
+  rmSync(packageConnectorCutoverDrainMarkerPath(controllerHome), { force: true });
+}
+
+function livePackageConnectorCutoverDrainMarker(
+  controllerHome: string,
+  now = Date.now(),
+): PackageConnectorCutoverDrainMarker | undefined {
+  const path = packageConnectorCutoverDrainMarkerPath(controllerHome);
+  if (!existsSync(path)) return undefined;
+  try {
+    const marker = JSON.parse(readFileSync(path, 'utf8')) as Partial<PackageConnectorCutoverDrainMarker>;
+    const armedAt = typeof marker.armedAt === 'string' ? Date.parse(marker.armedAt) : Number.NaN;
+    if (
+      marker.schemaVersion !== 1
+      || typeof marker.sessionId !== 'string'
+      || !marker.sessionId.trim()
+      || typeof marker.stableReleaseId !== 'string'
+      || !marker.stableReleaseId.trim()
+      || typeof marker.connectorEndpoint !== 'string'
+      || !marker.connectorEndpoint.trim()
+      || typeof marker.connectorInstalledAt !== 'string'
+      || !marker.connectorInstalledAt.trim()
+      || !Number.isInteger(marker.ownerPid)
+      || Number(marker.ownerPid) <= 0
+      || !Number.isFinite(armedAt)
+      || now - armedAt > PACKAGE_CONNECTOR_CUTOVER_DRAIN_TTL_MS
+    ) {
+      removePackageConnectorCutoverDrainMarker(controllerHome);
+      return undefined;
+    }
+    try {
+      process.kill(Number(marker.ownerPid), 0);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'EPERM') {
+        removePackageConnectorCutoverDrainMarker(controllerHome);
+        return undefined;
+      }
+    }
+    return marker as PackageConnectorCutoverDrainMarker;
+  } catch {
+    removePackageConnectorCutoverDrainMarker(controllerHome);
+    return undefined;
+  }
+}
+
+export function armPackageConnectorCutoverDrain(input: {
+  controllerHome: string;
+  sessionId: string;
+  stableReleaseId: string;
+  connectorAuthority: PackageConnectorServiceAuthority;
+}): PackageConnectorCutoverDrainMarker {
+  if (input.connectorAuthority.releaseId !== input.stableReleaseId) {
+    throw new Error(`PACKAGE_CONNECTOR_CUTOVER_DRAIN_STABLE_MISMATCH: expected ${input.stableReleaseId}, observed ${input.connectorAuthority.releaseId}`);
+  }
+  const currentAuthority = readPackageConnectorServiceAuthority(input.controllerHome);
+  if (
+    !currentAuthority
+    || currentAuthority.releaseId !== input.connectorAuthority.releaseId
+    || currentAuthority.endpoint !== input.connectorAuthority.endpoint
+    || currentAuthority.installedAt !== input.connectorAuthority.installedAt
+  ) {
+    throw new Error('PACKAGE_CONNECTOR_CUTOVER_DRAIN_AUTHORITY_CHANGED');
+  }
+  const marker: PackageConnectorCutoverDrainMarker = {
+    schemaVersion: 1,
+    sessionId: input.sessionId,
+    stableReleaseId: input.stableReleaseId,
+    connectorEndpoint: input.connectorAuthority.endpoint,
+    connectorInstalledAt: input.connectorAuthority.installedAt,
+    ownerPid: process.pid,
+    armedAt: new Date().toISOString(),
+  };
+  const path = packageConnectorCutoverDrainMarkerPath(input.controllerHome);
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  writeAtomicTextFile(path, `${JSON.stringify(marker, null, 2)}\n`, 0o600);
+  return marker;
+}
+
+export function clearPackageConnectorCutoverDrain(controllerHome: string): void {
+  removePackageConnectorCutoverDrainMarker(controllerHome);
+}
+
+export function packageConnectorCutoverDrainIsActive(
+  controllerHome: string,
+  connectorEndpoint: string,
+  now = Date.now(),
+): boolean {
+  const marker = livePackageConnectorCutoverDrainMarker(controllerHome, now);
+  if (!marker || marker.connectorEndpoint !== connectorEndpoint) return false;
+  let authority: PackageConnectorServiceAuthority | undefined;
+  try {
+    authority = readPackageConnectorServiceAuthority(controllerHome);
+  } catch {
+    return true;
+  }
+  if (!authority) return true;
+  return authority.releaseId === marker.stableReleaseId
+    && authority.endpoint === marker.connectorEndpoint
+    && authority.installedAt === marker.connectorInstalledAt;
+}
+
 export function readPackageConnectorServiceAuthority(controllerHome: string): PackageConnectorServiceAuthority | undefined {
   const path = packageConnectorServicePaths(controllerHome).authorityPath;
   if (!existsSync(path)) return undefined;
@@ -111,7 +223,7 @@ function writePackageConnectorServiceAuthority(input: { release: PackageConnecto
     ...(artifact ? { connectorArtifactIdentity: artifact.identity } : {}),
     installedAt: input.installedAt ?? new Date().toISOString(),
   };
-  atomicWrite(paths.authorityPath, `${JSON.stringify(authority, null, 2)}\n`);
+  writeAtomicTextFile(paths.authorityPath, `${JSON.stringify(authority, null, 2)}\n`);
 }
 
 export function packageConnectorEndpointStatusHealthy(status: number, authMode: PackageConnectorAuthMode = 'oauth'): boolean {
@@ -403,7 +515,7 @@ export async function installPackageConnectorService(input: { release: PackageCo
       port: launch.port,
       requiredArguments: ['mcp', 'serve', '--auth', launch.authMode],
     });
-    atomicWrite(paths.sourcePlistPath, renderPackageConnectorLaunchAgent({ paths, launch }), 0o600);
+    writeAtomicTextFile(paths.sourcePlistPath, renderPackageConnectorLaunchAgent({ paths, launch }), 0o600);
     serviceHost.installLaunchd(paths.sourcePlistPath, paths.label);
     const result = await serviceHost.bootstrapLaunchd({ label: paths.label, plistPath: paths.installedPlistPath });
     if (!result.ok) throw new Error(`FORGE_PACKAGE_CONNECTOR_LAUNCHD_INSTALL_FAILED: ${result.diagnostics.join('; ')}`);

package/src/runtime/root/package-runtime-release.ts

@@ -1,3 +1,4 @@
+import { writeAtomicTextFile } from '../shared/atomic-text-file';
 import { createHash, randomUUID } from 'crypto';
 import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'fs';
 import { dirname, join, relative, resolve } from 'path';
@@ -10,7 +11,6 @@ import { assertRuntimeReleaseExecutionSurface } from './release-manifest';
 import { assertRuntimeReleaseExecutionCanaries } from './release-execution-canary';
 import type { RuntimeReleaseManifest } from './types';
 import { assertStorageHeadroom } from '../shared/storage-capacity';
-import { PROCESS_RUNTIME_RELEASE_CANARY_ARG } from '../execution/process-runtime/canary';
 
 export interface PackageRuntimeFileRecord {
   path: string;
@@ -67,13 +67,6 @@ function sha256(value: Buffer | string): string {
   return createHash('sha256').update(value).digest('hex');
 }
 
-function atomicWrite(path: string, content: string, mode = 0o600): void {
-  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-  const temporary = `${path}.${process.pid}.${randomUUID().slice(0, 8)}.tmp`;
-  writeFileSync(temporary, content, { encoding: 'utf8', mode });
-  renameSync(temporary, path);
-}
-
 function walkRegularFiles(root: string, current: string, output: string[], prefix = ''): void {
   if (!existsSync(current)) return;
   const stat = lstatSync(current);
@@ -226,7 +219,6 @@ function launcherSource(input: {
   indexSha256: string;
   entryRelativePath?: string;
   managerSignalsProcessGroup?: boolean;
-  ownsProcessRuntimeCanary?: boolean;
 }): string {
   const entryRelativePath = input.entryRelativePath ?? 'src/runtime/root/entry.ts';
   return `#!${process.execPath}\n`
@@ -249,8 +241,6 @@ function launcherSource(input: {
     + `if(digest(raw)!==expectedIndex){console.error('FORGE_PACKAGE_RUNTIME_INDEX_CHANGED');process.exit(78);}\n`
     + `let records; try { records=JSON.parse(raw.toString('utf8')).files; } catch { console.error('FORGE_PACKAGE_RUNTIME_INDEX_INVALID'); process.exit(78); }\n`
     + `for(const record of records){const path=join(packageRoot,record.path);if(!existsSync(path)||digest(readFileSync(path))!==record.sha256){console.error('FORGE_PACKAGE_RUNTIME_SOURCE_CHANGED: '+record.path);process.exit(78);}}\n`
-    + `const ownsProcessRuntimeCanary=${input.ownsProcessRuntimeCanary === true ? 'true' : 'false'};\n`
-    + `if(ownsProcessRuntimeCanary&&process.argv.length===3&&process.argv[2]===${JSON.stringify(PROCESS_RUNTIME_RELEASE_CANARY_ARG)})process.exit(0);\n`
     + `const entry=join(packageRoot,...${JSON.stringify(entryRelativePath.split('/'))});\n`
     + `const loader=join(packageRoot,'src','runtime','shared','node-ts-loader.mjs');\n`
     + `const args=process.versions?.bun?[entry,...process.argv.slice(2)]:['--loader',loader,entry,...process.argv.slice(2)];\n`
@@ -357,7 +347,6 @@ export function materializePackageRuntimeRelease(input: {
   const processRunnerLauncher = launcherSource({
     indexSha256,
     entryRelativePath: 'src/runtime/execution/process-runtime/process-runner-entry.ts',
-    ownsProcessRuntimeCanary: true,
   });
   const processRunnerArtifactIdentity = `sha256:${sha256(Buffer.from(processRunnerLauncher))}`;
   const checkRunnerEntrypoint = 'forge-check-runner' as const;
@@ -365,7 +354,6 @@ export function materializePackageRuntimeRelease(input: {
   const checkRunnerLauncher = launcherSource({
     indexSha256,
     entryRelativePath: 'src/runtime/execution/process-runtime/check-runner-sidecar.ts',
-    ownsProcessRuntimeCanary: true,
   });
   const checkRunnerArtifactIdentity = `sha256:${sha256(Buffer.from(checkRunnerLauncher))}`;
   const expectedManifest: Omit<RuntimeReleaseManifest, 'createdAt'> = {
@@ -413,16 +401,16 @@ export function materializePackageRuntimeRelease(input: {
     try {
       mkdirSync(stagingRoot, { recursive: false, mode: 0o700 });
       stagePackageRuntimeSnapshot(sourcePackageRoot, join(stagingRoot, 'package'), records);
-      atomicWrite(join(stagingRoot, 'package-files.json'), indexJson);
-      atomicWrite(join(stagingRoot, 'forge-runtime'), launcher, 0o700);
+      writeAtomicTextFile(join(stagingRoot, 'package-files.json'), indexJson);
+      writeAtomicTextFile(join(stagingRoot, 'forge-runtime'), launcher, 0o700);
       chmodSync(join(stagingRoot, 'forge-runtime'), 0o700);
-      atomicWrite(join(stagingRoot, processRunnerEntrypoint), processRunnerLauncher, 0o700);
+      writeAtomicTextFile(join(stagingRoot, processRunnerEntrypoint), processRunnerLauncher, 0o700);
       chmodSync(join(stagingRoot, processRunnerEntrypoint), 0o700);
-      atomicWrite(join(stagingRoot, checkRunnerEntrypoint), checkRunnerLauncher, 0o700);
+      writeAtomicTextFile(join(stagingRoot, checkRunnerEntrypoint), checkRunnerLauncher, 0o700);
       chmodSync(join(stagingRoot, checkRunnerEntrypoint), 0o700);
       const manifest: RuntimeReleaseManifest = { ...expectedManifest, createdAt: new Date().toISOString() };
       const stagingManifestPath = join(stagingRoot, 'manifest.json');
-      atomicWrite(stagingManifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+      writeAtomicTextFile(stagingManifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
       // A failed execution surface is still a staging failure. Do not promote an
       // immutable release directory until both manifest-owned runners execute
       // their bounded no-op canary successfully.

package/src/runtime/root/package-runtime-service.ts

@@ -1,5 +1,6 @@
+import { writeAtomicTextFile } from '../shared/atomic-text-file';
 import { randomUUID } from 'crypto';
-import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'fs';
+import { existsSync, readFileSync, rmSync } from 'fs';
 import { setTimeout as sleep } from 'timers/promises';
 import { dirname, join, resolve } from 'path';
 import { resolveControllerHome } from '../../cli/repositories/controller-home';
@@ -114,13 +115,6 @@ export interface PackageRuntimeActivationDependencies {
   cleanupActivationHelper?: (request: PackageRuntimeActivationRequest) => Promise<void>;
 }
 
-function atomicWrite(path: string, content: string, mode = 0o600): void {
-  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-  const temporary = `${path}.${process.pid}.tmp`;
-  writeFileSync(temporary, content, { encoding: 'utf8', mode });
-  renameSync(temporary, path);
-}
-
 export function renderForgeRuntimeSystemdUserUnit(input: {
   description?: string;
   executable: string;
@@ -189,7 +183,7 @@ function startPortableRuntime(controllerHome: string, env: NodeJS.ProcessEnv, ho
     stderrPath: paths.stderrPath,
     errorCode: 'FORGE_PORTABLE_RUNTIME_START_FAILED',
   });
-  atomicWrite(join(paths.serviceRoot, 'portable.json'), `${JSON.stringify({ schemaVersion: 1, pid, startedAt: new Date().toISOString() }, null, 2)}\n`);
+  writeAtomicTextFile(join(paths.serviceRoot, 'portable.json'), `${JSON.stringify({ schemaVersion: 1, pid, startedAt: new Date().toISOString() }, null, 2)}\n`);
   return pid;
 }
 
@@ -208,7 +202,7 @@ function activationPaths(controllerHome: string, operationId: string): { request
 }
 
 function writeActivationRequest(request: PackageRuntimeActivationRequest): void {
-  atomicWrite(request.requestPath, `${JSON.stringify(request, null, 2)}\n`);
+  writeAtomicTextFile(request.requestPath, `${JSON.stringify(request, null, 2)}\n`);
 }
 
 function writeActivationReceipt(
@@ -232,7 +226,7 @@ function writeActivationReceipt(
     helperLabel: request.helperLabel,
     ...extra,
   };
-  atomicWrite(request.receiptPath, `${JSON.stringify(receipt, null, 2)}\n`);
+  writeAtomicTextFile(request.receiptPath, `${JSON.stringify(receipt, null, 2)}\n`);
   return receipt;
 }
 
@@ -299,7 +293,7 @@ export function renderPackageRuntimeActivationLaunchAgent(request: PackageRuntim
 async function scheduleDarwinPackageRuntimeActivation(request: PackageRuntimeActivationRequest): Promise<{ label: string; servicePath: string }> {
   if (process.platform !== 'darwin') throw new Error('FORGE_PACKAGE_RUNTIME_ACTIVATION_HELPER_PLATFORM_UNSUPPORTED');
   const host = createPlatformServiceManagerHost({ platform: 'darwin' });
-  atomicWrite(request.helperSourcePlistPath, renderPackageRuntimeActivationLaunchAgent(request), 0o600);
+  writeAtomicTextFile(request.helperSourcePlistPath, renderPackageRuntimeActivationLaunchAgent(request), 0o600);
   host.installLaunchd(request.helperSourcePlistPath, request.helperLabel);
   const result = await host.bootstrapLaunchd({ label: request.helperLabel, plistPath: request.helperInstalledPlistPath });
   if (!result.ok) throw new Error(`FORGE_PACKAGE_RUNTIME_ACTIVATION_HELPER_BOOTSTRAP_FAILED: ${result.diagnostics.join('; ')}`);
@@ -351,7 +345,7 @@ async function rollbackPackageRuntimeActivation(
   }
   try {
     if (request.priorConfigBytes === undefined) rmSync(servicePaths.configPath, { force: true });
-    else atomicWrite(servicePaths.configPath, request.priorConfigBytes);
+    else writeAtomicTextFile(servicePaths.configPath, request.priorConfigBytes);
     syncForgeRuntimeActiveEntrypoint(request.controllerHome);
   } catch (error) {
     errors.push(error instanceof Error ? error.message : String(error));

package/src/runtime/root/release-execution-canary.ts

@@ -1,3 +1,4 @@
+import { readFileSync } from 'fs';
 import { join } from 'path';
 import { runProcess } from '../../effects/process-runner';
 import { PROCESS_RUNTIME_RELEASE_CANARY_ARG } from '../execution/process-runtime/canary';
@@ -25,9 +26,9 @@ export interface RuntimeReleaseExecutionCanaryDependencies {
 /**
  * Release execution canaries deliberately do not inherit developer-tool PATH
  * entries. Standalone-binary artifacts must execute without Homebrew, Bun, nvm,
- * or similar PATH dependencies. Legacy script releases predate the embedded
- * Runtime interpreter and are probed through the same explicitly resolved Bun
- * executable that their Process Runtime uses in production.
+ * or similar PATH dependencies. Legacy source scripts are probed through the
+ * same explicitly resolved Bun executable that their Process Runtime uses in
+ * production, while executable shebangs remain the artifact's own launch contract.
  */
 export function runtimeReleaseCanaryEnvironment(
   env: NodeJS.ProcessEnv = process.env,
@@ -43,6 +44,17 @@ export function runtimeReleaseCanaryEnvironment(
   return { ...env, PATH: '/usr/bin:/bin:/usr/sbin:/sbin' };
 }
 
+/**
+ * Execute legacy JavaScript/TypeScript through the resolved Bun runtime only
+ * when the artifact does not declare a different executable shebang.
+ */
+function releaseScriptRequiresBun(entryPath: string): boolean {
+  const firstLine = readFileSync(entryPath, 'utf8').split(/\r?\n/, 1)[0]?.trim() ?? '';
+  if (!firstLine.startsWith('#!')) return true;
+  const shebangTokens = firstLine.slice(2).trim().split(/\s+/).filter(Boolean);
+  return shebangTokens.some((token) => /(?:^|\/)bun(?:\.exe)?$/i.test(token));
+}
+
 /**
  * Execute the minimum immutable Runtime execution surface plus the package
  * Connector CLI import graph. The latter is intentionally a help-only command:
@@ -81,10 +93,11 @@ export function assertRuntimeReleaseExecutionCanaries(
     const args = entry.canary === 'runtime_interpreter' ? ['--version'] : [PROCESS_RUNTIME_RELEASE_CANARY_ARG];
     const legacyScript = surface.manifest.executionMode !== 'standalone-binary'
       && /\.(?:[cm]?js|tsx?)$/i.test(entry.path);
+    const usesExplicitBun = legacyScript && releaseScriptRequiresBun(entry.path);
     assertCanary({
       name: entry.name,
-      executable: legacyScript ? resolveBunExecutable(process.execPath, process.env) : entry.path,
-      args: legacyScript ? [entry.path, ...args] : args,
+      executable: usesExplicitBun ? resolveBunExecutable(process.execPath, process.env) : entry.path,
+      args: usesExplicitBun ? [entry.path, ...args] : args,
     });
   }
 

package/src/runtime/root/release-manifest.ts

@@ -65,9 +65,6 @@ export const COMPILED_RUNTIME_RELEASE_COMPONENT_FIELDS = [
   'periodicCleanupEntrypoint', 'periodicCleanupArtifactIdentity',
   'pluginActionSidecarEntrypoint', 'pluginActionSidecarArtifactIdentity',
   'externalPluginProbeEntrypoint', 'externalPluginProbeArtifactIdentity',
-  'codeGraphNodeEntrypoint', 'codeGraphNodeArtifactIdentity',
-  'codeGraphSidecarEntrypoint', 'codeGraphSidecarArtifactIdentity',
-  'codeGraphLibraryRoot', 'codeGraphLibraryArtifactIdentity',
   'packageRoot', 'packageArtifactIdentity',
 ] as const satisfies readonly (keyof RuntimeReleaseManifest)[];
 
@@ -278,36 +275,6 @@ export function loadRuntimeReleaseManifest(
     };
   }
 
-  const codeGraphFields = [
-    value.codeGraphNodeEntrypoint,
-    value.codeGraphNodeArtifactIdentity,
-    value.codeGraphSidecarEntrypoint,
-    value.codeGraphSidecarArtifactIdentity,
-    value.codeGraphLibraryRoot,
-    value.codeGraphLibraryArtifactIdentity,
-  ];
-  const hasCodeGraphRuntime = codeGraphFields.some((entry) => entry !== undefined);
-  let codeGraphRuntime: Pick<RuntimeReleaseManifest,
-    'codeGraphNodeEntrypoint' | 'codeGraphNodeArtifactIdentity'
-    | 'codeGraphSidecarEntrypoint' | 'codeGraphSidecarArtifactIdentity'
-    | 'codeGraphLibraryRoot' | 'codeGraphLibraryArtifactIdentity'> | undefined;
-  if (hasCodeGraphRuntime) {
-    const nodeEntrypoint = requireString(value.codeGraphNodeEntrypoint, 'codeGraphNodeEntrypoint');
-    const sidecarEntrypoint = requireString(value.codeGraphSidecarEntrypoint, 'codeGraphSidecarEntrypoint');
-    const libraryRoot = requireString(value.codeGraphLibraryRoot, 'codeGraphLibraryRoot');
-    if (nodeEntrypoint !== 'codegraph-node' || sidecarEntrypoint !== 'codegraph-sidecar.cjs' || libraryRoot !== 'codegraph-lib') {
-      throw new Error('RELEASE_MANIFEST_INVALID: CodeGraph release paths must use the canonical co-located names');
-    }
-    codeGraphRuntime = {
-      codeGraphNodeEntrypoint: 'codegraph-node',
-      codeGraphNodeArtifactIdentity: requireSha256Identity(value.codeGraphNodeArtifactIdentity, 'codeGraphNodeArtifactIdentity'),
-      codeGraphSidecarEntrypoint: 'codegraph-sidecar.cjs',
-      codeGraphSidecarArtifactIdentity: requireSha256Identity(value.codeGraphSidecarArtifactIdentity, 'codeGraphSidecarArtifactIdentity'),
-      codeGraphLibraryRoot: 'codegraph-lib',
-      codeGraphLibraryArtifactIdentity: requireSha256Identity(value.codeGraphLibraryArtifactIdentity, 'codeGraphLibraryArtifactIdentity'),
-    };
-  }
-
   const argumentsValue = value.arguments;
   if (!Array.isArray(argumentsValue) || argumentsValue.some((item) => typeof item !== 'string')) {
     throw new Error('RELEASE_MANIFEST_INVALID: arguments must be a string array');
@@ -341,7 +308,6 @@ export function loadRuntimeReleaseManifest(
     ...(pluginActionSidecar ?? {}),
     ...(externalPluginProbe ?? {}),
     ...(browserAutomationHelper ?? {}),
-    ...(codeGraphRuntime ?? {}),
     ...(packageSnapshot ?? {}),
     ...(controllerUi ?? {}),
     arguments: argumentsValue as string[],

package/src/runtime/root/release-materialize.ts

@@ -1,5 +1,4 @@
 import { createHash, randomUUID } from 'crypto';
-import { createRequire } from 'module';
 import { chmodSync, copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, symlinkSync, writeFileSync } from 'fs';
 import { tmpdir } from 'os';
 import { dirname, join, relative, resolve } from 'path';
@@ -50,9 +49,6 @@ export interface StagedRuntimeRelease {
   periodicCleanupArtifactIdentity?: string;
   pluginActionSidecarArtifactIdentity?: string;
   externalPluginProbeArtifactIdentity?: string;
-  codeGraphNodeArtifactIdentity?: string;
-  codeGraphSidecarArtifactIdentity?: string;
-  codeGraphLibraryArtifactIdentity?: string;
   packageArtifactIdentity?: string;
   controllerUiArtifactIdentity?: string;
   macosCodeSigning?: MacOSRuntimeCodeSigning;
@@ -71,12 +67,6 @@ export interface RuntimeReleaseMaterializerDependencies {
   materializeRuntimeInterpreter?: (input: { sourceRoot: string; outputPath: string }) => { ok: boolean; stderr?: string; stdout?: string; error?: string };
   bundleNodeHost?: (input: { sourceRoot: string; outputPath: string; entryPath: string }) => { ok: boolean; stderr?: string; stdout?: string; error?: string };
   bundleProcessRunner?: (input: { sourceRoot: string; outputPath: string; entryPath: string }) => { ok: boolean; stderr?: string; stdout?: string; error?: string };
-  materializeCodeGraphRuntime?: (input: {
-    sourceRoot: string;
-    nodeOutputPath: string;
-    sidecarOutputPath: string;
-    libraryOutputPath: string;
-  }) => { ok: boolean; stderr?: string; stdout?: string; error?: string };
 }
 
 export interface CandidateRuntimeStageReceiptV1 {
@@ -450,9 +440,6 @@ export function stageRuntimeReleaseFromCandidateSource(input: {
     periodicCleanupArtifactIdentity: manifest.periodicCleanupArtifactIdentity,
     pluginActionSidecarArtifactIdentity: manifest.pluginActionSidecarArtifactIdentity,
     externalPluginProbeArtifactIdentity: manifest.externalPluginProbeArtifactIdentity,
-    codeGraphNodeArtifactIdentity: manifest.codeGraphNodeArtifactIdentity,
-    codeGraphSidecarArtifactIdentity: manifest.codeGraphSidecarArtifactIdentity,
-    codeGraphLibraryArtifactIdentity: manifest.codeGraphLibraryArtifactIdentity,
     packageArtifactIdentity: manifest.packageArtifactIdentity,
     controllerUiArtifactIdentity: manifest.controllerUiArtifactIdentity,
     ...(macosCodeSigning ? { macosCodeSigning } : {}),
@@ -526,32 +513,6 @@ function defaultBundleNodeScript(input: { sourceRoot: string; outputPath: string
   ], { cwd: input.sourceRoot, timeoutMs: 300_000, maxOutputBytes: 512 * 1024 });
 }
 
-function defaultMaterializeCodeGraphRuntime(input: {
-  sourceRoot: string;
-  nodeOutputPath: string;
-  sidecarOutputPath: string;
-  libraryOutputPath: string;
-}): { ok: boolean; stderr?: string; stdout?: string; error?: string } {
-  try {
-    const sourceRequire = createRequire(join(input.sourceRoot, 'package.json'));
-    const platformPackage = `@colbymchenry/codegraph-${process.platform}-${process.arch}`;
-    const packageJson = sourceRequire.resolve(`${platformPackage}/package.json`);
-    const packageRoot = dirname(packageJson);
-    const nodeSource = join(packageRoot, process.platform === 'win32' ? 'node.exe' : 'node');
-    const librarySource = join(packageRoot, 'lib');
-    const sidecarSource = join(input.sourceRoot, 'src', 'runtime', 'context', 'codegraph-sidecar.cjs');
-    if (!existsSync(nodeSource) || !statSync(nodeSource).isFile()) throw new Error(`${platformPackage} Node runtime is missing`);
-    if (!existsSync(librarySource) || !statSync(librarySource).isDirectory()) throw new Error(`${platformPackage} library is missing`);
-    if (!existsSync(sidecarSource)) throw new Error('CodeGraph sidecar source is missing');
-    copyFileSync(nodeSource, input.nodeOutputPath);
-    copyFileSync(sidecarSource, input.sidecarOutputPath);
-    cpSync(librarySource, input.libraryOutputPath, { recursive: true, force: false });
-    return { ok: true };
-  } catch (error) {
-    return { ok: false, error: error instanceof Error ? error.message : String(error) };
-  }
-}
-
 export function stageRuntimeRelease(input: {
   controllerHome: string;
   sourceRoot: string;
@@ -799,27 +760,6 @@ export function stageRuntimeRelease(input: {
     chmodSync(externalPluginProbePath, 0o700);
     const externalPluginProbeArtifactIdentity = `sha256:${sha256(externalPluginProbePath)}`;
 
-    const codeGraphNodeEntrypoint = 'codegraph-node' as const;
-    const codeGraphSidecarEntrypoint = 'codegraph-sidecar.cjs' as const;
-    const codeGraphLibraryRoot = 'codegraph-lib' as const;
-    const codeGraphNodePath = join(staging, codeGraphNodeEntrypoint);
-    const codeGraphSidecarPath = join(staging, codeGraphSidecarEntrypoint);
-    const codeGraphLibraryPath = join(staging, codeGraphLibraryRoot);
-    const codeGraphRuntime = (dependencies.materializeCodeGraphRuntime ?? defaultMaterializeCodeGraphRuntime)({
-      sourceRoot,
-      nodeOutputPath: codeGraphNodePath,
-      sidecarOutputPath: codeGraphSidecarPath,
-      libraryOutputPath: codeGraphLibraryPath,
-    });
-    if (!codeGraphRuntime.ok) {
-      throw new Error(`RUNTIME_RELEASE_CODEGRAPH_BUILD_FAILED: ${codeGraphRuntime.stderr || codeGraphRuntime.stdout || codeGraphRuntime.error}`.slice(0, 2_000));
-    }
-    chmodSync(codeGraphNodePath, 0o700);
-    chmodSync(codeGraphSidecarPath, 0o700);
-    const codeGraphNodeArtifactIdentity = `sha256:${sha256(codeGraphNodePath)}`;
-    const codeGraphSidecarArtifactIdentity = `sha256:${sha256(codeGraphSidecarPath)}`;
-    const codeGraphLibraryArtifactIdentity = `sha256:${sha256Directory(codeGraphLibraryPath)}`;
-
     // Keep the source-backed package projection during the Recovery migration.
     // The active standalone Recovery release can predate the compiled Connector
     // sidecar and still rebind the primary Connector through package/src/cli.
@@ -870,12 +810,6 @@ export function stageRuntimeRelease(input: {
       pluginActionSidecarArtifactIdentity,
       externalPluginProbeEntrypoint,
       externalPluginProbeArtifactIdentity,
-      codeGraphNodeEntrypoint,
-      codeGraphNodeArtifactIdentity,
-      codeGraphSidecarEntrypoint,
-      codeGraphSidecarArtifactIdentity,
-      codeGraphLibraryRoot,
-      codeGraphLibraryArtifactIdentity,
       packageRoot,
       packageArtifactIdentity,
       arguments: [],
@@ -917,9 +851,6 @@ export function stageRuntimeRelease(input: {
       periodicCleanupArtifactIdentity,
       pluginActionSidecarArtifactIdentity,
       externalPluginProbeArtifactIdentity,
-      codeGraphNodeArtifactIdentity,
-      codeGraphSidecarArtifactIdentity,
-      codeGraphLibraryArtifactIdentity,
       packageArtifactIdentity,
       manifestSha256: createHash('sha256').update(`${JSON.stringify(manifest, null, 2)}\n`).digest('hex'),
       sourceCommit,
@@ -1165,15 +1096,6 @@ export function assertRuntimeReleaseFiles(release: StagedRuntimeRelease, depende
   assertComponentFile({ path: join(release.releasePath, 'forge-periodic-cleanup'), identity: release.periodicCleanupArtifactIdentity, missingCode: 'RUNTIME_RELEASE_PERIODIC_CLEANUP_MISSING', executable: true });
   assertComponentFile({ path: join(release.releasePath, 'forge-plugin-action-sidecar'), identity: release.pluginActionSidecarArtifactIdentity, missingCode: 'RUNTIME_RELEASE_PLUGIN_ACTION_SIDECAR_MISSING', executable: true });
   assertComponentFile({ path: join(release.releasePath, 'external-unix-socket-probe.cjs'), identity: release.externalPluginProbeArtifactIdentity, missingCode: 'RUNTIME_RELEASE_EXTERNAL_PLUGIN_PROBE_MISSING', executable: true });
-  assertComponentFile({ path: join(release.releasePath, 'codegraph-node'), identity: release.codeGraphNodeArtifactIdentity, missingCode: 'RUNTIME_RELEASE_CODEGRAPH_NODE_MISSING', executable: true });
-  assertComponentFile({ path: join(release.releasePath, 'codegraph-sidecar.cjs'), identity: release.codeGraphSidecarArtifactIdentity, missingCode: 'RUNTIME_RELEASE_CODEGRAPH_SIDECAR_MISSING', executable: true });
-  if (release.codeGraphLibraryArtifactIdentity) {
-    const libraryRoot = join(release.releasePath, 'codegraph-lib');
-    if (!existsSync(join(libraryRoot, 'dist', 'index.js'))) {
-      throw new Error(`RUNTIME_RELEASE_CODEGRAPH_LIBRARY_MISSING: ${join(libraryRoot, 'dist', 'index.js')}`);
-    }
-    assertDirectoryIdentity(libraryRoot, release.codeGraphLibraryArtifactIdentity);
-  }
   if (release.packageArtifactIdentity) {
     const packageRoot = join(release.releasePath, 'package');
     assertDirectoryIdentity(packageRoot, release.packageArtifactIdentity);

package/src/runtime/root/runtime.ts

@@ -10,7 +10,6 @@ import {
   enableControlPlaneReadConnectionReuse,
   inspectControlPlaneDatabase,
 } from '../control-plane/persistence/sqlite-store';
-import { closeCodeGraphReadProviderSessions } from '../context/codegraph-read-provider';
 import { cancelAllLightweightProcesses } from '../execution/process-runtime/lightweight-managed';
 import {
   collectRuntimeSourceIdentity,
@@ -196,7 +195,7 @@ const DEFAULT_DEPENDENCIES: CanonicalRuntimeDependencies = {
   collectRuntimeSourceIdentity,
   rotateRuntimeGeneration,
   stopLightweightProcesses: cancelAllLightweightProcesses,
-  stopContextReadHelpers: closeCodeGraphReadProviderSessions,
+  stopContextReadHelpers: async () => {},
   computeToolSurfaceFingerprint: runtimeGatewayToolSurfaceFingerprint,
   ensureForgeInstanceIdentity,
   captureJscSamplingProfile: captureDefaultJscSamplingProfile,

package/src/runtime/root/scheduled-controller-composition.ts

@@ -6,6 +6,7 @@ import {
   type ControllerSession,
 } from '../../../packages/kernel/controller/api/index';
 import { upsertChatgptControllerBinding } from '../../../adapters/chatgpt/controller-binding-store';
+import { DEFAULT_CHATGPT_AUTOMATION_REASONING } from '../../../adapters/chatgpt/provider-delivery';
 import { getWorkContract } from '../../../packages/kernel/work/api/index';
 import { inheritWorkflowSupervisorConversationBinding } from './workflow-supervisor-composition';
 import { getChatgptWorkConversationBinding } from '../../../adapters/chatgpt/work-conversation-binding-store';
@@ -30,7 +31,7 @@ export function ensureScheduledControllerBinding(
       ].map(value => value.trim()).filter(Boolean).filter((value, index, values) => values.indexOf(value) === index),
       title: input.scheduleName,
       model: typeof input.args.model === 'string' ? input.args.model : 'gpt-5.6',
-      reasoning: input.args.reasoning === 'medium' || input.args.reasoning === 'high' || input.args.reasoning === 'xhigh' ? input.args.reasoning : 'medium',
+      reasoning: input.args.reasoning === 'medium' || input.args.reasoning === 'high' || input.args.reasoning === 'xhigh' ? input.args.reasoning : DEFAULT_CHATGPT_AUTOMATION_REASONING,
       tabPolicy: input.args.tab_policy === 'reuse' || input.args.tab_policy === 'new' ? input.args.tab_policy : 'auto',
       timeoutMs: typeof input.args.timeout_ms === 'number' ? input.args.timeout_ms : undefined,
     }).binding;