@moretea-labs/forge 1.8.0 → 1.8.1

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

@@ -3,6 +3,11 @@ import type { AssistantContextSnapshot, ControllerRoundRelayRecord } from '../..
 import { prepareAssistantWorkContext } from '../context/assistant-work-context';
 import { renderAssistantContext, type AssistantContextResolution } from '../context/assistant-context';
 import { getChatgptWorkConversationBinding } from '../../../adapters/chatgpt/work-conversation-binding-store';
+import {
+  chatgptControllerProviderBindingId,
+  upsertChatgptControllerBinding,
+  type ChatgptControllerBindingPayload,
+} from '../../../adapters/chatgpt/controller-binding-store';
 import {
   buildChatgptControllerRoundPrompt,
   chatgptControllerRoundBindingAuthorizesRecovery,
@@ -22,6 +27,18 @@ export interface ChatgptControllerRoundBindingSnapshot {
   bindingId?: string;
   browserSessionId?: string;
   conversationUrl?: string;
+  authorizationGrantRefs?: string[];
+}
+
+export function chatgptControllerRoundBindingId(workId: string): string {
+  return chatgptControllerProviderBindingId(workId);
+}
+
+export function upsertChatgptControllerRoundTransportBinding(
+  store: ControllerRoundCompositionStore,
+  input: Omit<ChatgptControllerBindingPayload, 'schemaVersion' | 'bindingId' | 'repoId' | 'createdAt' | 'updatedAt'>,
+) {
+  return upsertChatgptControllerBinding(store, input);
 }
 
 export function chatgptControllerRoundBinding(
@@ -34,6 +51,7 @@ export function chatgptControllerRoundBinding(
     bindingId: binding.bindingId,
     browserSessionId: binding.latestBrowserSessionId,
     conversationUrl: binding.conversationUrl,
+    authorizationGrantRefs: [...(binding.authorizationGrantRefs ?? [])],
   };
 }
 
@@ -65,6 +83,7 @@ export function recordChatgptControllerRoundTabSettlement(
     relayScopeId: string;
     status: ChatgptControllerRoundSettlementStatus;
     error?: string;
+    attemptIdentity?: string;
   },
 ): void {
   recordChatgptControllerRoundSettlement(store, input);
@@ -79,7 +98,7 @@ function controllerAssistantContextSnapshot(resolution: AssistantContextResoluti
     sourceRevision: item.provenance.sourceRevision,
   }));
   const identity = {
-    projectId: resolution.projectId,
+    ...(resolution.projectId ? { projectId: resolution.projectId } : {}),
     items,
     gaps: resolution.gaps,
     missingRequiredSources: resolution.missingRequiredSources,

package/src/runtime/root/deployment-topology.ts

@@ -0,0 +1,106 @@
+export type RuntimeRemoteControllerKind = 'chatgpt' | 'mcp';
+
+export interface RuntimeDeploymentTopology {
+  schemaVersion: 1;
+  remoteControllers: RuntimeRemoteControllerKind[];
+  capabilityIntents: string[];
+  persistentRuntimeRequired: boolean;
+  components: {
+    workflowSupervisor: boolean;
+    workflowSupervisorNativeBrowser: boolean;
+  };
+}
+
+const REMOTE_CONTROLLERS = new Set<RuntimeRemoteControllerKind>(['chatgpt', 'mcp']);
+
+function normalizeCapabilityIntent(value: string): string {
+  const normalized = value.trim().toLowerCase();
+  if (!/^[-a-z0-9_.]{3,128}$/.test(normalized)) throw new Error(`RUNTIME_TOPOLOGY_CAPABILITY_INTENT_INVALID: ${value}`);
+  return normalized;
+}
+
+function normalizedRemoteControllers(values: readonly string[] | undefined): RuntimeRemoteControllerKind[] {
+  return Array.from(new Set(
+    (values ?? [])
+      .map((value) => value.trim().toLowerCase())
+      .filter((value): value is RuntimeRemoteControllerKind => REMOTE_CONTROLLERS.has(value as RuntimeRemoteControllerKind)),
+  )).sort();
+}
+
+export function deriveRuntimeDeploymentTopology(input: {
+  controllers?: readonly string[];
+  capabilityIntents?: readonly string[];
+}): RuntimeDeploymentTopology {
+  const remoteControllers = normalizedRemoteControllers(input.controllers);
+  const capabilityIntents = Array.from(new Set(
+    (input.capabilityIntents ?? []).map(normalizeCapabilityIntent),
+  )).sort();
+  const chatgpt = remoteControllers.includes('chatgpt');
+  return {
+    schemaVersion: 1,
+    remoteControllers,
+    capabilityIntents,
+    persistentRuntimeRequired: remoteControllers.length > 0,
+    components: {
+      // Requirement-level ChatGPT continuation uses Supervisor Core as its
+      // outer-turn authority. Generic remote MCP transport does not.
+      workflowSupervisor: chatgpt,
+      // ChatGPT Work has one controlled outer-turn executor: the Supervisor's
+      // Computer adapter. It owns exact-conversation delivery and its durable
+      // effect ledger; Scheduler must never fall back to direct Browser delivery.
+      workflowSupervisorNativeBrowser: chatgpt,
+    },
+  };
+}
+
+/**
+ * Missing topology means an installation predates this contract. Preserve the
+ * complete ChatGPT Supervisor composition during upgrade.
+ */
+export function legacyRuntimeDeploymentTopology(): RuntimeDeploymentTopology {
+  return deriveRuntimeDeploymentTopology({ controllers: ['chatgpt'] });
+}
+
+export function normalizeRuntimeDeploymentTopology(value: unknown): RuntimeDeploymentTopology {
+  if (value === undefined || value === null) return legacyRuntimeDeploymentTopology();
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('RUNTIME_TOPOLOGY_INVALID');
+  const record = value as Record<string, unknown>;
+  if (record.schemaVersion !== 1) throw new Error('RUNTIME_TOPOLOGY_VERSION_UNSUPPORTED');
+  if (!Array.isArray(record.remoteControllers)
+    || record.remoteControllers.some((entry) => typeof entry !== 'string' || !REMOTE_CONTROLLERS.has(entry as RuntimeRemoteControllerKind))) {
+    throw new Error('RUNTIME_TOPOLOGY_REMOTE_CONTROLLERS_INVALID');
+  }
+  if (!Array.isArray(record.capabilityIntents)
+    || record.capabilityIntents.some((entry) => typeof entry !== 'string')) {
+    throw new Error('RUNTIME_TOPOLOGY_CAPABILITY_INTENTS_INVALID');
+  }
+  const remoteControllers = normalizedRemoteControllers(record.remoteControllers as string[]);
+  const capabilityIntents = Array.from(new Set(
+    (record.capabilityIntents as string[]).map(normalizeCapabilityIntent),
+  )).sort();
+  const canonical = deriveRuntimeDeploymentTopology({ controllers: remoteControllers, capabilityIntents });
+  const components = record.components;
+  if (!components || typeof components !== 'object' || Array.isArray(components)) throw new Error('RUNTIME_TOPOLOGY_COMPONENTS_REQUIRED');
+  const componentRecord = components as Record<string, unknown>;
+  if (typeof componentRecord.workflowSupervisor !== 'boolean'
+    || typeof componentRecord.workflowSupervisorNativeBrowser !== 'boolean') {
+    throw new Error('RUNTIME_TOPOLOGY_COMPONENTS_INVALID');
+  }
+  if (componentRecord.workflowSupervisor !== canonical.components.workflowSupervisor
+    || record.persistentRuntimeRequired !== canonical.persistentRuntimeRequired) {
+    throw new Error('RUNTIME_TOPOLOGY_DERIVATION_MISMATCH');
+  }
+  // The flag is derived, so stale persisted topology cannot disable the sole
+  // autonomous delivery owner or reintroduce an alternate Browser path.
+  return canonical;
+}
+
+export function parseRuntimeDeploymentTopologyArgument(value: string | undefined): RuntimeDeploymentTopology {
+  if (!value?.trim()) return legacyRuntimeDeploymentTopology();
+  try {
+    return normalizeRuntimeDeploymentTopology(JSON.parse(value));
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`RUNTIME_TOPOLOGY_ARGUMENT_INVALID: ${detail}`);
+  }
+}

package/src/runtime/root/entry.ts

@@ -3,6 +3,7 @@ import { resolve } from 'path';
 import { pathToFileURL } from 'url';
 import { Command } from 'commander';
 import { CanonicalForgeRuntime } from './runtime';
+import { parseRuntimeDeploymentTopologyArgument } from './deployment-topology';
 
 interface CliOptions {
   controllerHome: string;
@@ -11,7 +12,7 @@ interface CliOptions {
   host: string;
   port: string;
   authTokenFile: string;
-  exclusiveWorkId?: string;
+  deploymentTopology?: string;
 }
 
 function readAuthToken(path: string): string {
@@ -29,7 +30,7 @@ export async function runCanonicalRuntimeCli(argv = process.argv): Promise<void>
     .requiredOption('--host <host>', 'MCP listener host')
     .requiredOption('--port <port>', 'MCP listener port')
     .requiredOption('--auth-token-file <path>', 'Bearer token file')
-    .option('--exclusive-work-id <id>', 'Persistently admit only this P0 Work while migration is active');
+    .option('--deployment-topology <json>', 'Normalized product-level Runtime deployment topology');
   command.parse(argv);
   const options = command.opts<CliOptions>();
   const port = Number(options.port);
@@ -40,8 +41,8 @@ export async function runCanonicalRuntimeCli(argv = process.argv): Promise<void>
     releaseManifestPath: resolve(options.releaseManifest),
     host: options.host,
     port,
+    topology: parseRuntimeDeploymentTopologyArgument(options.deploymentTopology),
     authToken: readAuthToken(options.authTokenFile),
-    exclusiveWorkId: options.exclusiveWorkId,
   });
   await runtime.start();
   process.stderr.write(`${JSON.stringify({

package/src/runtime/root/known-good-recovery.ts

@@ -0,0 +1,184 @@
+import { createHash } from 'crypto';
+import { closeSync, existsSync, openSync, readFileSync, readSync, realpathSync } from 'fs';
+import { basename, dirname, join, relative, resolve } from 'path';
+import { inspectControlPlaneDatabaseFile, type ControlPlaneDatabaseInspection } from '../control-plane/persistence/sqlite-store';
+import { loadRuntimeReleaseManifest } from './release-manifest';
+import { forgeRuntimeServicePaths, validateForgeRuntimeServiceConfig, type ForgeRuntimeServiceConfig } from './service';
+
+/**
+ * A Recovery-owned, bounded restore point.  The release is immutable Runtime
+ * authority; the SQLite copy and service contract are the state and bootstrap
+ * material needed to make that release useful after the Kernel is dead.
+ */
+export interface KnownGoodRecoveryBundle {
+  schemaVersion: 1;
+  attestationId: string;
+  root: string;
+  database: {
+    path: string;
+    sha256: string;
+    schemaVersion: number;
+    recordCount: number;
+    auditEventCount: number;
+  };
+  serviceContract: {
+    path: string;
+    sha256: string;
+  };
+  createdAt: string;
+}
+
+export interface KnownGoodReleaseIdentity {
+  path: string;
+  revision: string;
+  artifactIdentity: string;
+  manifestSha256: string;
+  workerProtocolVersion: number;
+  controllerHome?: string;
+  recoveryBundle?: KnownGoodRecoveryBundle;
+}
+
+export interface InspectedKnownGoodRecoveryBundle {
+  releaseRoot: string;
+  database: ControlPlaneDatabaseInspection;
+  serviceConfig: ForgeRuntimeServiceConfig;
+}
+
+const SHA256_FILE_CHUNK_BYTES = 1024 * 1024;
+
+/** Hash arbitrarily large Recovery artifacts without allocating the whole file. */
+export function sha256FileBounded(path: string): string {
+  const descriptor = openSync(path, 'r');
+  const hash = createHash('sha256');
+  const buffer = Buffer.allocUnsafe(SHA256_FILE_CHUNK_BYTES);
+  try {
+    for (;;) {
+      const bytesRead = readSync(descriptor, buffer, 0, buffer.length, null);
+      if (bytesRead === 0) break;
+      hash.update(buffer.subarray(0, bytesRead));
+    }
+    return hash.digest('hex');
+  } finally {
+    closeSync(descriptor);
+  }
+}
+
+function canonical(path: string): string {
+  try { return realpathSync(path); }
+  catch { return resolve(path); }
+}
+
+function directChild(root: string, path: string): boolean {
+  return canonical(dirname(path)) === canonical(root);
+}
+
+function inside(root: string, path: string): boolean {
+  const value = relative(canonical(root), canonical(path));
+  return value === '' || (!value.startsWith('..') && value !== '..');
+}
+
+function requiredText(value: unknown, code: string): string {
+  if (typeof value !== 'string' || !value.trim()) throw new Error(code);
+  return value.trim();
+}
+
+function requiredPositiveInteger(value: unknown, code: string): number {
+  if (!Number.isInteger(value) || Number(value) < 1) throw new Error(code);
+  return Number(value);
+}
+
+function validateRecoveryBundleShape(entry: KnownGoodReleaseIdentity, controllerHome: string): KnownGoodRecoveryBundle {
+  const bundle = entry.recoveryBundle;
+  if (!bundle || bundle.schemaVersion !== 1) throw new Error('KNOWN_GOOD_RECOVERY_BUNDLE_MISSING');
+  const home = resolve(controllerHome);
+  const root = resolve(bundle.root);
+  const expectedBundlesRoot = resolve(home, 'recovery', 'bundles', 'known-good');
+  const attestationId = requiredText(bundle.attestationId, 'KNOWN_GOOD_RECOVERY_BUNDLE_ID_INVALID');
+  if (basename(root) !== attestationId || !directChild(expectedBundlesRoot, root)) {
+    throw new Error('KNOWN_GOOD_RECOVERY_BUNDLE_OUTSIDE_AUTHORITY');
+  }
+  if (!/^[-a-zA-Z0-9_]{8,160}$/.test(attestationId)) throw new Error('KNOWN_GOOD_RECOVERY_BUNDLE_ID_INVALID');
+  if (!inside(root, bundle.database.path) || basename(resolve(bundle.database.path)) !== 'controller.sqlite') {
+    throw new Error('KNOWN_GOOD_RECOVERY_DATABASE_PATH_INVALID');
+  }
+  if (!inside(root, bundle.serviceContract.path) || basename(resolve(bundle.serviceContract.path)) !== 'service-contract.json') {
+    throw new Error('KNOWN_GOOD_RECOVERY_SERVICE_CONTRACT_PATH_INVALID');
+  }
+  requiredText(bundle.database.sha256, 'KNOWN_GOOD_RECOVERY_DATABASE_HASH_INVALID');
+  requiredText(bundle.serviceContract.sha256, 'KNOWN_GOOD_RECOVERY_SERVICE_CONTRACT_HASH_INVALID');
+  requiredPositiveInteger(bundle.database.schemaVersion, 'KNOWN_GOOD_RECOVERY_DATABASE_SCHEMA_INVALID');
+  return {
+    ...bundle,
+    attestationId,
+    root,
+    database: { ...bundle.database, path: resolve(bundle.database.path) },
+    serviceContract: { ...bundle.serviceContract, path: resolve(bundle.serviceContract.path) },
+  };
+}
+
+/**
+ * Validate the exact three-way restore invariant used by both Recovery and
+ * release retention.  Legacy evidence without a Recovery bundle is historical
+ * audit data only: it must never be promoted to recoverable authority.
+ */
+export function inspectKnownGoodRecoveryBundle(
+  controllerHome: string,
+  entry: KnownGoodReleaseIdentity,
+): InspectedKnownGoodRecoveryBundle {
+  const home = resolve(controllerHome);
+  if (entry.controllerHome && canonical(entry.controllerHome) !== canonical(home)) {
+    throw new Error('KNOWN_GOOD_RECOVERY_CONTROLLER_HOME_MISMATCH');
+  }
+  const manifestPath = resolve(requiredText(entry.path, 'KNOWN_GOOD_RELEASE_MANIFEST_PATH_INVALID'));
+  const releasesRoot = resolve(home, 'runtime', 'releases');
+  const releaseRoot = dirname(manifestPath);
+  if (
+    basename(manifestPath) !== 'manifest.json'
+    || basename(releaseRoot) !== entry.revision
+    || !directChild(releasesRoot, releaseRoot)
+    || !existsSync(manifestPath)
+  ) throw new Error('KNOWN_GOOD_RELEASE_OUTSIDE_AUTHORITY');
+  const manifest = loadRuntimeReleaseManifest(manifestPath, home);
+  if (
+    manifest.releaseId !== entry.revision
+    || manifest.artifactIdentity !== entry.artifactIdentity
+    || manifest.workerProtocolVersion !== entry.workerProtocolVersion
+    || sha256FileBounded(manifestPath) !== entry.manifestSha256
+  ) throw new Error('KNOWN_GOOD_RELEASE_IDENTITY_MISMATCH');
+
+  const bundle = validateRecoveryBundleShape(entry, home);
+  if (!existsSync(bundle.database.path)) throw new Error('KNOWN_GOOD_RECOVERY_DATABASE_MISSING');
+  if (sha256FileBounded(bundle.database.path) !== bundle.database.sha256) throw new Error('KNOWN_GOOD_RECOVERY_DATABASE_HASH_MISMATCH');
+  const database = inspectControlPlaneDatabaseFile(bundle.database.path);
+  if (
+    database.schemaVersion !== bundle.database.schemaVersion
+    || database.recordCount !== bundle.database.recordCount
+    || database.auditEventCount !== bundle.database.auditEventCount
+  ) throw new Error('KNOWN_GOOD_RECOVERY_DATABASE_INSPECTION_MISMATCH');
+
+  if (!existsSync(bundle.serviceContract.path)) throw new Error('KNOWN_GOOD_RECOVERY_SERVICE_CONTRACT_MISSING');
+  if (sha256FileBounded(bundle.serviceContract.path) !== bundle.serviceContract.sha256) {
+    throw new Error('KNOWN_GOOD_RECOVERY_SERVICE_CONTRACT_HASH_MISMATCH');
+  }
+  let rawContract: unknown;
+  try { rawContract = JSON.parse(readFileSync(bundle.serviceContract.path, 'utf8')); }
+  catch { throw new Error('KNOWN_GOOD_RECOVERY_SERVICE_CONTRACT_INVALID'); }
+  if (!rawContract || typeof rawContract !== 'object' || Array.isArray(rawContract)) {
+    throw new Error('KNOWN_GOOD_RECOVERY_SERVICE_CONTRACT_INVALID');
+  }
+  const contract = rawContract as Record<string, unknown>;
+  if (contract.schemaVersion !== 1 || !contract.serviceConfig || typeof contract.serviceConfig !== 'object' || Array.isArray(contract.serviceConfig)) {
+    throw new Error('KNOWN_GOOD_RECOVERY_SERVICE_CONTRACT_INVALID');
+  }
+  const serviceConfig = validateForgeRuntimeServiceConfig(contract.serviceConfig as ForgeRuntimeServiceConfig);
+  if (canonical(serviceConfig.controllerHome) !== canonical(home)) throw new Error('KNOWN_GOOD_RECOVERY_SERVICE_HOME_MISMATCH');
+  const expectedConfigPath = forgeRuntimeServicePaths(home).configPath;
+  if (canonical(requiredText(contract.configPath, 'KNOWN_GOOD_RECOVERY_SERVICE_PATH_INVALID')) !== canonical(expectedConfigPath)) {
+    throw new Error('KNOWN_GOOD_RECOVERY_SERVICE_PATH_INVALID');
+  }
+  return { releaseRoot, database, serviceConfig };
+}
+
+export function knownGoodRecoveryBundleRoot(controllerHome: string): string {
+  return join(resolve(controllerHome), 'recovery', 'bundles', 'known-good');
+}

package/src/runtime/root/local-bridge.ts

@@ -35,7 +35,6 @@ export async function startConfiguredRuntimeLocalBridge(input: {
     controllerHome: input.controllerHome,
     host: local.host ?? '127.0.0.1',
     port: local.port ?? 8766,
-    openBrowser: local.autoOpen === true,
     mode: 'embedded',
   });
   const generation = readRuntimeGeneration(input.controllerHome)?.generation;

package/src/runtime/root/mcp-transport.ts

@@ -13,11 +13,19 @@ interface ManagedSession {
   activeStreams: number;
 }
 
+type RuntimeMcpRequestId = string | number;
+interface ActiveRuntimeMcpPost {
+  response: Response;
+  requestIds: RuntimeMcpRequestId[];
+  transport?: NodeStreamableHTTPServerTransport;
+}
+
 export interface RuntimeMcpSessionSnapshot {
   active: number;
   maximum: number;
   initializing: number;
   protected: number;
+  activeRequests: number;
   capacityAvailable: number;
   capacityEvictions: number;
 }
@@ -47,6 +55,8 @@ export interface StartRuntimeMcpTransportOptions {
   onFatal?: (error: Error) => void;
   /** Internal Runtime sessions are bounded even if a Gateway dies without DELETE. */
   maximumSessions?: number;
+  /** Test/embedded override; production defaults to the bounded cutover grace. */
+  requestDrainTimeoutMs?: number;
 }
 
 function authorized(request: Request, configuredToken: string): boolean {
@@ -76,6 +86,15 @@ function observesToolSurface(body: unknown): boolean {
   });
 }
 
+function runtimeMcpRequestIds(body: unknown): RuntimeMcpRequestId[] {
+  const values = Array.isArray(body) ? body : [body];
+  return values.flatMap((value) => {
+    if (!value || typeof value !== 'object') return [];
+    const id = (value as Record<string, unknown>).id;
+    return typeof id === 'string' || typeof id === 'number' ? [id] : [];
+  });
+}
+
 function parseBody(body: unknown): unknown {
   if (!Buffer.isBuffer(body)) return body;
   try { return JSON.parse(body.toString('utf8')); } catch {
@@ -95,7 +114,16 @@ function authMiddleware(token: string) {
 }
 
 const SESSION_CLOSE_TIMEOUT_MS = 1_000;
-const REQUEST_DRAIN_TIMEOUT_MS = 250;
+/**
+ * Cutover first withdraws admission, then gives already-admitted requests a
+ * bounded grace period that still fits inside the primary service stop budget.
+ * Requests that outlive it are explicitly settled as outcome-unknown before
+ * session/socket teardown, so an outer controller turn is never left waiting on
+ * a connection the Runtime is intentionally destroying.
+ */
+export const RUNTIME_MCP_REQUEST_DRAIN_TIMEOUT_MS = 5_000;
+const CUTOVER_SETTLEMENT_DRAIN_TIMEOUT_MS = 250;
+export const RUNTIME_MCP_CUTOVER_OUTCOME_UNKNOWN = 'MCP_RUNTIME_CUTOVER_OUTCOME_UNKNOWN';
 export const DEFAULT_RUNTIME_MCP_MAX_SESSIONS = 64;
 
 function boundedRuntimeMcpMaximumSessions(value: number | undefined): number {
@@ -112,31 +140,41 @@ function closeServer(server: NodeHttpServer): Promise<void> {
   });
 }
 
-function boundedDrain(wait: Promise<void>, timeoutMs: number): Promise<void> {
-  if (timeoutMs <= 0) return Promise.resolve();
-  return Promise.race([
-    wait.catch(() => undefined),
+async function boundedDrain(wait: Promise<void>, timeoutMs: number): Promise<boolean> {
+  if (timeoutMs <= 0) return false;
+  let drained = false;
+  await Promise.race([
+    wait.then(() => { drained = true; }).catch(() => undefined),
     new Promise<void>((resolve) => setTimeout(resolve, timeoutMs)),
   ]);
+  return drained;
 }
 
 export async function closeRuntimeMcpTransportResources(input: {
   closeListener: () => Promise<void>;
   closeSessions: Array<() => Promise<void>>;
   waitForRequestDrain?: () => Promise<void>;
+  settleActiveRequests?: () => void | Promise<void>;
   forceCloseConnections?: () => void;
   requestDrainTimeoutMs?: number;
   sessionCloseTimeoutMs?: number;
 }): Promise<void> {
-  // Withdraw the TCP listener first so no new request can enter. Allow ordinary
-  // short MCP calls to finish before closing their session transport; long SSE
-  // streams remain bounded and are force-closed after the drain window.
+  // Withdraw the listener first so no new request can enter. Existing calls get
+  // one bounded grace window. If that expires, settle still-open POST responses
+  // as explicit cutover/outcome-unknown before closing session transports. This
+  // preserves the no-blind-replay contract while preventing a controller turn
+  // from being stranded on a socket the Runtime is about to destroy.
   const listenerClose = input.closeListener();
   void listenerClose.catch(() => undefined);
-  await boundedDrain(
-    input.waitForRequestDrain?.() ?? Promise.resolve(),
-    Math.max(0, input.requestDrainTimeoutMs ?? REQUEST_DRAIN_TIMEOUT_MS),
+  const requestDrain = input.waitForRequestDrain?.() ?? Promise.resolve();
+  const drained = await boundedDrain(
+    requestDrain,
+    Math.max(0, input.requestDrainTimeoutMs ?? RUNTIME_MCP_REQUEST_DRAIN_TIMEOUT_MS),
   );
+  if (!drained) {
+    await input.settleActiveRequests?.();
+    await boundedDrain(requestDrain, CUTOVER_SETTLEMENT_DRAIN_TIMEOUT_MS);
+  }
   const sessionDrain = Promise.allSettled(input.closeSessions.map(async (close) => await close()));
   await boundedDrain(sessionDrain.then(() => undefined), Math.max(0, input.sessionCloseTimeoutMs ?? SESSION_CLOSE_TIMEOUT_MS));
   input.forceCloseConnections?.();
@@ -152,12 +190,14 @@ export async function startRuntimeMcpTransport(
   let initializingSessions = 0;
   let capacityEvictions = 0;
   let activeRequests = 0;
+  const activePosts = new Map<Response, ActiveRuntimeMcpPost>();
 
   const sessionSnapshot = (): RuntimeMcpSessionSnapshot => ({
     active: sessions.size,
     maximum: maximumSessions,
     initializing: initializingSessions,
     protected: [...sessions.values()].filter((session) => session.activePosts > 0).length,
+    activeRequests,
     capacityAvailable: Math.max(0, maximumSessions - sessions.size - initializingSessions),
     capacityEvictions,
   });
@@ -192,7 +232,7 @@ export async function startRuntimeMcpTransport(
       managed.lastActivityAt = Date.now();
     }
   };
-  const requestDrainWaiters = new Set<() => void>();
+  const postDrainWaiters = new Set<() => void>();
   const app = express();
   app.disable('x-powered-by');
   app.use((_req, res, next) => {
@@ -202,18 +242,17 @@ export async function startRuntimeMcpTransport(
       if (settled) return;
       settled = true;
       activeRequests = Math.max(0, activeRequests - 1);
-      if (activeRequests === 0) {
-        for (const resolve of requestDrainWaiters) resolve();
-        requestDrainWaiters.clear();
-      }
     };
     res.once('finish', settle);
     res.once('close', settle);
     next();
   });
-  const waitForRequestDrain = (): Promise<void> => activeRequests === 0
+  // Only POST requests can represent an in-flight tool mutation/read result that
+  // must settle before cutover. Long-lived GET/SSE streams are transport-only and
+  // must not consume the cutover grace window.
+  const waitForRequestDrain = (): Promise<void> => activePosts.size === 0
     ? Promise.resolve()
-    : new Promise<void>((resolve) => requestDrainWaiters.add(resolve));
+    : new Promise<void>((resolve) => postDrainWaiters.add(resolve));
   app.get('/ready', (_req, res) => {
     const readiness = options.readiness();
     res.status(readiness.ready ? 200 : 503).json(readiness);
@@ -221,12 +260,24 @@ export async function startRuntimeMcpTransport(
 
   const requireAuth = authMiddleware(options.authToken);
   app.post('/mcp', requireAuth, express.raw({ type: '*/*', limit: '1mb' }), (req, res) => {
+    const activePost: ActiveRuntimeMcpPost = { response: res, requestIds: [] };
+    activePosts.set(res, activePost);
+    const releasePostResponse = (): void => {
+      activePosts.delete(res);
+      if (activePosts.size === 0) {
+        for (const resolve of postDrainWaiters) resolve();
+        postDrainWaiters.clear();
+      }
+    };
+    res.once('finish', releasePostResponse);
+    res.once('close', releasePostResponse);
     void (async () => {
       let body: unknown;
       try { body = parseBody(req.body); } catch (error) {
         res.status(400).json({ error: error instanceof Error ? error.message : String(error) });
         return;
       }
+      activePost.requestIds = runtimeMcpRequestIds(body);
       if (observesToolSurface(body)) options.onToolSurfaceObservation?.();
       const requestedSessionId = req.headers['mcp-session-id'];
       const sessionId = typeof requestedSessionId === 'string' ? requestedSessionId : undefined;
@@ -265,6 +316,7 @@ export async function startRuntimeMcpTransport(
             });
           },
         });
+        activePost.transport = transport;
         transport.onclose = () => {
           if (transport.sessionId) sessions.delete(transport.sessionId);
         };
@@ -293,10 +345,15 @@ export async function startRuntimeMcpTransport(
         res.status(404).json({ error: 'mcp_session_not_found' });
         return;
       }
+      activePost.transport = managed.transport;
       await withManagedSessionRequest(managed, 'post', async () => await managed.transport.handleRequest(req, res, body));
     })().catch((error: unknown) => {
       if (!res.headersSent) res.status(500).json({ error: 'mcp_request_failed' });
       console.error('[forge-runtime mcp] request failed:', error);
+    }).finally(() => {
+      releasePostResponse();
+      res.off('finish', releasePostResponse);
+      res.off('close', releasePostResponse);
     });
   });
   app.get('/mcp', requireAuth, (req, res) => {
@@ -362,6 +419,7 @@ export async function startRuntimeMcpTransport(
       await closeRuntimeMcpTransportResources({
         closeListener: async () => await closeServer(httpServer),
         waitForRequestDrain,
+        requestDrainTimeoutMs: options.requestDrainTimeoutMs,
         // Snapshot sessions only after the request drain: an initialize request
         // already in flight may register its session while shutdown is starting.
         closeSessions: [async () => {
@@ -369,6 +427,41 @@ export async function startRuntimeMcpTransport(
           await Promise.allSettled(activeSessions.map(async ({ transport }) => await transport.close().catch(() => undefined)));
           sessions.clear();
         }],
+        settleActiveRequests: async () => {
+          for (const active of activePosts.values()) {
+            let protocolSettled = false;
+            if (active.transport && active.requestIds.length > 0) {
+              const outcomes = await Promise.allSettled(active.requestIds.map(async (id) => {
+                await active.transport!.send({
+                  jsonrpc: '2.0',
+                  id,
+                  error: {
+                    code: -32000,
+                    message: RUNTIME_MCP_CUTOVER_OUTCOME_UNKNOWN,
+                    data: {
+                      outcome: 'unknown',
+                      recoverable: true,
+                      retryable: false,
+                      action: 'reconcile',
+                    },
+                  },
+                });
+              }));
+              protocolSettled = outcomes.some((outcome) => outcome.status === 'fulfilled');
+            }
+            if (protocolSettled) continue;
+            const response = active.response;
+            if (response.destroyed || response.writableEnded || response.headersSent) continue;
+            response.status(409).json({
+              error: 'runtime_cutover_outcome_unknown',
+              code: RUNTIME_MCP_CUTOVER_OUTCOME_UNKNOWN,
+              message: 'Canonical Runtime entered cutover after this request was admitted. The request outcome is unknown; reconcile by request/effect identity before any retry.',
+              recoverable: true,
+              retryable: false,
+              action: 'reconcile',
+            });
+          }
+        },
         forceCloseConnections: () => httpServer.closeAllConnections?.(),
       });
     },