fix(runtime): Separate MCP hydration and refresh scheduling state

Return explicit hydration status so bootstrap logging reflects what happened.

Log hydration even when background simulator refresh is not scheduled.

Also remove a trivial simulator selector pass-through in infer-platform

to reduce indirection, and add coverage for scheme-only defaults.

Refs #206

Co-Authored-By: Codex <noreply@openai.com>

Author: cameroncooke

src/runtime/__tests__/bootstrap-runtime.test.ts

@@ -29,6 +29,20 @@ function createFsWithSessionDefaults() {
   });
 }
 
+function createFsWithSchemeOnlySessionDefaults() {
+  const yaml = ['schemaVersion: 1', 'sessionDefaults:', '  scheme: "AppScheme"', ''].join('\n');
+
+  return createMockFileSystemExecutor({
+    existsSync: (targetPath: string) => targetPath === configPath,
+    readFile: async (targetPath: string) => {
+      if (targetPath !== configPath) {
+        throw new Error(`Unexpected readFile path: ${targetPath}`);
+      }
+      return yaml;
+    },
+  });
+}
+
 describe('bootstrapRuntime', () => {
   beforeEach(() => {
     __resetConfigStoreForTests();
@@ -50,6 +64,21 @@ describe('bootstrapRuntime', () => {
     });
   });
 
+  it('hydrates non-simulator session defaults for mcp runtime', async () => {
+    const result = await bootstrapRuntime({
+      runtime: 'mcp',
+      cwd,
+      fs: createFsWithSchemeOnlySessionDefaults(),
+    });
+
+    expect(result.runtime.config.sessionDefaults?.scheme).toBe('AppScheme');
+    expect(sessionStore.getAll()).toMatchObject({
+      scheme: 'AppScheme',
+    });
+    expect(sessionStore.getAll().simulatorId).toBeUndefined();
+    expect(sessionStore.getAll().simulatorName).toBeUndefined();
+  });
+
   it.each(['cli', 'daemon'] as const)(
     'does not hydrate session defaults for %s runtime',
     async (runtime: RuntimeKind) => {

src/runtime/bootstrap-runtime.ts

@@ -33,25 +33,34 @@ export interface BootstrapRuntimeResult {
   notices: string[];
 }
 
+interface MCPSessionHydrationResult {
+  hydrated: boolean;
+  refreshScheduled: boolean;
+}
+
 /**
- * Returns true when defaults were hydrated and a background simulator refresh was scheduled.
+ * Hydrates MCP session defaults and reports whether a background simulator refresh was scheduled.
  */
-function hydrateSessionDefaultsForMcp(defaults: Partial<SessionDefaults> | undefined): boolean {
+function hydrateSessionDefaultsForMcp(
+  defaults: Partial<SessionDefaults> | undefined,
+): MCPSessionHydrationResult {
   const hydratedDefaults = { ...(defaults ?? {}) };
   if (Object.keys(hydratedDefaults).length === 0) {
-    return false;
+    return { hydrated: false, refreshScheduled: false };
   }
 
   sessionStore.setDefaults(hydratedDefaults);
   const revision = sessionStore.getRevision();
-  return scheduleSimulatorDefaultsRefresh({
+  const refreshScheduled = scheduleSimulatorDefaultsRefresh({
     expectedRevision: revision,
     reason: 'startup-hydration',
     persist: true,
     simulatorId: hydratedDefaults.simulatorId,
     simulatorName: hydratedDefaults.simulatorName,
     recomputePlatform: true,
   });
+
+  return { hydrated: true, refreshScheduled };
 }
 
 export async function bootstrapRuntime(
@@ -75,8 +84,16 @@ export async function bootstrapRuntime(
 
   const config = getConfig();
 
-  if (opts.runtime === 'mcp' && hydrateSessionDefaultsForMcp(config.sessionDefaults)) {
-    log('info', '[Session] Hydrated MCP session defaults; simulator metadata refresh scheduled.');
+  if (opts.runtime === 'mcp') {
+    const hydration = hydrateSessionDefaultsForMcp(config.sessionDefaults);
+    if (hydration.hydrated && hydration.refreshScheduled) {
+      log('info', '[Session] Hydrated MCP session defaults; simulator metadata refresh scheduled.');
+    } else if (hydration.hydrated) {
+      log(
+        'info',
+        '[Session] Hydrated MCP session defaults; simulator metadata refresh not scheduled.',
+      );
+    }
   }
 
   return {

src/utils/infer-platform.ts

@@ -110,17 +110,6 @@ function inferSimulatorSelectorForTool(params: {
   return {};
 }
 
-function resolveSimulatorsFromSession(params: InferPlatformParams): {
-  simulatorId?: string;
-  simulatorName?: string;
-} {
-  return inferSimulatorSelectorForTool({
-    simulatorId: params.simulatorId,
-    simulatorName: params.simulatorName,
-    sessionDefaults: params.sessionDefaults,
-  });
-}
-
 function resolveCachedPlatform(params: InferPlatformParams): SimulatorPlatform | null {
   const defaults = params.sessionDefaults ?? sessionStore.getAll();
   if (!isSimulatorPlatform(defaults.simulatorPlatform)) {
@@ -246,7 +235,11 @@ export async function inferPlatform(
     return { platform: cachedPlatform, source: 'simulator-platform-cache' };
   }
 
-  const { simulatorId, simulatorName } = resolveSimulatorsFromSession(params);
+  const { simulatorId, simulatorName } = inferSimulatorSelectorForTool({
+    simulatorId: params.simulatorId,
+    simulatorName: params.simulatorName,
+    sessionDefaults: params.sessionDefaults,
+  });
 
   let simulatorIdForLookup = simulatorId;
   let simulatorNameForLookup = simulatorName;