@whisperr/wizard 0.7.4 → 0.8.0

package/dist/index.js

@@ -5,7 +5,7 @@ import { realpathSync } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/cli.ts
-import { resolve as resolve5 } from "path";
+import { resolve as resolve6 } from "path";
 import * as p2 from "@clack/prompts";
 import open2 from "open";
 
@@ -1308,8 +1308,8 @@ function createProgressSink(options) {
 }
 
 // src/engine/orchestrator.ts
-import { readFile as readFile2 } from "fs/promises";
-import { basename, resolve as resolve2, sep as sep2 } from "path";
+import { readFile as readFile3 } from "fs/promises";
+import { basename, resolve as resolve3, sep as sep3 } from "path";
 
 // src/engine/bindings.ts
 function bindingsTargetFor(target9) {
@@ -1515,11 +1515,14 @@ function eventWrapperName(code) {
 
 // src/engine/clusters.ts
 import { createHash } from "crypto";
-import { dirname } from "path";
-var MIN_CLUSTER_EVENTS = 3;
-var MAX_CLUSTER_EVENTS = 8;
-function clusterIdFor(files) {
-  const digest = createHash("sha256").update([...files].sort().join("\n")).digest("hex");
+var MAX_CLUSTER_EVENTS = 4;
+var MAX_CONCURRENT_CLUSTERS = 4;
+function clusterIdFor(files, eventIds = [], slicePosition = 0) {
+  const digest = createHash("sha256").update(JSON.stringify({
+    files: [...files].sort(),
+    events: [...eventIds].sort(),
+    slicePosition
+  })).digest("hex");
   return `cluster_${digest.slice(0, 12)}`;
 }
 function deriveClusters(placements) {
@@ -1529,46 +1532,58 @@ function deriveClusters(placements) {
     existing.push(placement);
     byFile.set(placement.file, existing);
   }
-  const byDirectory = /* @__PURE__ */ new Map();
-  for (const [file, events] of byFile) {
-    const directory = dirname(file);
-    const bucket = byDirectory.get(directory) ?? { files: /* @__PURE__ */ new Set(), events: [] };
-    bucket.files.add(file);
-    bucket.events.push(...events);
-    byDirectory.set(directory, bucket);
-  }
-  const clusters = [];
-  const pending = [];
-  for (const directory of [...byDirectory.keys()].sort()) {
-    const bucket = byDirectory.get(directory);
-    if (bucket.events.length >= MIN_CLUSTER_EVENTS) {
-      pending.push(bucket);
-      continue;
-    }
-    const last = pending[pending.length - 1];
-    if (last && last.events.length + bucket.events.length <= MAX_CLUSTER_EVENTS) {
-      for (const file of bucket.files) last.files.add(file);
-      last.events.push(...bucket.events);
-    } else {
-      pending.push(bucket);
-    }
-  }
-  for (const bucket of pending) {
-    const events = [...bucket.events].sort((a, b) => a.eventCode.localeCompare(b.eventCode));
+  const fileSlices = [];
+  for (const file of [...byFile.keys()].sort()) {
+    const events = [...byFile.get(file)].sort(
+      (a, b) => a.eventCode.localeCompare(b.eventCode) || a.eventId.localeCompare(b.eventId)
+    );
     for (let start = 0; start < events.length; start += MAX_CLUSTER_EVENTS) {
-      const slice = events.slice(start, start + MAX_CLUSTER_EVENTS);
-      const files = [...new Set(slice.map((event) => event.file))].sort();
-      clusters.push({
-        id: clusterIdFor(files.length > 0 ? files : [`slice_${start}`]),
-        files,
-        events: slice,
-        status: "pending",
-        attempts: 0
+      fileSlices.push({
+        file,
+        position: start / MAX_CLUSTER_EVENTS,
+        events: events.slice(start, start + MAX_CLUSTER_EVENTS)
       });
     }
   }
+  const clusters = [];
+  const positions = /* @__PURE__ */ new Map();
+  for (const slice of fileSlices) {
+    let target9 = clusters.find(
+      (cluster) => !cluster.files.includes(slice.file) && cluster.events.length + slice.events.length <= MAX_CLUSTER_EVENTS
+    );
+    if (!target9) {
+      target9 = { id: "", files: [], events: [], status: "pending", attempts: 0 };
+      clusters.push(target9);
+    }
+    target9.files.push(slice.file);
+    target9.events.push(...slice.events);
+    const existing = positions.get(String(clusters.indexOf(target9))) ?? [];
+    existing.push(slice.position);
+    positions.set(String(clusters.indexOf(target9)), existing);
+  }
+  for (const [index, cluster] of clusters.entries()) {
+    cluster.files.sort();
+    cluster.events.sort((a, b) => a.eventCode.localeCompare(b.eventCode));
+    cluster.id = clusterIdFor(
+      cluster.files,
+      cluster.events.map((event) => event.eventId || event.eventCode),
+      Number((positions.get(String(index)) ?? [0]).join(""))
+    );
+  }
   return clusters;
 }
+function nextConcurrentClusters(clusters, limit = MAX_CONCURRENT_CLUSTERS) {
+  const selected = [];
+  const lockedFiles = /* @__PURE__ */ new Set();
+  for (const cluster of clusters) {
+    if (cluster.status !== "pending" && cluster.status !== "editing") continue;
+    if (cluster.files.some((file) => lockedFiles.has(file))) continue;
+    selected.push(cluster);
+    for (const file of cluster.files) lockedFiles.add(file);
+    if (selected.length === limit) break;
+  }
+  return selected;
+}
 var TERMINAL_STATUSES = ["reviewed", "failed_resumable", "blocked"];
 function nextPendingCluster(clusters) {
   return clusters.find((cluster) => cluster.status === "pending" || cluster.status === "editing");
@@ -1587,8 +1602,8 @@ function transitionCluster(clusters, clusterId, status, note3) {
 }
 
 // src/engine/integrate.ts
-import { writeFile } from "fs/promises";
-import { join as join3 } from "path";
+import { readFile as readFile2, writeFile } from "fs/promises";
+import { join as join3, resolve, sep } from "path";
 
 // src/engine/budgets.ts
 var OVERFLOW_PATTERNS = [
@@ -1600,6 +1615,8 @@ var OVERFLOW_PATTERNS = [
 ];
 var TRANSIENT_PATTERNS = [
   /rate.?limit/i,
+  /quota/i,
+  /\b429\b/,
   /overloaded/i,
   /timeout/i,
   /timed out/i,
@@ -1629,6 +1646,11 @@ function nextClusterStatusAfterFailure(failure, attempts) {
   return "failed_resumable";
 }
 
+// src/engine/types.ts
+function modelConfigFor(models, task, role) {
+  return models[task] ?? models[role];
+}
+
 // src/engine/verify.ts
 import { spawn } from "child_process";
 import { readFileSync } from "fs";
@@ -1673,7 +1695,7 @@ function npmCommand() {
   return process.platform === "win32" ? "npm.cmd" : "npm";
 }
 function runVerifyStep(cwd, step, timeoutMs = 3e5) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const child = spawn(step.command, step.args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
     let output = "";
     const capture = (chunk) => {
@@ -1688,11 +1710,11 @@ function runVerifyStep(cwd, step, timeoutMs = 3e5) {
     }, timeoutMs);
     child.on("error", (error) => {
       clearTimeout(timer);
-      resolve6({ ...step, ok: false, output: String(error) });
+      resolve7({ ...step, ok: false, output: String(error) });
     });
     child.on("close", (exitCode) => {
       clearTimeout(timer);
-      resolve6({ ...step, ok: exitCode === 0, output });
+      resolve7({ ...step, ok: exitCode === 0, output });
     });
   });
 }
@@ -1703,21 +1725,6 @@ async function runVerifySteps(cwd, steps) {
   }
   return results;
 }
-function verifiedStatus(results) {
-  if (results.length === 0) {
-    return "applied";
-  }
-  if (results.some((result) => !result.ok)) {
-    return "applied";
-  }
-  if (results.some((result) => result.kind === "build")) {
-    return "build_verified";
-  }
-  if (results.some((result) => result.kind === "typecheck" || result.kind === "analyze")) {
-    return "type_verified";
-  }
-  return "syntax_verified";
-}
 function runVerificationStatus(results) {
   if (results.length === 0) {
     return "unavailable";
@@ -1748,6 +1755,8 @@ async function runSdkSetupPass(deps, bindings) {
   const outcome = await deps.provider.invoke(
     {
       role: "edit",
+      task: "sdk_setup",
+      sessionKey: "sdk_setup",
       systemPrompt: deps.playbookSystemPrompt,
       userPrompt: [
         "CORE SETUP for the Whisperr SDK in this repository. Do exactly this, then stop:",
@@ -1764,7 +1773,7 @@ async function runSdkSetupPass(deps, bindings) {
       allowRepoWrite: true,
       cwd: deps.worktree.path
     },
-    deps.models.edit,
+    modelConfigFor(deps.models, "sdk_setup", "edit"),
     (action) => deps.sink.emit({ phase: "binding", action })
   );
   return outcome.kind === "completed";
@@ -1798,6 +1807,8 @@ async function reviewCluster(deps, cluster, diff) {
   const outcome = await deps.provider.invoke(
     {
       role: "review",
+      task: "review",
+      sessionKey: `review:${cluster.id}`,
       systemPrompt: [
         "You review an instrumentation diff against a strict checklist. Answer with a verdict line",
         "`VERDICT: pass` or `VERDICT: fail`, then bullet notes for anything wrong."
@@ -1815,7 +1826,7 @@ async function reviewCluster(deps, cluster, diff) {
       allowRepoWrite: false,
       cwd: deps.worktree.path
     },
-    deps.models.review,
+    modelConfigFor(deps.models, "review", "review"),
     (action) => deps.sink.emit({ phase: "reviewing", action })
   );
   if (outcome.kind !== "completed") {
@@ -1828,7 +1839,6 @@ async function runClusterIntegration(deps, initialClusters, clusterDiff) {
   let clusters = initialClusters;
   const eventStatuses = /* @__PURE__ */ new Map();
   const bindings = generateBindings(deps.target, deps.registered);
-  const steps = resolveVerifySteps(deps.worktree.path, deps.target);
   const total = clusters.length;
   for (; ; ) {
     const cluster = nextPendingCluster(clusters);
@@ -1844,22 +1854,47 @@ async function runClusterIntegration(deps, initialClusters, clusterDiff) {
       file: cluster.files[0],
       action: "placing events"
     });
-    const edit = await deps.provider.invoke(
-      {
-        role: "edit",
-        systemPrompt: deps.playbookSystemPrompt,
-        userPrompt: clusterPrompt(cluster, deps.registered, bindings),
-        tools: [],
-        allowRepoWrite: true,
-        cwd: deps.worktree.path
-      },
-      deps.models.edit,
+    const invocation = {
+      role: "edit",
+      task: "cluster_edit",
+      sessionKey: cluster.id,
+      systemPrompt: deps.playbookSystemPrompt,
+      userPrompt: clusterPrompt(cluster, deps.registered, bindings),
+      tools: [],
+      allowRepoWrite: true,
+      cwd: deps.worktree.path
+    };
+    let edit = await deps.provider.invoke(
+      invocation,
+      modelConfigFor(deps.models, "cluster_edit", "edit"),
       (action) => deps.sink.emit({ phase: "integrating", cluster: { index, total }, action })
     );
-    if (edit.kind !== "completed") {
+    let escalated = false;
+    let structural = edit.kind === "completed" ? await structuralClusterCheck(deps.worktree.path, cluster) : { ok: false, notes: `edit ${edit.kind}` };
+    if ((!structural.ok || edit.kind !== "completed") && deps.provider.invokeFallback) {
+      await deps.discardChanges();
+      escalated = true;
+      deps.sink.emit({
+        phase: "integrating",
+        cluster: { index, total },
+        action: "Terra attempt rolled back; retrying with Opus"
+      });
+      edit = await deps.provider.invokeFallback(
+        { ...invocation, task: "repair", sessionKey: `escalation:${cluster.id}` },
+        modelConfigFor(deps.models, "sdk_setup", "edit"),
+        (action) => deps.sink.emit({ phase: "integrating", cluster: { index, total }, action })
+      );
+      structural = edit.kind === "completed" ? await structuralClusterCheck(deps.worktree.path, cluster) : { ok: false, notes: `Opus escalation ${edit.kind}` };
+    }
+    if (edit.kind !== "completed" || !structural.ok) {
       const failure = edit.kind === "context_overflow" ? "context_overflow" : edit.kind === "budget_exhausted" ? "context_overflow" : classifyFailure(edit.kind === "failed" ? edit.error : "");
       const nextStatus = nextClusterStatusAfterFailure(failure, cluster.attempts);
-      clusters = transitionCluster(clusters, cluster.id, nextStatus, `edit ${edit.kind}`);
+      clusters = transitionCluster(
+        clusters,
+        cluster.id,
+        nextStatus,
+        structural.notes || `edit ${edit.kind}`
+      );
       deps.saveClusters(clusters);
       for (const placement of cluster.events) {
         eventStatuses.set(placement.eventCode, "failed");
@@ -1867,38 +1902,42 @@ async function runClusterIntegration(deps, initialClusters, clusterDiff) {
       await deps.discardChanges();
       continue;
     }
-    let statuses = "applied";
-    if (steps.length > 0) {
-      deps.sink.emit({ phase: "verifying", cluster: { index, total }, action: "running verifier" });
-      const results = await runVerifySteps(deps.worktree.path, steps);
-      statuses = verifiedStatus(results);
-      if (results.some((result) => !result.ok) && cluster.attempts < MAX_CLUSTER_ATTEMPTS) {
-        deps.sink.emit({ phase: "verifying", cluster: { index, total }, action: "repairing verification failure" });
-        await deps.provider.invoke(
-          {
-            role: "edit",
-            systemPrompt: deps.playbookSystemPrompt,
-            userPrompt: [
-              "The verification command failed after your edits. Fix ONLY the failure below, then stop.",
-              "",
-              results.map((result) => result.output).join("\n").slice(0, 2e4)
-            ].join("\n"),
-            tools: [],
-            allowRepoWrite: true,
-            cwd: deps.worktree.path
-          },
-          deps.models.edit,
-          (action) => deps.sink.emit({ phase: "verifying", cluster: { index, total }, action })
-        );
-        const retried = await runVerifySteps(deps.worktree.path, steps);
-        statuses = verifiedStatus(retried);
-      }
-    }
     clusters = transitionCluster(clusters, cluster.id, "verified");
     deps.saveClusters(clusters);
     const diff = await clusterDiff(cluster.files);
-    const review = await reviewCluster(deps, cluster, diff);
-    const finalStatus = review.ok ? statuses === "applied" ? "applied" : "reviewed" : statuses;
+    let review = await reviewCluster(deps, cluster, diff);
+    if (!review.ok && !escalated && deps.provider.invokeFallback) {
+      await deps.discardChanges();
+      deps.sink.emit({
+        phase: "reviewing",
+        cluster: { index, total },
+        action: "Terra diff rejected; retrying the clean cluster with Opus"
+      });
+      edit = await deps.provider.invokeFallback(
+        { ...invocation, task: "repair", sessionKey: `review-retry:${cluster.id}` },
+        modelConfigFor(deps.models, "sdk_setup", "edit"),
+        (action) => deps.sink.emit({ phase: "integrating", cluster: { index, total }, action })
+      );
+      structural = edit.kind === "completed" ? await structuralClusterCheck(deps.worktree.path, cluster) : { ok: false, notes: `Opus review retry ${edit.kind}` };
+      if (edit.kind === "completed" && structural.ok) {
+        review = await reviewCluster(deps, cluster, await clusterDiff(cluster.files));
+      }
+    }
+    if (!structural.ok || !review.ok) {
+      clusters = transitionCluster(
+        clusters,
+        cluster.id,
+        "blocked",
+        (!structural.ok ? structural.notes : review.notes).slice(0, 500)
+      );
+      for (const placement of cluster.events) {
+        eventStatuses.set(placement.eventCode, "failed");
+      }
+      await deps.discardChanges();
+      continue;
+    }
+    const statuses = "reviewed";
+    const finalStatus = review.ok ? statuses : statuses;
     clusters = transitionCluster(clusters, cluster.id, "reviewed", review.ok ? void 0 : review.notes.slice(0, 500));
     deps.saveClusters(clusters);
     for (const placement of cluster.events) {
@@ -1911,6 +1950,34 @@ async function runClusterIntegration(deps, initialClusters, clusterDiff) {
   }
   return { clusters, eventStatuses };
 }
+async function structuralClusterCheck(repoPath, cluster) {
+  const allowed = new Set(cluster.files);
+  const missing = [];
+  for (const placement of cluster.events) {
+    if (!allowed.has(placement.file)) {
+      missing.push(`${placement.eventCode}: placement escaped cluster`);
+      continue;
+    }
+    try {
+      const root = resolve(repoPath);
+      const path = resolve(root, placement.file);
+      if (!path.startsWith(root + sep)) {
+        missing.push(`${placement.eventCode}: unsafe file`);
+        continue;
+      }
+      const content = await readFile2(path, "utf8");
+      if (!content.includes(eventWrapperName(placement.eventCode))) {
+        missing.push(`${placement.eventCode}: wrapper call missing from ${placement.file}`);
+      }
+    } catch {
+      missing.push(`${placement.eventCode}: cannot read ${placement.file}`);
+    }
+  }
+  return {
+    ok: missing.length === 0,
+    notes: missing.join("; ")
+  };
+}
 async function finalizeIntegration(deps) {
   const steps = resolveVerifySteps(deps.worktree.path, deps.target);
   deps.sink.emit({ phase: "verifying", action: "final verification pass" });
@@ -1921,6 +1988,33 @@ async function finalizeIntegration(deps) {
     command: verificationCommand(results)
   };
 }
+async function repairVerification(deps, results) {
+  const failed = results.filter((result) => !result.ok);
+  if (failed.length === 0) return true;
+  deps.sink.emit({ phase: "verifying", action: "Opus is repairing final verification failures" });
+  const outcome = await deps.provider.invoke(
+    {
+      role: "edit",
+      task: "repair",
+      sessionKey: "final_repair",
+      systemPrompt: deps.playbookSystemPrompt,
+      userPrompt: [
+        "The one final repository verification failed after all instrumentation patches were merged.",
+        "Repair only the affected integration files and their imports/configuration. Preserve every generated event wrapper call.",
+        "Do not redesign events. Stop after the repair; the wizard will rerun verification.",
+        "",
+        failed.map((result) => `$ ${result.command} ${result.args.join(" ")}
+${result.output}`).join("\n\n").slice(0, 3e4)
+      ].join("\n"),
+      tools: [],
+      allowRepoWrite: true,
+      cwd: deps.worktree.path
+    },
+    modelConfigFor(deps.models, "repair", "edit"),
+    (action) => deps.sink.emit({ phase: "verifying", action })
+  );
+  return outcome.kind === "completed";
+}
 
 // src/engine/runs.ts
 import { createHash as createHash2 } from "crypto";
@@ -2275,6 +2369,8 @@ async function runSurvey(provider, models, repoPath, bootstrap, sink, resumeSess
   const outcome = await provider.invoke(
     {
       role: "survey",
+      task: "survey",
+      sessionKey: "survey",
       systemPrompt: SURVEY_SYSTEM_PROMPT,
       userPrompt: surveyUserPrompt(repoPath, renderOnboardingContext(bootstrap.onboardingContext)),
       tools: [],
@@ -2282,7 +2378,7 @@ async function runSurvey(provider, models, repoPath, bootstrap, sink, resumeSess
       cwd: repoPath,
       resumeSessionId
     },
-    models.survey,
+    modelConfigFor(models, "survey", "survey"),
     (action) => sink.emit({ phase: "surveying", action })
   );
   return { report: outcome.kind === "completed" ? outcome.text : "", outcome };
@@ -2343,6 +2439,37 @@ async function runSelection(provider, models, repoPath, bootstrap, surveyReport,
       return { ok: true, code: validated.event.code };
     }
   };
+  const proposeBatchTool = {
+    name: "propose_event_batch",
+    description: "Propose a batch of important, concretely-anchored product events in one tool call.",
+    inputSchema: {
+      events: z.array(z.object(proposeTool.inputSchema)).min(1).max(200)
+    },
+    jsonSchema: {
+      type: "object",
+      properties: {
+        events: {
+          type: "array",
+          minItems: 1,
+          maxItems: 200,
+          items: proposeTool.jsonSchema
+        }
+      },
+      required: ["events"]
+    },
+    handler: async (input) => {
+      const events = Array.isArray(input.events) ? input.events : [];
+      const results = [];
+      for (const event of events) {
+        results.push(await proposeTool.handler(event ?? {}));
+      }
+      return {
+        ok: results.every((result) => result.ok === true),
+        accepted: results.filter((result) => result.ok === true).length,
+        results
+      };
+    }
+  };
   const finishTool = {
     name: "finish_selection",
     description: "Signal that every important event has been proposed.",
@@ -2362,6 +2489,7 @@ async function runSelection(provider, models, repoPath, bootstrap, surveyReport,
   const outcome = await provider.invoke(
     {
       role: "design",
+      task: "design",
       systemPrompt: SELECTION_SYSTEM_PROMPT,
       userPrompt: selectionUserPrompt(
         surveyReport,
@@ -2369,11 +2497,11 @@ async function runSelection(provider, models, repoPath, bootstrap, surveyReport,
         existingEventCodes,
         rejectedCodes
       ),
-      tools: [proposeTool, finishTool],
+      tools: [proposeBatchTool, proposeTool, finishTool],
       allowRepoWrite: false,
       cwd: repoPath
     },
-    models.design,
+    modelConfigFor(models, "design", "design"),
     (action) => sink.emit({ phase: "designing", action })
   );
   return {
@@ -2428,7 +2556,7 @@ function placementsFor(registered) {
 import { spawn as spawn2 } from "child_process";
 import { cp, lstat, mkdir, mkdtemp, rm, writeFile as writeFile2 } from "fs/promises";
 import { tmpdir } from "os";
-import { dirname as dirname2, join as join4, relative, resolve, sep } from "path";
+import { dirname, join as join4, relative, resolve as resolve2, sep as sep2 } from "path";
 var WorktreeError = class extends Error {
   constructor(code, message) {
     super(message);
@@ -2438,7 +2566,7 @@ var WorktreeError = class extends Error {
   code;
 };
 function git(cwd, args) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const child = spawn2("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
@@ -2448,8 +2576,8 @@ function git(cwd, args) {
     child.stderr.on("data", (chunk) => {
       stderr += String(chunk);
     });
-    child.on("error", () => resolve6({ ok: false, stdout, stderr: "git is not available" }));
-    child.on("close", (exitCode) => resolve6({ ok: exitCode === 0, stdout, stderr }));
+    child.on("error", () => resolve7({ ok: false, stdout, stderr: "git is not available" }));
+    child.on("close", (exitCode) => resolve7({ ok: exitCode === 0, stdout, stderr }));
   });
 }
 async function must(cwd, args) {
@@ -2460,8 +2588,8 @@ async function must(cwd, args) {
   return result.stdout;
 }
 function safeRepoFile(repoPath, file) {
-  const path = resolve(repoPath, file);
-  if (path === repoPath || !path.startsWith(repoPath + sep) || relative(repoPath, path).startsWith("..")) {
+  const path = resolve2(repoPath, file);
+  if (path === repoPath || !path.startsWith(repoPath + sep2) || relative(repoPath, path).startsWith("..")) {
     throw new WorktreeError("git_failed", `unsafe progress file path: ${file}`);
   }
   return path;
@@ -2477,7 +2605,7 @@ async function seedWorktree(repoPath, worktreePath, files) {
     const destination = safeRepoFile(worktreePath, file);
     try {
       await lstat(source);
-      await mkdir(dirname2(destination), { recursive: true });
+      await mkdir(dirname(destination), { recursive: true });
       await cp(source, destination, { recursive: true, force: true });
     } catch {
       await rm(destination, { recursive: true, force: true });
@@ -2527,7 +2655,7 @@ async function applyPatchToRepo(handle, patch) {
   if (patch.trim() === "") {
     return;
   }
-  await new Promise((resolve6, reject) => {
+  await new Promise((resolve7, reject) => {
     const child = spawn2("git", ["apply", "--whitespace=nowarn"], {
       cwd: handle.repoPath,
       stdio: ["pipe", "ignore", "pipe"]
@@ -2539,7 +2667,7 @@ async function applyPatchToRepo(handle, patch) {
     child.on("error", (error) => reject(new WorktreeError("git_failed", String(error))));
     child.on("close", (exitCode) => {
       if (exitCode === 0) {
-        resolve6();
+        resolve7();
       } else {
         reject(new WorktreeError("git_failed", `git apply failed: ${stderr.trim()}`));
       }
@@ -2686,6 +2814,7 @@ async function runEngine(input) {
   const prior = bootstrap.run.integrationEvidence;
   const changedFiles2 = new Set(prior?.changedFiles ?? []);
   const eventStatuses = await reconcileProgress(input.repoPath, registered, prior, input.sink);
+  const eventFailureReasons = /* @__PURE__ */ new Map();
   for (const event of registered) {
     const status = eventStatuses.get(event.code) ?? "planned";
     if (status !== "planned" && status !== "failed" && status !== "unsupported") {
@@ -2758,7 +2887,10 @@ async function runEngine(input) {
         throw new Error("SDK setup did not complete");
       }
       await checkpoint();
-      identifyWired = true;
+      identifyWired = await setupLooksPresent(input.repoPath, changedFiles2);
+      if (!identifyWired) {
+        throw new Error("SDK initialization, bindings, or identify() could not be verified");
+      }
       await saveProgress();
     } else {
       await checkpoint();
@@ -2767,53 +2899,128 @@ async function runEngine(input) {
       const status = eventStatuses.get(event.code) ?? "planned";
       return status === "planned" || status === "failed";
     });
-    const clusters = deriveClusters(placementsFor(pending));
-    const deps = {
-      provider: input.provider,
-      models: input.models,
-      worktree,
-      target: input.target,
-      playbookSystemPrompt: input.playbookSystemPrompt,
-      registered,
-      ingestion: bootstrap.ingestion,
-      sink: input.sink,
-      saveClusters: () => {
-      },
-      discardChanges: async () => discardWorktreeChanges(worktree),
-      onClusterIntegrated: async (cluster, status) => {
-        const verified = /* @__PURE__ */ new Map();
-        for (const placement of cluster.events) {
-          const present = await fileContainsWrapper(
-            worktree.path,
-            placement.file,
-            placement.eventCode
+    let clusters = deriveClusters(placementsFor(pending));
+    await patchPhase("integrating");
+    await removeWorktree(worktree).catch(() => {
+    });
+    while (!clustersComplete(clusters)) {
+      const wave = nextConcurrentClusters(clusters);
+      if (wave.length === 0) {
+        break;
+      }
+      const prepared = [];
+      for (const cluster of wave) {
+        try {
+          prepared.push({
+            cluster,
+            handle: await createWorktree(input.repoPath, input.force ?? false, [...changedFiles2])
+          });
+        } catch (error) {
+          prepared.push({
+            cluster,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+      const completed = await Promise.all(prepared.map(async (worker) => {
+        if (!worker.handle) {
+          return { ...worker, integration: void 0, patch: "" };
+        }
+        const workerDeps = {
+          provider: input.provider,
+          models: input.models,
+          worktree: worker.handle,
+          target: input.target,
+          playbookSystemPrompt: input.playbookSystemPrompt,
+          registered,
+          ingestion: bootstrap.ingestion,
+          sink: input.sink,
+          saveClusters: () => {
+          },
+          discardChanges: async () => discardWorktreeChanges(worker.handle),
+          onClusterIntegrated: async () => {
+          }
+        };
+        try {
+          const integration = await runClusterIntegration(
+            workerDeps,
+            [worker.cluster],
+            async () => worktreePatch(worker.handle)
           );
-          verified.set(placement.eventCode, present ? status : "failed");
+          return {
+            ...worker,
+            integration,
+            patch: await worktreePatch(worker.handle)
+          };
+        } catch (error) {
+          return {
+            ...worker,
+            integration: void 0,
+            patch: "",
+            error: error instanceof Error ? error.message : String(error)
+          };
         }
-        await checkpoint();
-        for (const placement of cluster.events) {
-          eventStatuses.set(
-            placement.eventCode,
-            verified.get(placement.eventCode) ?? "failed"
+      }));
+      for (const worker of completed) {
+        const returned = worker.integration?.clusters[0];
+        if (returned) {
+          clusters = clusters.map((cluster) => cluster.id === returned.id ? returned : cluster);
+        } else {
+          clusters = transitionCluster(
+            clusters,
+            worker.cluster.id,
+            "blocked",
+            worker.error ?? "cluster worker failed"
           );
+        }
+        let applied = false;
+        if (returned?.status === "reviewed") {
+          const files = patchFiles(worker.patch);
+          const unexpected = files.filter((file) => !worker.cluster.files.includes(file));
+          if (unexpected.length > 0) {
+            clusters = transitionCluster(
+              clusters,
+              worker.cluster.id,
+              "blocked",
+              `cluster edited files outside its isolation boundary: ${unexpected.join(", ")}`
+            );
+          } else {
+            try {
+              for (const file of files) changedFiles2.add(file);
+              await saveProgress();
+              await applyPatchToRepo(worker.handle, worker.patch);
+              applied = true;
+            } catch (error) {
+              clusters = transitionCluster(
+                clusters,
+                worker.cluster.id,
+                "blocked",
+                `serial patch merge failed: ${error instanceof Error ? error.message : String(error)}`
+              );
+            }
+          }
+        }
+        for (const placement of worker.cluster.events) {
+          const status = applied ? worker.integration?.eventStatuses.get(placement.eventCode) ?? "failed" : "failed";
+          eventStatuses.set(placement.eventCode, status);
+          if (status === "failed") {
+            const current = clusters.find((candidate) => candidate.id === worker.cluster.id);
+            eventFailureReasons.set(
+              placement.eventCode,
+              current?.note ?? worker.error ?? "cluster patch could not be merged"
+            );
+          }
           await saveProgress();
           input.sink.emit({
             phase: "integrating",
             file: placement.file,
-            action: `saved ${placement.eventCode} progress`
+            action: applied ? `merged and saved ${placement.eventCode}` : `${placement.eventCode} needs manual attention`
+          });
+        }
+        if (worker.handle) {
+          await removeWorktree(worker.handle).catch(() => {
           });
         }
-      }
-    };
-    await patchPhase("integrating");
-    const integration = await runClusterIntegration(
-      deps,
-      clusters,
-      async () => worktreePatch(worktree)
-    );
-    for (const [code, status] of integration.eventStatuses) {
-      if ((eventStatuses.get(code) ?? "planned") === "planned") {
-        eventStatuses.set(code, status);
       }
     }
     await saveProgress();
@@ -2827,7 +3034,62 @@ async function runEngine(input) {
       );
     }
     await patchPhase("verifying");
-    const finalVerify = await finalizeIntegration(deps);
+    const verificationWorktree = await createWorktree(
+      input.repoPath,
+      input.force ?? false,
+      [...changedFiles2]
+    );
+    const verificationDeps = {
+      provider: input.provider,
+      models: input.models,
+      worktree: verificationWorktree,
+      target: input.target,
+      playbookSystemPrompt: input.playbookSystemPrompt,
+      registered,
+      ingestion: bootstrap.ingestion,
+      sink: input.sink,
+      saveClusters: () => {
+      },
+      discardChanges: async () => discardWorktreeChanges(verificationWorktree),
+      onClusterIntegrated: async () => {
+      }
+    };
+    let finalVerify = await finalizeIntegration(verificationDeps);
+    if (finalVerify.status === "failed") {
+      const repaired = await repairVerification(verificationDeps, finalVerify.results);
+      if (repaired) {
+        const repairPatch = await worktreePatch(verificationWorktree);
+        const repairFiles = patchFiles(repairPatch);
+        finalVerify = await finalizeIntegration(verificationDeps);
+        if (finalVerify.status !== "failed") {
+          for (const file of repairFiles) changedFiles2.add(file);
+          await saveProgress();
+          await applyPatchToRepo(verificationWorktree, repairPatch);
+        }
+      }
+    }
+    await removeWorktree(verificationWorktree).catch(() => {
+    });
+    if (finalVerify.status === "failed") {
+      for (const event of registered) {
+        eventStatuses.set(event.code, "failed");
+        eventFailureReasons.set(
+          event.code,
+          `final verification failed${finalVerify.command ? `: ${finalVerify.command}` : ""}`
+        );
+      }
+      await saveProgress();
+      throw new Error("final verification still fails after Opus repair");
+    }
+    identifyWired = await setupLooksPresent(input.repoPath, changedFiles2);
+    if (!identifyWired) {
+      for (const event of registered) {
+        eventStatuses.set(event.code, "failed");
+        eventFailureReasons.set(event.code, "SDK initialization or identify() is missing after final repair");
+      }
+      await saveProgress();
+      throw new Error("SDK initialization and identify() must be present before completion");
+    }
     await patchPhase("reporting");
     await runs.completeRun(runId, {
       changedFiles: [...changedFiles2].sort(),
@@ -2845,7 +3107,7 @@ async function runEngine(input) {
       runId,
       registered,
       eventStatuses,
-      reportEvents: buildReportEvents(registered, eventStatuses),
+      reportEvents: buildReportEvents(registered, eventStatuses, eventFailureReasons),
       changedFiles: [...changedFiles2].sort(),
       identifyWired,
       applied: changedFiles2.size > 0,
@@ -2853,6 +3115,13 @@ async function runEngine(input) {
     };
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
+    for (const event of registered) {
+      const status = eventStatuses.get(event.code) ?? "planned";
+      if (status === "planned") {
+        eventStatuses.set(event.code, "failed");
+        eventFailureReasons.set(event.code, reason);
+      }
+    }
     await failRun(reason);
     await removeWorktree(worktree).catch(() => {
     });
@@ -2861,7 +3130,7 @@ async function runEngine(input) {
       runId,
       registered,
       eventStatuses,
-      reportEvents: buildReportEvents(registered, eventStatuses),
+      reportEvents: buildReportEvents(registered, eventStatuses, eventFailureReasons),
       changedFiles: [...changedFiles2].sort(),
       identifyWired,
       applied: changedFiles2.size > 0,
@@ -2913,7 +3182,7 @@ async function reconcileProgress(repoPath, registered, prior, sink) {
 async function fileContainsWrapper(repoPath, file, eventCode) {
   try {
     const path = safeRepoPath(repoPath, file);
-    const content = await readFile2(path, "utf8");
+    const content = await readFile3(path, "utf8");
     return content.includes(eventWrapperName(eventCode));
   } catch {
     return false;
@@ -2922,23 +3191,27 @@ async function fileContainsWrapper(repoPath, file, eventCode) {
 async function setupLooksPresent(repoPath, changedFiles2) {
   let bindingsFound = false;
   let bindingCallFound = false;
+  let identifyFound = false;
+  let sdkInitializationFound = false;
   for (const file of changedFiles2) {
     try {
-      const content = await readFile2(safeRepoPath(repoPath, file), "utf8");
+      const content = await readFile3(safeRepoPath(repoPath, file), "utf8");
       const generated = content.includes("Generated by @whisperr/wizard");
       bindingsFound ||= generated;
       if (!generated) {
         bindingCallFound ||= content.includes("bindWhisperr(") || content.includes("WhisperrEvents.bind(");
+        identifyFound ||= /\bidentify\s*\(/.test(content);
+        sdkInitializationFound ||= /whisperr/i.test(content) && /(initiali[sz]e|configure|client|setup)/i.test(content);
       }
     } catch {
     }
   }
-  return bindingsFound && bindingCallFound;
+  return bindingsFound && bindingCallFound && identifyFound && sdkInitializationFound;
 }
 function safeRepoPath(repoPath, file) {
-  const root = resolve2(repoPath);
-  const path = resolve2(root, file);
-  if (path === root || !path.startsWith(root + sep2)) {
+  const root = resolve3(repoPath);
+  const path = resolve3(root, file);
+  if (path === root || !path.startsWith(root + sep3)) {
     throw new Error(`unsafe progress file path: ${file}`);
   }
   return path;
@@ -2951,7 +3224,7 @@ function buildEvidence(registered, statuses) {
     status: statuses.get(event.code) ?? "planned"
   }));
 }
-function buildReportEvents(registered, statuses) {
+function buildReportEvents(registered, statuses, failureReasons = /* @__PURE__ */ new Map()) {
   return registered.map((event) => {
     const status = statuses.get(event.code);
     const wired = status !== void 0 && status !== "failed" && status !== "unsupported" && status !== "planned";
@@ -2959,7 +3232,7 @@ function buildReportEvents(registered, statuses) {
       event_type: event.code,
       status: wired ? "wired" : "skipped",
       ...wired ? { file: event.anchorFile } : {},
-      ...wired ? {} : { reason: status ?? "not integrated" }
+      ...wired ? {} : { reason: failureReasons.get(event.code) ?? status ?? "not integrated" }
     };
   });
 }
@@ -2991,7 +3264,7 @@ import {
 // src/core/git.ts
 import { spawn as spawn3 } from "child_process";
 import { createHash as createHash3 } from "crypto";
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
 import { basename as basename2, join as join5 } from "path";
 async function takeCheckpoint(repoPath) {
   const isRepo = (await run(repoPath, ["rev-parse", "--is-inside-work-tree"])).ok;
@@ -3058,7 +3331,7 @@ async function scanWiredEvents(repoPath, files, eventTypes) {
   const contents = [];
   for (const file of files) {
     try {
-      contents.push({ file, content: await readFile3(join5(repoPath, file), "utf8") });
+      contents.push({ file, content: await readFile4(join5(repoPath, file), "utf8") });
     } catch {
       continue;
     }
@@ -3088,14 +3361,14 @@ function escapeRegExp(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function run(cwd, args) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const child = spawn3("git", args, { cwd });
     let stdout = "";
     let stderr = "";
     child.stdout.on("data", (d) => stdout += d.toString());
     child.stderr.on("data", (d) => stderr += d.toString());
-    child.on("close", (code) => resolve6({ ok: code === 0, stdout, stderr }));
-    child.on("error", () => resolve6({ ok: false, stdout, stderr }));
+    child.on("close", (code) => resolve7({ ok: code === 0, stdout, stderr }));
+    child.on("error", () => resolve7({ ok: false, stdout, stderr }));
   });
 }
 
@@ -3334,7 +3607,7 @@ function coverageNote(coverage) {
 }
 
 // src/core/toolPolicy.ts
-import { isAbsolute, relative as relative2, resolve as resolve3 } from "path";
+import { isAbsolute, relative as relative2, resolve as resolve4 } from "path";
 var SECRET_MATERIAL_DENIAL = "blocked: secret material must not be accessed";
 var WRITE_OUTSIDE_REPO_DENIAL = "blocked: writes must stay inside the target repository";
 var SENSITIVE_WRITE_DENIAL = "blocked: refusing to write CI/git configuration";
@@ -3430,8 +3703,8 @@ function isSecretPathLike(value) {
 }
 function isPathInsideRepo(pathValue, repoPath) {
   if (pathValue.includes("..")) return false;
-  const repoRoot = resolve3(repoPath);
-  const candidate = isAbsolute(pathValue) ? resolve3(pathValue) : resolve3(repoRoot, pathValue);
+  const repoRoot = resolve4(repoPath);
+  const candidate = isAbsolute(pathValue) ? resolve4(pathValue) : resolve4(repoRoot, pathValue);
   const rel = relative2(repoRoot, candidate);
   return rel === "" || !!rel && !rel.startsWith("..") && !isAbsolute(rel);
 }
@@ -3555,8 +3828,8 @@ function normalizePathLike(value) {
   return stripOuterQuotes(value.trim()).replace(/\\/g, "/");
 }
 function repoRelativePath(pathValue, repoPath) {
-  const repoRoot = resolve3(repoPath);
-  const candidate = isAbsolute(pathValue) ? resolve3(pathValue) : resolve3(repoRoot, pathValue);
+  const repoRoot = resolve4(repoPath);
+  const candidate = isAbsolute(pathValue) ? resolve4(pathValue) : resolve4(repoRoot, pathValue);
   return normalizePathLike(relative2(repoRoot, candidate));
 }
 function isSensitiveWritePath(pathValue, repoPath) {
@@ -4525,8 +4798,12 @@ function supportsClaudeFastMode(model) {
   return FAST_MODE_MODELS.has(model);
 }
 function createClaudeProvider(config, session) {
+  let runId = "";
   return {
     name: "claude",
+    onRunReady(readyRunId) {
+      runId = readyRunId;
+    },
     async invoke(invocation, roleConfig, onProgress) {
       applyModelAuthEnv(config, session);
       const hostTools = invocation.tools.map(
@@ -4546,6 +4823,17 @@ function createClaudeProvider(config, session) {
       const deadline = Date.now() + roleConfig.maxMs;
       const outcome = (kind, text = "", error = "") => kind === "completed" ? { kind, text, sessionId, costUsd, turns } : kind === "failed" ? { kind, error, sessionId, costUsd, turns } : { kind, sessionId, costUsd, turns };
       try {
+        const task = invocation.task ?? invocation.role;
+        const sessionKey = invocation.sessionKey ?? task;
+        const customHeaders = [
+          process.env.ANTHROPIC_CUSTOM_HEADERS,
+          runId ? `X-Whisperr-Wizard-Run-ID: ${headerValue(runId)}` : "",
+          `X-Whisperr-Wizard-Task: ${headerValue(task)}`,
+          `X-Whisperr-Wizard-Session-Key: ${headerValue(sessionKey)}`,
+          `X-Whisperr-Wizard-Model: ${headerValue(roleConfig.model)}`,
+          `X-Whisperr-Wizard-Effort: ${headerValue(roleConfig.effort ?? "")}`,
+          `X-Whisperr-Wizard-Service-Tier: ${roleConfig.fastMode ? "fast" : "default"}`
+        ].filter(Boolean).join("\n");
         const response = query2({
           prompt: invocation.userPrompt,
           options: {
@@ -4559,9 +4847,13 @@ function createClaudeProvider(config, session) {
             hooks: buildToolPolicyHooks(invocation.cwd, trustedTools),
             canUseTool: createToolPermissionCallback(invocation.cwd, trustedTools),
             maxTurns: roleConfig.maxTurns,
-            ...supportsClaudeFastMode(roleConfig.model) ? { settings: { fastMode: true } } : {},
+            ...roleConfig.fastMode ?? supportsClaudeFastMode(roleConfig.model) ? { settings: { fastMode: true } } : {},
             ...invocation.resumeSessionId ? { resume: invocation.resumeSessionId } : {},
-            settingSources: []
+            settingSources: [],
+            env: {
+              ...process.env,
+              ANTHROPIC_CUSTOM_HEADERS: customHeaders
+            }
           }
         });
         for await (const raw of response) {
@@ -4609,13 +4901,16 @@ function createClaudeProvider(config, session) {
     }
   };
 }
+function headerValue(value) {
+  return value.replace(/[\r\n]/g, "").slice(0, 200);
+}
 
 // src/engine/providers/openai.ts
 import { readdirSync, readFileSync as readFileSync2, statSync, writeFileSync } from "fs";
-import { join as join6, resolve as resolve4, sep as sep3 } from "path";
+import { join as join6, resolve as resolve5, sep as sep4 } from "path";
 function jailedPath(cwd, candidate) {
-  const resolved = resolve4(cwd, candidate);
-  if (resolved !== cwd && !resolved.startsWith(cwd + sep3)) {
+  const resolved = resolve5(cwd, candidate);
+  if (resolved !== cwd && !resolved.startsWith(cwd + sep4)) {
     throw new Error(`path ${candidate} escapes the repository`);
   }
   return resolved;
@@ -4715,8 +5010,9 @@ function fileTools(cwd, allowWrite) {
 }
 function createOpenAIProvider(config, session) {
   let runId;
-  let conversationId;
-  const gatewayFetch = async (path, body) => {
+  const conversationIds = /* @__PURE__ */ new Map();
+  let legacyConversationId;
+  const gatewayFetch = async (path, body, sessionKey, task) => {
     if (!runId) {
       throw new Error("OpenAI provider used before the run was created");
     }
@@ -4726,7 +5022,11 @@ function createOpenAIProvider(config, session) {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          Authorization: `Bearer ${session.token}`
+          Authorization: `Bearer ${session.token}`,
+          ...sessionKey === "legacy" ? {} : {
+            "X-Whisperr-Wizard-Session-Key": sessionKey,
+            "X-Whisperr-Wizard-Task": task
+          }
         },
         body: JSON.stringify(body)
       }
@@ -4739,44 +5039,61 @@ function createOpenAIProvider(config, session) {
       payload = {};
     }
     if (!response.ok) {
-      const detail = payload.message ?? text;
+      const top = payload;
+      const nested = top.error?.error ?? top.error;
+      const detail = top.message ?? nested?.message ?? text;
       const error = new Error(detail || `gateway request failed (${response.status})`);
-      error.code = payload.code;
+      error.code = top.code ?? nested?.code;
       throw error;
     }
     return payload;
   };
-  const ensureConversation = async (resumeId) => {
-    if (conversationId) {
-      return conversationId;
+  const ensureConversation = async (sessionKey, task, resumeId) => {
+    const existing = sessionKey === "legacy" ? legacyConversationId : conversationIds.get(sessionKey);
+    if (existing) {
+      return existing;
     }
     if (resumeId) {
-      conversationId = resumeId;
+      if (sessionKey === "legacy") {
+        legacyConversationId = resumeId;
+      } else {
+        conversationIds.set(sessionKey, resumeId);
+      }
       return resumeId;
     }
     try {
-      const created = await gatewayFetch("/v1/conversations", {});
-      conversationId = created.id;
+      const created = await gatewayFetch("/v1/conversations", {}, sessionKey, task);
+      if (created.id) {
+        if (sessionKey === "legacy") {
+          legacyConversationId = created.id;
+        } else {
+          conversationIds.set(sessionKey, created.id);
+        }
+      }
     } catch (error) {
       if (error.code !== "conversation_already_bound") {
         throw error;
       }
     }
-    if (!conversationId) {
+    const createdId = sessionKey === "legacy" ? legacyConversationId : conversationIds.get(sessionKey);
+    if (!createdId) {
       throw new Error("wizard run already has a bound conversation; rerun with its resume state");
     }
-    return conversationId;
+    return createdId;
   };
   return {
     name: "openai-gateway",
     onRunReady(readyRunId, resumeSessionId) {
       runId = readyRunId;
-      conversationId = resumeSessionId;
+      legacyConversationId = resumeSessionId;
     },
     async invoke(invocation, roleConfig, onProgress) {
       let costUsd = 0;
       let turns = 0;
-      const outcome = (kind, text = "", error = "") => kind === "completed" ? { kind, text, sessionId: conversationId, costUsd, turns } : kind === "failed" ? { kind, error, sessionId: conversationId, costUsd, turns } : { kind, sessionId: conversationId, costUsd, turns };
+      const task = invocation.task ?? invocation.role;
+      const sessionKey = invocation.sessionKey?.trim() || "legacy";
+      let activeConversationId = sessionKey === "legacy" ? legacyConversationId : conversationIds.get(sessionKey);
+      const outcome = (kind, text = "", error = "") => kind === "completed" ? { kind, text, sessionId: activeConversationId, costUsd, turns } : kind === "failed" ? { kind, error, sessionId: activeConversationId, costUsd, turns } : { kind, sessionId: activeConversationId, costUsd, turns };
       const allTools = [...invocation.tools, ...fileTools(invocation.cwd, invocation.allowRepoWrite)];
       const toolsByName = new Map(allTools.map((tool2) => [tool2.name, tool2]));
       const toolDefs = allTools.map((tool2) => ({
@@ -4786,7 +5103,12 @@ function createOpenAIProvider(config, session) {
         parameters: tool2.jsonSchema
       }));
       try {
-        const conversation = await ensureConversation(invocation.resumeSessionId);
+        const conversation = await ensureConversation(
+          sessionKey,
+          task,
+          invocation.resumeSessionId
+        );
+        activeConversationId = conversation;
         const deadline = Date.now() + roleConfig.maxMs;
         let input = [
           { role: "user", content: invocation.userPrompt }
@@ -4802,8 +5124,9 @@ function createOpenAIProvider(config, session) {
             conversation,
             input,
             tools: toolDefs,
-            ...roleConfig.effort ? { reasoning: { effort: roleConfig.effort } } : {}
-          });
+            ...roleConfig.effort ? { reasoning: { effort: roleConfig.effort } } : {},
+            ...roleConfig.serviceTier ? { service_tier: roleConfig.serviceTier } : {}
+          }, sessionKey, task);
           const items = response.output ?? [];
           const calls = items.filter(
             (item) => item.type === "function_call"
@@ -4849,18 +5172,102 @@ function createOpenAIProvider(config, session) {
 }
 
 // src/engine/providers/router.ts
-function createRoutedProvider(routes, fallback) {
-  const providers = /* @__PURE__ */ new Set([fallback, ...Object.values(routes)]);
+var Semaphore = class {
+  constructor(limit) {
+    this.limit = limit;
+  }
+  limit;
+  active = 0;
+  waiting = [];
+  async run(operation) {
+    if (this.active >= this.limit) {
+      await new Promise((resolve7) => this.waiting.push(resolve7));
+    }
+    this.active += 1;
+    try {
+      return await operation();
+    } finally {
+      this.active -= 1;
+      this.waiting.shift()?.();
+    }
+  }
+};
+function shouldFallback(outcome) {
+  if (outcome.kind === "context_overflow" || outcome.kind === "budget_exhausted") {
+    return true;
+  }
+  return outcome.kind === "failed" && classifyFailure(outcome.error) !== "fatal";
+}
+function shouldDisableProvider(outcome) {
+  return outcome.kind === "failed" && classifyFailure(outcome.error) === "transient";
+}
+function createRoutedProvider(routes, fallback, fallbackConcurrency = 2) {
+  const normalized = /* @__PURE__ */ new Map();
+  for (const [key, value] of Object.entries(routes)) {
+    normalized.set(
+      key,
+      "provider" in value ? value : { provider: value }
+    );
+  }
+  const providers = /* @__PURE__ */ new Set([
+    fallback,
+    ...[...normalized.values()].map((route) => route.provider)
+  ]);
+  const semaphores = /* @__PURE__ */ new Map();
+  const disabledProviders = /* @__PURE__ */ new Set();
+  const semaphoreFor = (provider, concurrency) => {
+    let semaphore = semaphores.get(provider);
+    if (!semaphore) {
+      semaphore = new Semaphore(concurrency ?? (provider === fallback ? fallbackConcurrency : 4));
+      semaphores.set(provider, semaphore);
+    }
+    return semaphore;
+  };
+  const routeFor = (invocation) => normalized.get(invocation.task ?? invocation.role) ?? normalized.get(invocation.role);
+  const call = (provider, concurrency, invocation, config, onProgress) => semaphoreFor(provider, concurrency).run(() => provider.invoke(invocation, config, onProgress));
   return {
     name: "routed",
     onRunReady(runId, resumeSessionId) {
+      disabledProviders.clear();
       for (const provider of providers) {
         provider.onRunReady?.(runId, resumeSessionId);
       }
     },
     invoke(invocation, config, onProgress) {
-      const provider = routes[invocation.role] ?? fallback;
-      return provider.invoke(invocation, config, onProgress);
+      const route = routeFor(invocation);
+      if (!route) {
+        return call(fallback, fallbackConcurrency, invocation, config, onProgress);
+      }
+      if (disabledProviders.has(route.provider)) {
+        return call(
+          fallback,
+          fallbackConcurrency,
+          invocation,
+          route.fallbackConfig ?? config,
+          onProgress
+        );
+      }
+      return call(route.provider, route.concurrency, invocation, config, onProgress).then(
+        async (outcome) => {
+          if (shouldDisableProvider(outcome)) {
+            disabledProviders.add(route.provider);
+          }
+          if (!invocation.allowRepoWrite && shouldFallback(outcome)) {
+            onProgress(`${route.provider.name} unavailable; continuing with ${fallback.name}`);
+            return call(
+              fallback,
+              fallbackConcurrency,
+              invocation,
+              route.fallbackConfig ?? config,
+              onProgress
+            );
+          }
+          return outcome;
+        }
+      );
+    },
+    invokeFallback(invocation, config, onProgress) {
+      return call(fallback, fallbackConcurrency, invocation, config, onProgress);
     }
   };
 }
@@ -4868,22 +5275,45 @@ function createRoutedProvider(routes, fallback) {
 // src/engine/cli.ts
 var MINUTE = 6e4;
 function engineModelConfig(config) {
-  const model = (role, fallback) => process.env[`WHISPERR_WIZARD_ENGINE_${role.toUpperCase()}_MODEL`]?.trim() || fallback;
+  const model = (task, fallback) => process.env[`WHISPERR_WIZARD_ENGINE_${task.toUpperCase()}_MODEL`]?.trim() || fallback;
+  const terra = "gpt-5.6-terra";
+  const opus = "claude-opus-5";
+  const opusOnly = process.env.WHISPERR_WIZARD_PRESET?.trim() === "claude-default" || config.offline === true;
+  const survey = opusOnly ? { model: model("survey", opus), effort: "medium", fastMode: true, maxTurns: 30, maxMs: 5 * MINUTE } : { model: model("survey", terra), effort: "medium", serviceTier: "priority", maxTurns: 30, maxMs: 5 * MINUTE };
+  const design = { model: model("design", opus), effort: "medium", fastMode: true, maxTurns: 80, maxMs: 20 * MINUTE };
+  const sdkSetup = { model: model("sdk_setup", opus), effort: "medium", fastMode: true, maxTurns: 60, maxMs: 12 * MINUTE };
+  const clusterEdit = opusOnly ? { model: model("cluster_edit", opus), effort: "medium", fastMode: true, maxTurns: 60, maxMs: 12 * MINUTE } : { model: model("cluster_edit", terra), effort: "medium", serviceTier: "priority", maxTurns: 30, maxMs: 5 * MINUTE };
+  const repair = { model: model("repair", opus), effort: "medium", fastMode: true, maxTurns: 30, maxMs: 8 * MINUTE };
+  const review = { model: model("review", opus), effort: "medium", fastMode: true, maxTurns: 30, maxMs: 8 * MINUTE };
   return {
-    survey: { model: model("survey", config.model), effort: "medium", maxTurns: 40, maxMs: 12 * MINUTE },
-    design: { model: model("design", config.plannerModel), effort: "high", maxTurns: 40, maxMs: 15 * MINUTE },
-    edit: { model: model("edit", config.model), effort: config.effort, maxTurns: 50, maxMs: 15 * MINUTE },
-    review: { model: model("review", config.model), effort: "medium", maxTurns: 15, maxMs: 8 * MINUTE }
+    survey,
+    design,
+    edit: sdkSetup,
+    review,
+    sdk_setup: sdkSetup,
+    cluster_edit: clusterEdit,
+    repair
   };
 }
 function engineProvider(config, session) {
   const claude = createClaudeProvider(config, session);
-  const preset = process.env.WHISPERR_WIZARD_PRESET?.trim() ?? "claude-default";
+  const models = engineModelConfig(config);
+  const preset = process.env.WHISPERR_WIZARD_PRESET?.trim() ?? "hybrid";
+  if (preset === "claude-default" || config.offline) {
+    return createRoutedProvider({}, claude, 2);
+  }
+  const openai = createOpenAIProvider(config, session);
   if (preset === "sol-design") {
-    const openai = createOpenAIProvider(config, session);
-    return createRoutedProvider({ survey: openai, design: openai, review: openai }, claude);
+    return createRoutedProvider({
+      survey: { provider: openai, fallbackConfig: models.sdk_setup },
+      design: { provider: openai, fallbackConfig: models.design },
+      review: { provider: openai, fallbackConfig: models.review }
+    }, claude);
   }
-  return claude;
+  return createRoutedProvider({
+    survey: { provider: openai, concurrency: 4, fallbackConfig: models.sdk_setup },
+    cluster_edit: { provider: openai, concurrency: 4, fallbackConfig: models.sdk_setup }
+  }, claude, 2);
 }
 async function tryEngineFlow(options) {
   const { repoPath, fingerprint, config, session, playbook, theme: theme2 } = options;
@@ -5200,7 +5630,7 @@ function runVerifyCommand(repoPath, command, opts = {}) {
     return Promise.resolve({ ran: false, ok: true, output: "" });
   }
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const child = spawn4(command, { cwd: repoPath, shell: true, env: process.env });
     let out = "";
     const append = (d) => {
@@ -5211,11 +5641,11 @@ function runVerifyCommand(repoPath, command, opts = {}) {
     child.stderr?.on("data", append);
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
-      resolve6({ ran: true, ok: false, command, output: tail2(out), timedOut: true });
+      resolve7({ ran: true, ok: false, command, output: tail2(out), timedOut: true });
     }, timeoutMs);
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve6({
+      resolve7({
         ran: true,
         ok: code === 0,
         command,
@@ -5227,7 +5657,7 @@ function runVerifyCommand(repoPath, command, opts = {}) {
     });
     child.on("error", () => {
       clearTimeout(timer);
-      resolve6({ ran: true, ok: false, command, output: tail2(out), toolMissing: true });
+      resolve7({ ran: true, ok: false, command, output: tail2(out), toolMissing: true });
     });
   });
 }
@@ -5238,11 +5668,11 @@ function tail2(s) {
 
 // src/core/version.ts
 import { readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname4, join as join7, parse } from "path";
+import { dirname as dirname3, join as join7, parse } from "path";
 import { fileURLToPath } from "url";
 var PACKAGE_NAME = "@whisperr/wizard";
 function packageVersion() {
-  let dir = dirname4(fileURLToPath(import.meta.url));
+  let dir = dirname3(fileURLToPath(import.meta.url));
   const { root } = parse(dir);
   while (true) {
     try {
@@ -5251,7 +5681,7 @@ function packageVersion() {
     } catch {
     }
     if (dir === root) return "0.0.0";
-    dir = dirname4(dir);
+    dir = dirname3(dir);
   }
 }
 
@@ -5384,7 +5814,7 @@ function banner() {
 
 // src/cli.ts
 async function run2(options) {
-  const repoPath = resolve5(options.path ?? process.cwd());
+  const repoPath = resolve6(options.path ?? process.cwd());
   const config = resolveConfig(options);
   console.log(banner());
   p2.intro(theme.signal("Let's wire Whisperr into your app."));