fix(test-common): Finalize xcodebuild pipeline on post-startup exceptions

When the executor throws after startBuildPipeline has been called, the
pipeline response was left in a pending state with no output. Hoist the
started variable above the try block so the catch handler can call
finalizeInlineXcodebuild and produce a proper error response with build
log links.

Author: cameroncooke

src/utils/__tests__/test-common.test.ts

@@ -246,6 +246,45 @@ describe('handleTestLogic (pipeline)', () => {
     expect(renderedText).toContain('Running tests');
   });
 
+  it('finalizes the pipeline when the executor throws after startup', async () => {
+    const executor = async () => {
+      throw new Error('spawn blew up');
+    };
+
+    const { result } = await runToolLogic(() =>
+      handleTestLogic(
+        {
+          projectPath: '/tmp/App.xcodeproj',
+          scheme: 'App',
+          configuration: 'Debug',
+          platform: XcodePlatform.macOS,
+          progress: true,
+        },
+        executor,
+        {
+          preflight: {
+            scheme: 'App',
+            configuration: 'Debug',
+            destinationName: 'iPhone 17 Pro',
+            projectPath: '/tmp/App.xcodeproj',
+            selectors: { onlyTesting: [], skipTesting: [] },
+            targets: [],
+            warnings: [],
+            totalTests: 1,
+            completeness: 'complete',
+          },
+          toolName: 'test_macos',
+        },
+      ),
+    );
+
+    expectPendingTestResponse(result, true);
+
+    const renderedText = finalizeAndGetText(result);
+    expect(renderedText).toContain('spawn blew up');
+    expect(renderedText).toContain('Build Logs:');
+  });
+
   it('returns a pending xcodebuild response when compilation fails before tests start', async () => {
     const executor = async (
       _command: string[],

src/utils/test-common.ts

@@ -27,7 +27,7 @@ import { formatToolPreflight } from './build-preflight.ts';
 import { resolveDeviceName } from './device-name-resolver.ts';
 import { createSimulatorTwoPhaseExecutionPlan } from './simulator-test-execution.ts';
 import { startBuildPipeline } from './xcodebuild-pipeline.ts';
-import type { XcodebuildPipeline } from './xcodebuild-pipeline.ts';
+import type { StartedPipeline, XcodebuildPipeline } from './xcodebuild-pipeline.ts';
 import { finalizeInlineXcodebuild } from './xcodebuild-output.ts';
 import { getHandlerContext } from './typed-tool-factory.ts';
 
@@ -77,6 +77,7 @@ export async function handleTestLogic(
     `Starting test run for scheme ${params.scheme} on platform ${params.platform} (internal)`,
   );
   const ctx = getHandlerContext();
+  let started: StartedPipeline | null = null;
 
   try {
     const execOpts: CommandExecOptions | undefined = params.testRunnerEnv
@@ -118,7 +119,7 @@ export async function handleTestLogic(
         : `${configText}\n${discoveryText}`;
     }
 
-    const started = startBuildPipeline({
+    started = startBuildPipeline({
       operation: 'TEST',
       toolName: resolvedToolName,
       params: {
@@ -242,6 +243,19 @@ export async function handleTestLogic(
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     log('error', `Error during test run: ${errorMessage}`);
+
+    if (started) {
+      finalizeInlineXcodebuild({
+        started,
+        emit: ctx.emit,
+        succeeded: false,
+        durationMs: Date.now() - started.startedAt,
+        responseContent: [{ type: 'text', text: `Error during test run: ${errorMessage}` }],
+        errorFallbackPolicy: 'always',
+      });
+      return;
+    }
+
     ctx.emit(
       header('Test Run', [
         { label: 'Scheme', value: params.scheme },