fix(simulator): Correct refresh signaling and selector notices

Return explicit scheduling status from simulator defaults refresh so MCP
bootstrap logs only claim refresh scheduling when one is actually queued.

Tighten session default notices so cleared selector messages only appear
when a counterpart existed, and changed messages only appear on actual
selector changes.

Also prefer workspace defaults over project defaults when both are present,
remove an unnecessary infer-platform export, and drop emoji from simulator
build/run user-facing success strings.

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

Author: cameroncooke

src/mcp/tools/session-management/__tests__/session_set_defaults.test.ts

@@ -125,7 +125,7 @@ describe('session-set-defaults tool', () => {
       expect(current.simulatorId).toBe('RESOLVED-SIM-UUID');
       expect(current.simulatorName).toBeUndefined();
       expect(result.content[0].text).toContain(
-        'Cleared simulatorName because simulatorId changed; background resolution will repopulate it.',
+        'Cleared simulatorName because simulatorId was set; background resolution will repopulate it.',
       );
     });
 
@@ -137,10 +137,20 @@ describe('session-set-defaults tool', () => {
       expect(current.simulatorName).toBe('iPhone 16');
       expect(current.simulatorId).toBeUndefined();
       expect(result.content[0].text).toContain(
-        'Cleared simulatorId because simulatorName changed; background resolution will repopulate it.',
+        'Cleared simulatorId because simulatorName was set; background resolution will repopulate it.',
       );
     });
 
+    it('does not claim simulatorName was cleared when none existed', async () => {
+      sessionStore.setDefaults({ simulatorId: 'RESOLVED-SIM-UUID' });
+      const result = await sessionSetDefaultsLogic(
+        { simulatorId: 'RESOLVED-SIM-UUID' },
+        createContext(),
+      );
+
+      expect(result.content[0].text).not.toContain('Cleared simulatorName');
+    });
+
     it('should not fail when simulatorName cannot be resolved immediately', async () => {
       const contextWithFailingExecutor = {
         executor: vi.fn().mockImplementation(async (command: string[]) => {

src/mcp/tools/session-management/session_set_defaults.ts

@@ -75,33 +75,43 @@ export async function sessionSetDefaultsLogic(
   }
 
   const selectorProvided = hasSimulatorId || hasSimulatorName;
+  const simulatorIdChanged = hasSimulatorId && nextParams.simulatorId !== current.simulatorId;
+  const simulatorNameChanged =
+    hasSimulatorName && nextParams.simulatorName !== current.simulatorName;
+
   if (hasSimulatorId && hasSimulatorName) {
     // Both provided - keep both, simulatorId takes precedence for tools
     notices.push(
       'Both simulatorId and simulatorName were provided; simulatorId will be used by tools.',
     );
   } else if (hasSimulatorId && !hasSimulatorName) {
     toClear.add('simulatorName');
-    notices.push(
-      'Cleared simulatorName because simulatorId changed; background resolution will repopulate it.',
-    );
-    notices.push(
-      `Set simulatorId to "${nextParams.simulatorId}". Simulator name and platform refresh scheduled in background.`,
-    );
+    if (current.simulatorName !== undefined) {
+      notices.push(
+        'Cleared simulatorName because simulatorId was set; background resolution will repopulate it.',
+      );
+    }
+    if (simulatorIdChanged) {
+      notices.push(
+        `Set simulatorId to "${nextParams.simulatorId}". Simulator name and platform refresh scheduled in background.`,
+      );
+    }
   } else if (hasSimulatorName && !hasSimulatorId) {
     toClear.add('simulatorId');
-    notices.push(
-      'Cleared simulatorId because simulatorName changed; background resolution will repopulate it.',
-    );
-    notices.push(
-      `Set simulatorName to "${nextParams.simulatorName}". Simulator ID and platform refresh scheduled in background.`,
-    );
+    if (current.simulatorId !== undefined) {
+      notices.push(
+        'Cleared simulatorId because simulatorName was set; background resolution will repopulate it.',
+      );
+    }
+    if (simulatorNameChanged) {
+      notices.push(
+        `Set simulatorName to "${nextParams.simulatorName}". Simulator ID and platform refresh scheduled in background.`,
+      );
+    }
   }
 
   if (selectorProvided) {
-    const selectorChanged =
-      (hasSimulatorId && nextParams.simulatorId !== current.simulatorId) ||
-      (hasSimulatorName && nextParams.simulatorName !== current.simulatorName);
+    const selectorChanged = simulatorIdChanged || simulatorNameChanged;
     if (selectorChanged) {
       toClear.add('simulatorPlatform');
       notices.push('Cleared simulatorPlatform because simulator selector changed.');

src/mcp/tools/simulator/build_run_sim.ts

@@ -468,7 +468,7 @@ export async function build_run_simLogic(
     }
 
     // --- Success ---
-    log('info', `✅ ${platformName} simulator build & run succeeded.`);
+    log('info', `${platformName} simulator build & run succeeded.`);
 
     const target = params.simulatorId
       ? `simulator UUID '${params.simulatorId}'`
@@ -480,7 +480,7 @@ export async function build_run_simLogic(
       content: [
         {
           type: 'text',
-          text: `✅ ${platformName} simulator build and run succeeded for scheme ${params.scheme} from ${sourceType} ${sourcePath} targeting ${target}.\n\nThe app (${bundleId}) is now running in the ${platformName} Simulator.\nIf you don't see the simulator window, it may be hidden behind other windows. The Simulator app should be open.`,
+          text: `${platformName} simulator build and run succeeded for scheme ${params.scheme} from ${sourceType} ${sourcePath} targeting ${target}.\n\nThe app (${bundleId}) is now running in the ${platformName} Simulator.\nIf you don't see the simulator window, it may be hidden behind other windows. The Simulator app should be open.`,
         },
       ],
       nextSteps: [

src/runtime/bootstrap-runtime.ts

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

src/utils/__tests__/infer-platform.test.ts

@@ -195,6 +195,45 @@ describe('inferPlatform', () => {
     ]);
   });
 
+  it('prefers workspace defaults when both projectPath and workspacePath are present in session defaults', async () => {
+    sessionStore.setDefaults({
+      projectPath: '/tmp/Test.xcodeproj',
+      workspacePath: '/tmp/Test.xcworkspace',
+      scheme: 'WatchScheme',
+    });
+
+    const callHistory: string[][] = [];
+    const mockExecutor: CommandExecutor = async (command) => {
+      callHistory.push(command);
+
+      if (command[0] === 'xcrun') {
+        return createMockCommandResponse({
+          success: true,
+          output: JSON.stringify({ devices: {} }),
+        });
+      }
+
+      return createMockCommandResponse({
+        success: true,
+        output: 'SDKROOT = watchsimulator',
+      });
+    };
+
+    const result = await inferPlatform({ simulatorId: 'SIM-UUID' }, mockExecutor);
+
+    expect(result.platform).toBe(XcodePlatform.watchOSSimulator);
+    expect(result.source).toBe('build-settings');
+    expect(callHistory).toHaveLength(2);
+    expect(callHistory[1]).toEqual([
+      'xcodebuild',
+      '-showBuildSettings',
+      '-scheme',
+      'WatchScheme',
+      '-workspace',
+      '/tmp/Test.xcworkspace',
+    ]);
+  });
+
   it('defaults to iOS when simulator and build-settings inference both fail', async () => {
     const mockExecutor: CommandExecutor = async (command) => {
       if (command[0] === 'xcrun') {

src/utils/infer-platform.ts

@@ -87,7 +87,7 @@ function isSimulatorPlatform(value: unknown): value is SimulatorPlatform {
   return SIMULATOR_PLATFORMS.includes(value as SimulatorPlatform);
 }
 
-export function inferSimulatorSelectorForTool(params: {
+function inferSimulatorSelectorForTool(params: {
   simulatorId?: string;
   simulatorName?: string;
   sessionDefaults?: Partial<SessionDefaults>;
@@ -155,11 +155,21 @@ function resolveProjectFromSession(params: InferPlatformParams): {
   scheme?: string;
 } {
   const defaults = params.sessionDefaults ?? sessionStore.getAll();
+  const hasExplicitProjectPath = params.projectPath !== undefined;
+  const hasExplicitWorkspacePath = params.workspacePath !== undefined;
   const projectPath =
     params.projectPath ?? (params.workspacePath ? undefined : defaults.projectPath);
   const workspacePath =
     params.workspacePath ?? (params.projectPath ? undefined : defaults.workspacePath);
 
+  if (projectPath && workspacePath && !hasExplicitProjectPath && !hasExplicitWorkspacePath) {
+    return {
+      projectPath: undefined,
+      workspacePath,
+      scheme: params.scheme ?? defaults.scheme,
+    };
+  }
+
   return {
     projectPath,
     workspacePath,

src/utils/simulator-defaults-refresh.ts

@@ -23,19 +23,21 @@ function shouldSkipBackgroundRefresh(): boolean {
 
 export function scheduleSimulatorDefaultsRefresh(
   options: ScheduleSimulatorDefaultsRefreshOptions,
-): void {
+): boolean {
   const hasSelector = options.simulatorId != null || options.simulatorName != null;
   if (!hasSelector) {
-    return;
+    return false;
   }
 
   if (shouldSkipBackgroundRefresh()) {
-    return;
+    return false;
   }
 
   setTimeout(() => {
     void refreshSimulatorDefaults(options);
   }, 0);
+
+  return true;
 }
 
 async function refreshSimulatorDefaults(