stagent 0.1.7 → 0.1.10

package/src/lib/agents/runtime/claude-sdk.ts

@@ -1,12 +1,26 @@
 /**
  * Build the environment for the Claude Agent SDK subprocess.
- * Returns undefined when no changes are needed.
+ *
+ * Always strips CLAUDECODE (prevents nested-session issues) and
+ * ANTHROPIC_API_KEY (prevents SDK from using API-key auth when
+ * OAuth mode is intended).
+ *
+ * - API-key mode: authEnv is provided → key gets merged back in via spread.
+ * - OAuth mode:   authEnv is undefined → key stays stripped, SDK falls
+ *   through to cached OAuth tokens from `claude login`.
  */
 export function buildClaudeSdkEnv(
   authEnv?: Record<string, string>
-): Record<string, string> | undefined {
-  const isNested = "CLAUDECODE" in process.env;
-  if (!authEnv && !isNested) return undefined;
-  const { CLAUDECODE, ...cleanEnv } = process.env as Record<string, string>;
-  return { ...cleanEnv, ...authEnv };
+): Record<string, string> {
+  const { CLAUDECODE, ANTHROPIC_API_KEY, ...cleanEnv } =
+    process.env as Record<string, string>;
+
+  if (authEnv) {
+    // API key mode — merge the provided key into clean env
+    return { ...cleanEnv, ...authEnv };
+  }
+
+  // OAuth mode — return env WITHOUT ANTHROPIC_API_KEY
+  // so the SDK subprocess uses cached OAuth tokens from Claude CLI
+  return cleanEnv;
 }

package/src/lib/agents/runtime/claude.ts

@@ -4,7 +4,7 @@ import { tasks } from "@/lib/db/schema";
 import { eq } from "drizzle-orm";
 import { updateAuthStatus, getAuthEnv } from "@/lib/settings/auth";
 import { getExecution, removeExecution } from "@/lib/agents/execution-manager";
-import { getProfile } from "@/lib/agents/profiles/registry";
+import { getProfile, listProfiles } from "@/lib/agents/profiles/registry";
 import { resolveProfileRuntimePayload } from "@/lib/agents/profiles/compatibility";
 import { executeClaudeTask, resumeClaudeTask } from "@/lib/agents/claude-agent";
 import { getRuntimeCapabilities, getRuntimeCatalogEntry } from "./catalog";
@@ -23,13 +23,41 @@ import {
   type UsageSnapshot,
 } from "@/lib/usage/ledger";
 
-const TASK_ASSIST_SYSTEM_PROMPT = `You are an AI task definition assistant. Analyze the given task and return ONLY a JSON object (no markdown, no code fences) with:
+function buildTaskAssistSystemPrompt(profileIds: string[]): string {
+  const profileList = profileIds.length > 0
+    ? `Available agent profiles: ${profileIds.join(", ")}\nUse "auto" if unsure which profile fits a step.`
+    : `No explicit profiles available. Use "auto" for suggestedProfile.`;
+
+  return `You are an AI task definition assistant. Analyze the given task and return ONLY a JSON object (no markdown, no code fences) with:
 - "improvedDescription": A clearer version of the task for an AI agent to execute
-- "breakdown": Array of {title, description} sub-tasks if complex (empty array if simple)
-- "recommendedPattern": "single", "sequence", "planner-executor", or "checkpoint"
+- "breakdown": Array of step objects if complex (empty array if simple). Each step: {title, description, suggestedProfile?, requiresApproval?, dependsOn?}
+  - "suggestedProfile": one of the available profile IDs or "auto"
+  - "requiresApproval": true if the step involves irreversible actions needing human review
+  - "dependsOn": array of step indices (0-based) this step depends on (for parallel/swarm patterns)
+- "recommendedPattern": one of "single", "sequence", "planner-executor", "checkpoint", "parallel", "loop", "swarm"
+  - "sequence": steps run one after another in order
+  - "planner-executor": first step plans, remaining steps execute the plan
+  - "checkpoint": like sequence but certain steps pause for human approval
+  - "parallel": independent steps run concurrently, a final synthesis step merges results (use dependsOn to mark the synthesis step)
+  - "loop": a single step repeats iteratively until a goal is met (include suggestedLoopConfig)
+  - "swarm": first step is the mayor (coordinator), middle steps are workers (run in parallel), last step is the refinery (merges results)
 - "complexity": "simple", "moderate", or "complex"
 - "needsCheckpoint": true if irreversible actions or needs human review
-- "reasoning": Brief explanation`;
+- "reasoning": Brief explanation of why you chose this pattern
+- "suggestedLoopConfig": {maxIterations, timeBudgetMs?} — only for loop pattern
+- "suggestedSwarmConfig": {workerConcurrencyLimit?} — only for swarm pattern
+
+${profileList}
+
+Pattern selection guide:
+- Use "single" for simple, atomic tasks
+- Use "sequence" for ordered multi-step work where each step builds on the previous
+- Use "planner-executor" when the task needs analysis before action
+- Use "checkpoint" when steps involve deployments, deletions, or other irreversible actions
+- Use "parallel" when sub-tasks are independent and can run concurrently (research, analysis)
+- Use "loop" for iterative refinement (code review cycles, optimization passes)
+- Use "swarm" for complex tasks needing multiple specialized agents coordinated by a lead`;
+}
 
 async function collectResultText(
   response: AsyncIterable<Record<string, unknown>>
@@ -39,11 +67,20 @@ async function collectResultText(
 
   for await (const raw of response) {
     usage = mergeUsageSnapshot(usage, extractUsageSnapshot(raw));
-    if (raw.type === "result" && "result" in raw) {
-      resultText =
-        typeof raw.result === "string"
-          ? raw.result
-          : JSON.stringify(raw.result);
+
+    if (raw.type === "content_block_delta") {
+      const delta = raw.delta as Record<string, unknown> | undefined;
+      if (delta?.type === "text_delta" && typeof delta.text === "string") {
+        resultText += delta.text;
+      }
+    } else if (raw.type === "result" && "result" in raw) {
+      if (raw.is_error) {
+        throw new Error(typeof raw.result === "string" ? raw.result : "Agent SDK returned an error");
+      }
+      const result = raw.result;
+      if (typeof result === "string" && result.length > 0) {
+        resultText = result;
+      }
       break;
     }
   }
@@ -226,16 +263,25 @@ async function runClaudeTaskAssist(
     .join("\n");
 
   const authEnv = await getAuthEnv();
-  const prompt = `${TASK_ASSIST_SYSTEM_PROMPT}\n\n${userMessage}`;
+  const profileIds = listProfiles().map((p) => p.id);
+  const systemPrompt = buildTaskAssistSystemPrompt(profileIds);
+  const prompt = `${systemPrompt}\n\n${userMessage}`;
   const startedAt = new Date();
   let usage: UsageSnapshot = {};
 
+  const abortController = new AbortController();
+  const timeout = setTimeout(() => abortController.abort(), 30_000);
+
   try {
     const response = query({
       prompt,
       options: {
+        abortController,
+        includePartialMessages: true,
         cwd: process.cwd(),
         env: buildClaudeSdkEnv(authEnv),
+        allowedTools: [],   // No tool use — pure text completion
+        maxTurns: 1,        // Single turn only — no agentic loop
       },
     });
 
@@ -283,6 +329,8 @@ async function runClaudeTaskAssist(
       finishedAt: new Date(),
     });
     throw error;
+  } finally {
+    clearTimeout(timeout);
   }
 }
 

package/src/lib/agents/runtime/openai-codex.ts

@@ -643,7 +643,13 @@ async function runAssistTurn({
       ephemeral: true,
     })) as { thread: { id: string } };
 
+    const ASSIST_TIMEOUT_MS = 60_000;
+
     const completion = new Promise<void>((resolve, reject) => {
+      client!.onProcessError = (error: Error) => {
+        reject(new Error(`Codex process died: ${error.message}`));
+      };
+
       client!.onNotification = (notification: JsonRpcLikeNotification) => {
         const params = asRecord(notification.params) ?? {};
         applyUsageSnapshot(usage, params);
@@ -669,6 +675,13 @@ async function runAssistTurn({
       };
     });
 
+    const timeout = new Promise<never>((_, reject) => {
+      setTimeout(
+        () => reject(new Error("Codex task assist timed out after 60s")),
+        ASSIST_TIMEOUT_MS
+      );
+    });
+
     await client.request("turn/start", {
       threadId: threadResponse.thread.id,
       input: buildTurnInput(prompt),
@@ -676,7 +689,7 @@ async function runAssistTurn({
       outputSchema: TASK_ASSIST_OUTPUT_SCHEMA,
     });
 
-    await completion;
+    await Promise.race([completion, timeout]);
 
     return { text: text.trim(), usage };
   } finally {

package/src/lib/agents/runtime/task-assist-types.ts

@@ -1,8 +1,18 @@
+export interface TaskAssistBreakdownStep {
+  title: string;
+  description: string;
+  suggestedProfile?: string;
+  requiresApproval?: boolean;
+  dependsOn?: number[];
+}
+
 export interface TaskAssistResponse {
   improvedDescription: string;
-  breakdown: { title: string; description: string }[];
-  recommendedPattern: "single" | "sequence" | "planner-executor" | "checkpoint";
+  breakdown: TaskAssistBreakdownStep[];
+  recommendedPattern: "single" | "sequence" | "planner-executor" | "checkpoint" | "parallel" | "loop" | "swarm";
   complexity: "simple" | "moderate" | "complex";
   needsCheckpoint: boolean;
   reasoning: string;
+  suggestedLoopConfig?: { maxIterations: number; timeBudgetMs?: number };
+  suggestedSwarmConfig?: { workerConcurrencyLimit?: number };
 }

package/src/lib/data/__tests__/clear.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import { readFileSync } from "fs";
+import { join } from "path";
+import * as schema from "@/lib/db/schema";
+
+/**
+ * Safety-net test: every table exported from schema.ts must appear in clear.ts
+ * (except `settings`, which is intentionally preserved across clears).
+ *
+ * When you add a new table to schema.ts, this test will fail until you add a
+ * corresponding db.delete() call to clear.ts in the correct FK-safe order.
+ */
+describe("clearAllData coverage", () => {
+  const INTENTIONALLY_PRESERVED = ["settings"];
+
+  it("deletes every schema table (except settings)", () => {
+    const clearSource = readFileSync(
+      join(__dirname, "..", "clear.ts"),
+      "utf-8"
+    );
+
+    // Collect all sqliteTable exports from schema
+    const tableExports = Object.entries(schema)
+      .filter(
+        ([, value]) =>
+          value != null &&
+          typeof value === "object" &&
+          "getSQL" in (value as Record<string, unknown>)
+      )
+      .map(([name]) => name);
+
+    expect(tableExports.length).toBeGreaterThan(0);
+
+    const missing = tableExports.filter(
+      (name) =>
+        !INTENTIONALLY_PRESERVED.includes(name) &&
+        !clearSource.includes(`db.delete(${name})`)
+    );
+
+    expect(missing, `Tables missing from clear.ts: ${missing.join(", ")}`).toEqual([]);
+  });
+});

package/src/lib/data/clear.ts

@@ -3,6 +3,7 @@ import {
   agentLogs,
   notifications,
   documents,
+  learnedContext,
   tasks,
   workflows,
   schedules,
@@ -31,6 +32,7 @@ export function clearAllData() {
   const logsDeleted = db.delete(agentLogs).run().changes;
   const notificationsDeleted = db.delete(notifications).run().changes;
   const documentsDeleted = db.delete(documents).run().changes;
+  const learnedContextDeleted = db.delete(learnedContext).run().changes;
   const tasksDeleted = db.delete(tasks).run().changes;
   const workflowsDeleted = db.delete(workflows).run().changes;
   const schedulesDeleted = db.delete(schedules).run().changes;
@@ -58,6 +60,7 @@ export function clearAllData() {
     agentLogs: logsDeleted,
     notifications: notificationsDeleted,
     documents: documentsDeleted,
+    learnedContext: learnedContextDeleted,
     files: filesDeleted,
   };
 }

package/src/lib/db/bootstrap.ts

@@ -193,44 +193,29 @@ export function bootstrapStagentDatabase(sqlite: Database.Database): void {
     CREATE INDEX IF NOT EXISTS idx_learned_context_change_type ON learned_context(change_type);
   `);
 
-  try {
-    sqlite.exec(`ALTER TABLE tasks ADD COLUMN agent_profile TEXT;`);
-  } catch {
-    // Column already exists.
-  }
+  const addColumnIfMissing = (ddl: string) => {
+    try {
+      sqlite.exec(ddl);
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (!msg.includes("duplicate column")) {
+        console.error("[bootstrap] ALTER TABLE failed:", msg);
+      }
+    }
+  };
+
+  addColumnIfMissing(`ALTER TABLE tasks ADD COLUMN agent_profile TEXT;`);
   sqlite.exec(`CREATE INDEX IF NOT EXISTS idx_tasks_agent_profile ON tasks(agent_profile);`);
 
-  try {
-    sqlite.exec(`ALTER TABLE tasks ADD COLUMN workflow_id TEXT REFERENCES workflows(id);`);
-  } catch {
-    // Column already exists.
-  }
+  addColumnIfMissing(`ALTER TABLE tasks ADD COLUMN workflow_id TEXT REFERENCES workflows(id);`);
   sqlite.exec(`CREATE INDEX IF NOT EXISTS idx_tasks_workflow_id ON tasks(workflow_id);`);
 
-  try {
-    sqlite.exec(`ALTER TABLE tasks ADD COLUMN schedule_id TEXT REFERENCES schedules(id);`);
-  } catch {
-    // Column already exists.
-  }
+  addColumnIfMissing(`ALTER TABLE tasks ADD COLUMN schedule_id TEXT REFERENCES schedules(id);`);
   sqlite.exec(`CREATE INDEX IF NOT EXISTS idx_tasks_schedule_id ON tasks(schedule_id);`);
 
-  try {
-    sqlite.exec(`ALTER TABLE projects ADD COLUMN working_directory TEXT;`);
-  } catch {
-    // Column already exists.
-  }
-
-  try {
-    sqlite.exec(`ALTER TABLE schedules ADD COLUMN assigned_agent TEXT;`);
-  } catch {
-    // Column already exists.
-  }
-
-  try {
-    sqlite.exec(`ALTER TABLE documents ADD COLUMN version INTEGER NOT NULL DEFAULT 1;`);
-  } catch {
-    // Column already exists.
-  }
+  addColumnIfMissing(`ALTER TABLE projects ADD COLUMN working_directory TEXT;`);
+  addColumnIfMissing(`ALTER TABLE schedules ADD COLUMN assigned_agent TEXT;`);
+  addColumnIfMissing(`ALTER TABLE documents ADD COLUMN version INTEGER NOT NULL DEFAULT 1;`);
 }
 
 export function hasLegacyStagentTables(sqlite: Database.Database): boolean {

package/src/lib/documents/cleanup.ts

@@ -42,8 +42,9 @@ export async function cleanupOrphanedUploads(): Promise<{
         errors.push(`${filename}: ${err instanceof Error ? err.message : "unknown error"}`);
       }
     }
-  } catch {
-    // Upload directory may not exist yet
+  } catch (err) {
+    // Upload directory may not exist yet — log for visibility
+    console.error("[cleanup] Failed to read upload directory:", err);
   }
 
   return { deleted, errors };

package/src/lib/notifications/permissions.ts

@@ -23,7 +23,8 @@ export function parseNotificationToolInput(
     return parsed && typeof parsed === "object"
       ? (parsed as PermissionToolInput)
       : null;
-  } catch {
+  } catch (err) {
+    console.error("[permissions] Failed to parse notification tool input:", err);
     return null;
   }
 }
@@ -148,6 +149,11 @@ export function getPermissionDetailEntries(
 export function getPermissionResponseLabel(response: string | null): string | null {
   if (!response) return null;
 
+  // Handle legacy plain-string responses (pre-JSON format)
+  const legacy = response.toLowerCase();
+  if (legacy === "approved" || legacy === "allowed") return "Allowed";
+  if (legacy === "denied" || legacy === "rejected") return "Denied";
+
   try {
     const parsed = JSON.parse(response) as {
       behavior?: "allow" | "deny";

package/src/lib/workflows/__tests__/assist-builder.test.ts

@@ -0,0 +1,255 @@
+import { describe, it, expect } from "vitest";
+import { buildWorkflowDefinitionFromAssist } from "../assist-builder";
+import type { TaskAssistResponse } from "@/lib/agents/runtime/task-assist-types";
+
+const MAIN_TASK = {
+  title: "Build Auth System",
+  description: "Implement authentication with OAuth2",
+  agentProfile: "general",
+};
+
+function makeAssistResponse(
+  overrides: Partial<TaskAssistResponse> = {}
+): TaskAssistResponse {
+  return {
+    improvedDescription: "Build a complete auth system",
+    breakdown: [
+      { title: "Set up middleware", description: "Create auth middleware" },
+      { title: "Create endpoints", description: "Build user API endpoints" },
+      { title: "Write tests", description: "Integration tests for auth" },
+    ],
+    recommendedPattern: "sequence",
+    complexity: "complex",
+    needsCheckpoint: false,
+    reasoning: "Multi-step ordered work",
+    ...overrides,
+  };
+}
+
+describe("buildWorkflowDefinitionFromAssist", () => {
+  describe("sequence pattern", () => {
+    it("creates a sequence workflow with main task as step 1", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse(),
+      });
+
+      expect(result.pattern).toBe("sequence");
+      expect(result.steps).toHaveLength(4); // main + 3 breakdown
+      expect(result.steps[0].name).toBe("Build Auth System");
+      expect(result.steps[1].name).toBe("Set up middleware");
+      expect(result.steps[3].name).toBe("Write tests");
+    });
+
+    it("assigns profiles from main task and suggestions", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({
+          breakdown: [
+            { title: "Research", description: "Research patterns", suggestedProfile: "researcher" },
+            { title: "Code", description: "Write code" },
+          ],
+        }),
+      });
+
+      expect(result.steps[0].agentProfile).toBe("general"); // from mainTask
+      expect(result.steps[1].agentProfile).toBe("researcher"); // from suggestion
+      expect(result.steps[2].agentProfile).toBeUndefined(); // no suggestion = undefined
+    });
+  });
+
+  describe("checkpoint pattern", () => {
+    it("preserves requiresApproval on steps", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({
+          recommendedPattern: "checkpoint",
+          breakdown: [
+            { title: "Plan", description: "Plan deployment", requiresApproval: true },
+            { title: "Deploy", description: "Execute deployment" },
+          ],
+        }),
+      });
+
+      expect(result.pattern).toBe("checkpoint");
+      expect(result.steps[1].requiresApproval).toBe(true);
+      expect(result.steps[2].requiresApproval).toBeUndefined();
+    });
+  });
+
+  describe("parallel pattern", () => {
+    it("auto-generates synthesis step when none provided", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({
+          recommendedPattern: "parallel",
+          breakdown: [
+            { title: "Branch A", description: "Research area A" },
+            { title: "Branch B", description: "Research area B" },
+          ],
+        }),
+      });
+
+      expect(result.pattern).toBe("parallel");
+      // main + 2 branches + auto-synthesis = 4
+      expect(result.steps).toHaveLength(4);
+      expect(result.steps[3].name).toBe("Synthesize results");
+      expect(result.steps[3].dependsOn).toEqual(["step_1", "step_2", "step_3"]);
+    });
+
+    it("preserves explicit synthesis step with dependsOn", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({
+          recommendedPattern: "parallel",
+          breakdown: [
+            { title: "Branch A", description: "Research A" },
+            { title: "Merge", description: "Merge results", dependsOn: [0, 1] },
+          ],
+        }),
+      });
+
+      // main + Branch A + Merge = 3 (no auto-synthesis because dependsOn exists)
+      expect(result.steps).toHaveLength(3);
+      expect(result.steps[2].dependsOn).toEqual(["step_1", "step_2"]);
+    });
+  });
+
+  describe("loop pattern", () => {
+    it("creates single-step loop with config", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({
+          recommendedPattern: "loop",
+          suggestedLoopConfig: { maxIterations: 3, timeBudgetMs: 60000 },
+        }),
+      });
+
+      expect(result.pattern).toBe("loop");
+      expect(result.steps).toHaveLength(1);
+      expect(result.loopConfig?.maxIterations).toBe(3);
+      expect(result.loopConfig?.timeBudgetMs).toBe(60000);
+    });
+
+    it("defaults to 5 iterations", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({ recommendedPattern: "loop" }),
+      });
+
+      expect(result.loopConfig?.maxIterations).toBe(5);
+    });
+
+    it("applies loop config overrides", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({
+          recommendedPattern: "loop",
+          suggestedLoopConfig: { maxIterations: 3 },
+        }),
+        overrides: { loopConfig: { maxIterations: 10 } },
+      });
+
+      expect(result.loopConfig?.maxIterations).toBe(10);
+    });
+  });
+
+  describe("swarm pattern", () => {
+    it("creates mayor/workers/refinery structure", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({
+          recommendedPattern: "swarm",
+          breakdown: [
+            { title: "Worker 1", description: "Task 1" },
+            { title: "Worker 2", description: "Task 2" },
+          ],
+        }),
+      });
+
+      expect(result.pattern).toBe("swarm");
+      // mayor + 2 workers + refinery = 4
+      expect(result.steps).toHaveLength(4);
+      expect(result.steps[0].name).toBe("Build Auth System"); // mayor
+      expect(result.steps[3].name).toBe("Refine and merge results"); // refinery
+      expect(result.swarmConfig?.workerConcurrencyLimit).toBe(2);
+    });
+
+    it("applies swarm config overrides", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({
+          recommendedPattern: "swarm",
+          breakdown: [
+            { title: "W1", description: "T1" },
+            { title: "W2", description: "T2" },
+          ],
+          suggestedSwarmConfig: { workerConcurrencyLimit: 1 },
+        }),
+        overrides: { swarmConfig: { workerConcurrencyLimit: 2 } },
+      });
+
+      expect(result.swarmConfig?.workerConcurrencyLimit).toBe(2);
+    });
+  });
+
+  describe("pattern override", () => {
+    it("overrides AI-recommended pattern", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({ recommendedPattern: "sequence" }),
+        overrides: { pattern: "checkpoint" },
+      });
+
+      expect(result.pattern).toBe("checkpoint");
+    });
+  });
+
+  describe("step overrides", () => {
+    it("applies partial step overrides", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse(),
+        overrides: {
+          steps: [
+            undefined,
+            { agentProfile: "code-reviewer" },
+          ] as Partial<import("../types").WorkflowStep>[],
+        },
+      });
+
+      expect(result.steps[1].agentProfile).toBe("code-reviewer");
+    });
+  });
+
+  describe("validation", () => {
+    it("throws on invalid definition", () => {
+      expect(() =>
+        buildWorkflowDefinitionFromAssist({
+          mainTask: MAIN_TASK,
+          assistResponse: makeAssistResponse({
+            recommendedPattern: "loop",
+            // Missing loopConfig
+          }),
+          overrides: { loopConfig: { maxIterations: 0 } },
+        })
+      ).toThrow("Invalid workflow definition");
+    });
+  });
+
+  describe("auto profile handling", () => {
+    it('treats "auto" suggestedProfile as undefined', () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: { ...MAIN_TASK, agentProfile: undefined },
+        assistResponse: makeAssistResponse({
+          breakdown: [
+            { title: "Step", description: "Do thing", suggestedProfile: "auto" },
+          ],
+        }),
+      });
+
+      expect(result.steps[0].agentProfile).toBeUndefined();
+      expect(result.steps[1].agentProfile).toBeUndefined();
+    });
+  });
+});