fix(roadmap): harden generation startup and artifact parsing

apps/desktop/src/main/__tests__/agent-queue.test.ts

@@ -0,0 +1,85 @@
+import { EventEmitter } from 'node:events';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const {
+  runRoadmapGenerationMock,
+  writeFileWithRetryMock,
+} = vi.hoisted(() => ({
+  runRoadmapGenerationMock: vi.fn(),
+  writeFileWithRetryMock: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock('../ai/runners/roadmap', () => ({
+  runRoadmapGeneration: runRoadmapGenerationMock,
+}));
+
+vi.mock('../utils/atomic-file', () => ({
+  writeFileWithRetry: writeFileWithRetryMock,
+}));
+
+vi.mock('../utils/debounce', () => ({
+  debounce: (fn: (...args: unknown[]) => unknown) => ({
+    fn,
+    cancel: vi.fn(),
+  }),
+}));
+
+import { AgentQueueManager } from '../agent/agent-queue';
+import { AgentState } from '../agent/agent-state';
+
+describe('AgentQueueManager roadmap progress mapping', () => {
+  let projectPath: string;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    projectPath = mkdtempSync(join(tmpdir(), 'agent-queue-'));
+  });
+
+  afterEach(() => {
+    rmSync(projectPath, { recursive: true, force: true });
+  });
+
+  it('maps runner phase names to frontend roadmap phases', async () => {
+    runRoadmapGenerationMock.mockImplementation(
+      async (
+        _config: unknown,
+        onStream?: (event: { type: string; phase?: string }) => void,
+      ) => {
+        onStream?.({ type: 'phase-start', phase: 'discovery' });
+        onStream?.({ type: 'phase-start', phase: 'features' });
+
+        return {
+          success: false,
+          phases: [],
+          error: 'boom',
+        };
+      },
+    );
+
+    const emitter = new EventEmitter();
+    const progressUpdates: Array<{ phase: string; progress: number; message: string }> = [];
+    emitter.on('roadmap-progress', (_projectId, status) => {
+      progressUpdates.push(status);
+    });
+
+    const queue = new AgentQueueManager(
+      new AgentState(),
+      {} as never,
+      { killProcess: vi.fn() } as never,
+      emitter,
+    );
+
+    await queue.startRoadmapGeneration('project-1', projectPath);
+
+    expect(progressUpdates.map((status) => status.phase)).toEqual([
+      'analyzing',
+      'discovering',
+      'generating',
+    ]);
+    expect(progressUpdates[1]?.message).toContain('discovery');
+    expect(progressUpdates[2]?.message).toContain('features');
+  });
+});

apps/desktop/src/main/agent/agent-queue.ts

@@ -418,7 +418,14 @@ export class AgentQueueManager {
         (event: RoadmapStreamEvent) => {
           switch (event.type) {
             case 'phase-start': {
-              progressPhase = event.phase;
+              // Map runner phase names to XState machine state names
+              // Runner uses: 'discovery', 'features'
+              // Machine expects: 'discovering', 'generating'
+              const phaseMap: Record<string, string> = {
+                'discovery': 'discovering',
+                'features': 'generating',
+              };
+              progressPhase = phaseMap[event.phase] ?? event.phase;
               progressPercent = Math.min(progressPercent + 20, 90);
               const msg = `Running ${event.phase} phase...`;
               this.emitter.emit('roadmap-log', projectId, msg);

apps/desktop/src/main/ai/auth/resolver.ts

@@ -51,6 +51,17 @@ type SettingsAccessor = (key: string) => string | undefined;
 
 let _getSettingsValue: SettingsAccessor | null = null;
 
+function throwIfAborted(signal?: AbortSignal): void {
+  if (!signal?.aborted) return;
+
+  const reason = signal.reason;
+  if (reason instanceof Error) {
+    throw reason;
+  }
+
+  throw new Error(typeof reason === 'string' ? reason : 'Aborted');
+}
+
 /**
  * Register a settings accessor function.
  * Called once during app initialization to wire up settings access.
@@ -70,6 +81,8 @@ export function registerSettingsAccessor(accessor: SettingsAccessor): void {
  * This is the highest priority stage — checks providerAccounts array.
  */
 async function resolveFromProviderAccount(ctx: AuthResolverContext): Promise<ResolvedAuth | null> {
+  throwIfAborted(ctx.abortSignal);
+
   if (!_getSettingsValue) return null;
 
   // Read providerAccounts from settings
@@ -95,7 +108,7 @@ async function resolveFromProviderAccount(ctx: AuthResolverContext): Promise<Res
     const { app } = await import('electron');
     const tokenFilePath = path.join(app.getPath('userData'), 'codex-auth.json');
     const { ensureValidOAuthToken } = await import('../providers/oauth-fetch');
-    const token = await ensureValidOAuthToken(tokenFilePath, 'openai');
+    const token = await ensureValidOAuthToken(tokenFilePath, 'openai', ctx.abortSignal);
     if (token) {
       return {
         apiKey: 'codex-oauth-placeholder', // Dummy key; real token injected via custom fetch
@@ -145,7 +158,7 @@ async function resolveFromProfileOAuth(ctx: AuthResolverContext): Promise<Resolv
   if (ctx.provider !== 'anthropic') return null;
 
   try {
-    const tokenResult = await ensureValidToken(ctx.configDir);
+    const tokenResult = await ensureValidToken(ctx.configDir, undefined, ctx.abortSignal);
     if (tokenResult.token) {
       const resolved: ResolvedAuth = {
         apiKey: tokenResult.token,
@@ -164,6 +177,7 @@ async function resolveFromProfileOAuth(ctx: AuthResolverContext): Promise<Resolv
       return resolved;
     }
   } catch {
+    throwIfAborted(ctx.abortSignal);
     // Token refresh failed (network, keychain locked, etc.) — fall through
   }
 
@@ -291,6 +305,8 @@ function resolveDefaultCredentials(ctx: AuthResolverContext): ResolvedAuth | nul
  * @returns Resolved auth credentials, or null if no credentials found
  */
 export async function resolveAuth(ctx: AuthResolverContext): Promise<ResolvedAuth | null> {
+  throwIfAborted(ctx.abortSignal);
+
   return (
     (await resolveFromProviderAccount(ctx)) ??
     (await resolveFromProfileOAuth(ctx)) ??
@@ -352,8 +368,11 @@ export async function resolveAuthFromQueue(
     excludeAccountIds?: string[];
     userModelOverrides?: Record<string, Partial<Record<BuiltinProvider, import('../../../shared/constants/models').ProviderModelSpec>>>;
     autoSwitchSettings?: ClaudeAutoSwitchSettings;
+    abortSignal?: AbortSignal;
   }
 ): Promise<QueueResolvedAuth | null> {
+  throwIfAborted(options?.abortSignal);
+
   const excludeSet = new Set(options?.excludeAccountIds ?? []);
   const defaultSettings: ClaudeAutoSwitchSettings = {
     enabled: true,
@@ -367,6 +386,8 @@ export async function resolveAuthFromQueue(
   const settings = options?.autoSwitchSettings ?? defaultSettings;
 
   for (const account of queue) {
+    throwIfAborted(options?.abortSignal);
+
     // Skip excluded accounts
     if (excludeSet.has(account.id)) continue;
 
@@ -411,7 +432,7 @@ export async function resolveAuthFromQueue(
     // is needed here. All OpenAI models are eligible through Codex OAuth.
 
     // Resolve credentials for this account
-    const auth = await resolveCredentialsForAccount(account, supportedProvider);
+    const auth = await resolveCredentialsForAccount(account, supportedProvider, options?.abortSignal);
     if (!auth) continue;
 
     // Success — return the fully resolved auth
@@ -495,7 +516,10 @@ function resolveZaiBaseUrl(account: ProviderAccount): string {
 async function resolveCredentialsForAccount(
   account: ProviderAccount,
   provider: SupportedProvider,
+  abortSignal?: AbortSignal,
 ): Promise<ResolvedAuth | null> {
+  throwIfAborted(abortSignal);
+
   // No-auth providers (e.g., Ollama) — no API key required
   if (NO_AUTH_PROVIDERS.has(provider)) {
     return {
@@ -511,23 +535,26 @@ async function resolveCredentialsForAccount(
       const { app } = await import('electron');
       const tokenFilePath = path.join(app.getPath('userData'), 'codex-auth.json');
       const { ensureValidOAuthToken } = await import('../providers/oauth-fetch');
-      const token = await ensureValidOAuthToken(tokenFilePath, 'openai');
+      const token = await ensureValidOAuthToken(tokenFilePath, 'openai', abortSignal);
       if (token) {
         return {
           apiKey: 'codex-oauth-placeholder',
           source: 'codex-oauth',
           oauthTokenFilePath: tokenFilePath,
         };
       }
-    } catch { /* fall through */ }
+    } catch {
+      throwIfAborted(abortSignal);
+      /* fall through */
+    }
     return null;
   }
 
   // Anthropic OAuth — refresh token via existing claude-profile system
   if (account.authType === 'oauth' && account.provider === 'anthropic') {
     if (account.claudeProfileId) {
       // Delegate to profile OAuth resolution
-      const ctx: AuthResolverContext = { provider, profileId: account.claudeProfileId };
+      const ctx: AuthResolverContext = { provider, profileId: account.claudeProfileId, abortSignal };
       return resolveAuth(ctx);
     }
     return null;

apps/desktop/src/main/ai/auth/types.ts

@@ -59,6 +59,8 @@ export interface AuthResolverContext {
   profileId?: string;
   /** Optional CLAUDE_CONFIG_DIR for profile-specific keychain lookup */
   configDir?: string;
+  /** Abort signal for cancellation during credential resolution */
+  abortSignal?: AbortSignal;
 }
 
 // ============================================

apps/desktop/src/main/ai/client/factory.ts

@@ -84,6 +84,7 @@ export async function createAgentClient(
     thinkingLevel,
     maxSteps = DEFAULT_MAX_STEPS,
     profileId,
+    abortSignal,
     additionalMcpServers,
     queueConfig,
   } = config;
@@ -101,6 +102,7 @@ export async function createAgentClient(
       {
         excludeAccountIds: queueConfig.excludeAccountIds,
         userModelOverrides: queueConfig.userModelOverrides as any,
+        abortSignal,
       }
     );
 
@@ -133,6 +135,7 @@ export async function createAgentClient(
     const auth = await resolveAuth({
       provider: detectedProvider,
       profileId,
+      abortSignal,
     });
 
     model = createProvider({
@@ -216,6 +219,7 @@ export async function createSimpleClient(
     modelShorthand = 'haiku',
     thinkingLevel = 'low',
     profileId,
+    abortSignal,
     maxSteps = DEFAULT_SIMPLE_MAX_STEPS,
     tools = {},
     queueConfig: explicitQueueConfig,
@@ -240,6 +244,7 @@ export async function createSimpleClient(
       {
         excludeAccountIds,
         userModelOverrides: userModelOverrides as any,
+        abortSignal,
       }
     );
 
@@ -271,6 +276,7 @@ export async function createSimpleClient(
     const auth = await resolveAuth({
       provider: detectedProvider,
       profileId,
+      abortSignal,
     });
 
     model = createProvider({

apps/desktop/src/main/ai/client/types.ts

@@ -71,6 +71,8 @@ export interface SimpleClientConfig {
   thinkingLevel?: ThinkingLevel;
   /** Profile ID for credential resolution */
   profileId?: string;
+  /** Abort signal for cancellation during auth/model resolution */
+  abortSignal?: AbortSignal;
   /** Maximum agentic steps (defaults to 1 for single-turn) */
   maxSteps?: number;
   /** Specific tools to include (if any) */

apps/desktop/src/main/ai/providers/oauth-fetch.ts

@@ -105,6 +105,7 @@ async function refreshOAuthToken(
   refreshToken: string,
   providerSpec: OAuthProviderSpec,
   tokenFilePath: string,
+  abortSignal?: AbortSignal,
 ): Promise<string | null> {
   debugLog('Refreshing OAuth token');
 
@@ -118,6 +119,7 @@ async function refreshOAuthToken(
     method: 'POST',
     headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
     body: body.toString(),
+    signal: abortSignal,
   });
 
   debugLog('Token refresh response', { status: response.status, ok: response.ok });
@@ -186,6 +188,7 @@ function detectProvider(provider?: string): OAuthProviderSpec | undefined {
 export async function ensureValidOAuthToken(
   tokenFilePath: string,
   provider?: string,
+  abortSignal?: AbortSignal,
 ): Promise<string | null> {
   debugLog('Ensuring valid OAuth token', { path: tokenFilePath, provider });
 
@@ -212,8 +215,12 @@ export async function ensureValidOAuthToken(
   }
 
   try {
-    return await refreshOAuthToken(stored.refresh_token, providerSpec, tokenFilePath);
+    return await refreshOAuthToken(stored.refresh_token, providerSpec, tokenFilePath, abortSignal);
   } catch (err) {
+    if (abortSignal?.aborted) {
+      throw (abortSignal.reason instanceof Error ? abortSignal.reason : new Error('Aborted'));
+    }
+
     debugLog('Token refresh failed', { error: err instanceof Error ? err.message : String(err) });
     return null;
   }
@@ -238,7 +245,11 @@ export function createOAuthProviderFetch(
 
   return async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
     // 1. Get valid OAuth token (auto-refresh if needed)
-    const token = await ensureValidOAuthToken(tokenFilePath, provider);
+    const token = await ensureValidOAuthToken(
+      tokenFilePath,
+      provider,
+      init?.signal instanceof AbortSignal ? init.signal : undefined,
+    );
     if (!token) {
       throw new Error('OAuth: No valid token available. Please re-authenticate.');
     }