@whisperr/wizard 0.7.3 → 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 resolve3 } from "path";
+import { resolve as resolve6 } from "path";
 import * as p2 from "@clack/prompts";
 import open2 from "open";
 
@@ -1308,84 +1308,8 @@ function createProgressSink(options) {
 }
 
 // src/engine/orchestrator.ts
-import { basename, join as join6 } from "path";
-
-// 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");
-  return `cluster_${digest.slice(0, 12)}`;
-}
-function deriveClusters(placements) {
-  const byFile = /* @__PURE__ */ new Map();
-  for (const placement of placements) {
-    const existing = byFile.get(placement.file) ?? [];
-    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));
-    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
-      });
-    }
-  }
-  return clusters;
-}
-var TERMINAL_STATUSES = ["reviewed", "failed_resumable", "blocked"];
-function nextPendingCluster(clusters) {
-  return clusters.find((cluster) => cluster.status === "pending" || cluster.status === "editing");
-}
-function clustersComplete(clusters) {
-  return clusters.every((cluster) => TERMINAL_STATUSES.includes(cluster.status));
-}
-function transitionCluster(clusters, clusterId, status, note3) {
-  return clusters.map((cluster) => {
-    if (cluster.id !== clusterId) {
-      return cluster;
-    }
-    const attempts = status === "editing" ? cluster.attempts + 1 : cluster.attempts;
-    return { ...cluster, status, attempts, note: note3 ?? cluster.note };
-  });
-}
-
-// src/engine/integrate.ts
-import { writeFile } from "fs/promises";
-import { join as join3 } 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) {
@@ -1582,6 +1506,104 @@ function generateDart(events) {
     bindInstruction: "Call WhisperrEvents.bind(track) once, immediately after the Whisperr SDK is initialized, forwarding to the SDK's track call."
   };
 }
+function bindingsClassName(target9) {
+  return bindingsTargetFor(target9) === "typescript" ? "WhisperrEvents" : "WhisperrEvents";
+}
+function eventWrapperName(code) {
+  return `${bindingsClassName("")}.${camelCase(code)}`;
+}
+
+// src/engine/clusters.ts
+import { createHash } from "crypto";
+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) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const placement of placements) {
+    const existing = byFile.get(placement.file) ?? [];
+    existing.push(placement);
+    byFile.set(placement.file, existing);
+  }
+  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) {
+      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");
+}
+function clustersComplete(clusters) {
+  return clusters.every((cluster) => TERMINAL_STATUSES.includes(cluster.status));
+}
+function transitionCluster(clusters, clusterId, status, note3) {
+  return clusters.map((cluster) => {
+    if (cluster.id !== clusterId) {
+      return cluster;
+    }
+    const attempts = status === "editing" ? cluster.attempts + 1 : cluster.attempts;
+    return { ...cluster, status, attempts, note: note3 ?? cluster.note };
+  });
+}
+
+// src/engine/integrate.ts
+import { readFile as readFile2, writeFile } from "fs/promises";
+import { join as join3, resolve, sep } from "path";
 
 // src/engine/budgets.ts
 var OVERFLOW_PATTERNS = [
@@ -1593,6 +1615,8 @@ var OVERFLOW_PATTERNS = [
 ];
 var TRANSIENT_PATTERNS = [
   /rate.?limit/i,
+  /quota/i,
+  /\b429\b/,
   /overloaded/i,
   /timeout/i,
   /timed out/i,
@@ -1622,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";
@@ -1666,7 +1695,7 @@ function npmCommand() {
   return process.platform === "win32" ? "npm.cmd" : "npm";
 }
 function runVerifyStep(cwd, step, timeoutMs = 3e5) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve7) => {
     const child = spawn(step.command, step.args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
     let output = "";
     const capture = (chunk) => {
@@ -1681,11 +1710,11 @@ function runVerifyStep(cwd, step, timeoutMs = 3e5) {
     }, timeoutMs);
     child.on("error", (error) => {
       clearTimeout(timer);
-      resolve4({ ...step, ok: false, output: String(error) });
+      resolve7({ ...step, ok: false, output: String(error) });
     });
     child.on("close", (exitCode) => {
       clearTimeout(timer);
-      resolve4({ ...step, ok: exitCode === 0, output });
+      resolve7({ ...step, ok: exitCode === 0, output });
     });
   });
 }
@@ -1696,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";
@@ -1741,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:",
@@ -1757,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";
@@ -1791,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."
@@ -1808,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") {
@@ -1821,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);
@@ -1837,71 +1854,130 @@ 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");
       }
+      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) {
       eventStatuses.set(placement.eventCode, finalStatus);
     }
+    await deps.onClusterIntegrated(cluster, finalStatus);
   }
   if (!clustersComplete(clusters)) {
     throw new Error("cluster queue did not reach a terminal state");
   }
   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" });
@@ -1912,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";
@@ -1977,6 +2080,9 @@ var RunsClient = class {
   patchRun(runId, patch) {
     return this.request("PATCH", `/wizard/runs/${runId}`, { ...patch });
   }
+  saveProgress(runId, progress) {
+    return this.patchRun(runId, { integrationEvidence: progress });
+  }
   writeItem(runId, kind, payload, idempotencyExtra = "") {
     const code = typeof payload.code === "string" ? payload.code : JSON.stringify(payload);
     return this.request("POST", `/wizard/runs/${runId}/items`, {
@@ -2029,7 +2135,13 @@ function normalizeRunBootstrap(payload) {
       target: stringValue(project.target),
       kind: stringValue(project.kind)
     },
-    run: { id: run3.id, status: stringValue(run3.status), phase: stringValue(run3.phase) },
+    run: {
+      id: run3.id,
+      status: stringValue(run3.status),
+      phase: stringValue(run3.phase),
+      ...stringValue(run3.modelConversationId) ? { modelConversationId: stringValue(run3.modelConversationId) } : {},
+      ...normalizeIntegrationProgress(run3.integrationEvidence) ? { integrationEvidence: normalizeIntegrationProgress(run3.integrationEvidence) } : {}
+    },
     resumed: value.resumed === true,
     universeMode: stringValue(value.universeMode),
     ...record(value.onboardingContext) ? { onboardingContext: record(value.onboardingContext) } : {},
@@ -2041,6 +2153,31 @@ function normalizeRunBootstrap(payload) {
     ingestion: { apiKey: ingestion.apiKey, baseUrl: ingestion.baseUrl }
   };
 }
+function normalizeIntegrationProgress(payload) {
+  const value = record(payload);
+  if (!value || !Array.isArray(value.changedFiles) || !Array.isArray(value.events)) {
+    return void 0;
+  }
+  const events = value.events.map((candidate) => {
+    const event = record(candidate);
+    if (!event || !stringValue(event.eventId) || !stringValue(event.eventCode)) {
+      return void 0;
+    }
+    return {
+      eventId: stringValue(event.eventId),
+      eventCode: stringValue(event.eventCode),
+      ...stringValue(event.file) ? { file: stringValue(event.file) } : {},
+      status: stringValue(event.status)
+    };
+  }).filter((event) => event !== void 0);
+  return {
+    changedFiles: value.changedFiles.filter((file) => typeof file === "string"),
+    identifyWired: value.identifyWired === true,
+    verificationStatus: stringValue(value.verificationStatus) || "pending",
+    ...stringValue(value.verificationCommand) ? { verificationCommand: stringValue(value.verificationCommand) } : {},
+    events
+  };
+}
 function record(value) {
   return typeof value === "object" && value !== null ? value : void 0;
 }
@@ -2049,7 +2186,7 @@ function stringValue(value) {
 }
 function isSnapshotEvent(value) {
   const event = record(value);
-  return !!event && typeof event.id === "string" && typeof event.code === "string" && typeof event.name === "string" && typeof event.reasoning === "string" && typeof event.projectId === "string" && !!record(event.payloadSchema);
+  return !!event && typeof event.id === "string" && typeof event.code === "string" && typeof event.name === "string" && typeof event.reasoning === "string" && typeof event.projectId === "string" && (event.anchorFile === void 0 || typeof event.anchorFile === "string") && (event.anchorSymbol === void 0 || typeof event.anchorSymbol === "string") && !!record(event.payloadSchema);
 }
 
 // src/engine/selection.ts
@@ -2193,9 +2330,14 @@ function validateProposedEvent(input, seen, rejected) {
   if (rejected.has(code)) {
     return { ok: false, reason: `event ${code} was rejected by the user \u2014 do not re-propose it` };
   }
-  if (!input.name.trim() || !input.reasoning.trim() || !input.anchorFile.trim()) {
+  const anchorFile = input.anchorFile.trim().replaceAll("\\", "/");
+  const anchorParts = anchorFile.split("/");
+  if (!input.name.trim() || !input.reasoning.trim() || !anchorFile) {
     return { ok: false, reason: "name, reasoning, and anchorFile are required" };
   }
+  if (anchorFile.startsWith("/") || /^[a-z]:/i.test(anchorFile) || anchorParts.some((part) => part === "" || part === "." || part === "..")) {
+    return { ok: false, reason: "anchorFile must be a safe repository-relative path" };
+  }
   const schema = {};
   for (const [field, description] of Object.entries(input.payloadSchema ?? {})) {
     const normalizedField = normalizeEventCode(field);
@@ -2216,7 +2358,7 @@ function validateProposedEvent(input, seen, rejected) {
       code,
       name: input.name.trim(),
       reasoning: input.reasoning.trim(),
-      anchorFile: input.anchorFile.trim(),
+      anchorFile,
       anchorSymbol: input.anchorSymbol?.trim() || void 0,
       payloadSchema: schema
     }
@@ -2227,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: [],
@@ -2234,12 +2378,12 @@ 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 };
 }
-async function runSelection(provider, models, repoPath, bootstrap, surveyReport, rejectedCodes, sink) {
+async function runSelection(provider, models, repoPath, bootstrap, surveyReport, rejectedCodes, sink, existingEventCodes = bootstrap.snapshot.events.map((event) => event.code)) {
   const proposed = [];
   const seen = /* @__PURE__ */ new Set();
   const rejected = new Set(rejectedCodes);
@@ -2295,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.",
@@ -2314,18 +2489,19 @@ async function runSelection(provider, models, repoPath, bootstrap, surveyReport,
   const outcome = await provider.invoke(
     {
       role: "design",
+      task: "design",
       systemPrompt: SELECTION_SYSTEM_PROMPT,
       userPrompt: selectionUserPrompt(
         surveyReport,
         renderOnboardingContext(bootstrap.onboardingContext),
-        bootstrap.snapshot.events.map((event) => event.code),
+        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 {
@@ -2340,12 +2516,27 @@ async function runSelection(provider, models, repoPath, bootstrap, surveyReport,
 async function registerApprovedEvents(runs, runId, approved, sink) {
   const registered = [];
   for (const event of approved) {
-    const result = await runs.writeItem(runId, "event", {
-      code: event.code,
-      name: event.name,
-      reasoning: event.reasoning,
-      ...Object.keys(event.payloadSchema).length > 0 ? { payloadSchema: event.payloadSchema } : {}
-    });
+    let result;
+    try {
+      result = await runs.writeItem(runId, "event", {
+        code: event.code,
+        name: event.name,
+        reasoning: event.reasoning,
+        anchorFile: event.anchorFile,
+        ...event.anchorSymbol ? { anchorSymbol: event.anchorSymbol } : {},
+        ...Object.keys(event.payloadSchema).length > 0 ? { payloadSchema: event.payloadSchema } : {}
+      }, "placement-v2");
+    } catch (error) {
+      if (error instanceof RunsApiError && error.code === "wizard_project_conflict") {
+        sink.emit({
+          phase: "persisting",
+          file: event.anchorFile,
+          action: `skipped ${event.code} \u2014 already registered by another project`
+        });
+        continue;
+      }
+      throw error;
+    }
     registered.push({ ...event, eventId: result.id || result.item?.id || "" });
     sink.emit({ phase: "persisting", file: event.anchorFile, action: `registered ${event.code}` });
   }
@@ -2361,99 +2552,11 @@ function placementsFor(registered) {
   }));
 }
 
-// src/engine/state.ts
-import { createHash as createHash3 } from "crypto";
-import { mkdirSync, readFileSync as readFileSync2, renameSync, writeFileSync } from "fs";
-import { homedir, tmpdir } from "os";
-import { join as join4 } from "path";
-
-// src/engine/types.ts
-var ENGINE_PHASES = [
-  "authorizing",
-  "surveying",
-  "designing",
-  "persisting",
-  "binding",
-  "integrating",
-  "reviewing",
-  "verifying",
-  "reporting",
-  "completed"
-];
-
-// src/engine/state.ts
-function stateDirectory() {
-  const override = process.env.WHISPERR_WIZARD_STATE_DIR?.trim();
-  const preferred = override || join4(homedir(), ".whisperr", "wizard-runs");
-  if (canCreateStateDirectory(preferred)) {
-    return preferred;
-  }
-  const user = typeof process.getuid === "function" ? process.getuid() : "user";
-  const fallback = join4(tmpdir(), `whisperr-${user}`, "wizard-runs");
-  if (canCreateStateDirectory(fallback)) {
-    return fallback;
-  }
-  throw new Error("Whisperr Wizard could not create a directory for run state");
-}
-function stateKey(apiBaseUrl, appId, repoFingerprint2) {
-  return createHash3("sha256").update(`${apiBaseUrl}
-${appId}
-${repoFingerprint2}`).digest("hex").slice(0, 24);
-}
-function statePath(apiBaseUrl, appId, repoFingerprint2) {
-  return join4(stateDirectory(), `${stateKey(apiBaseUrl, appId, repoFingerprint2)}.json`);
-}
-function saveRunState(state) {
-  const directory = stateDirectory();
-  const path = join4(directory, `${stateKey(state.apiBaseUrl, state.appId, state.repoFingerprint)}.json`);
-  const payload = JSON.stringify({ ...state, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2);
-  const temporary = `${path}.tmp`;
-  writeFileSync(temporary, payload, { mode: 384 });
-  renameSync(temporary, path);
-}
-function canCreateStateDirectory(directory) {
-  try {
-    mkdirSync(directory, { recursive: true, mode: 448 });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function loadRunState(apiBaseUrl, appId, repoFingerprint2) {
-  const path = statePath(apiBaseUrl, appId, repoFingerprint2);
-  let raw;
-  try {
-    raw = readFileSync2(path, "utf8");
-  } catch {
-    return void 0;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return void 0;
-  }
-  if (!isEngineRunState(parsed)) {
-    return void 0;
-  }
-  if (parsed.apiBaseUrl !== apiBaseUrl || parsed.appId !== appId || parsed.repoFingerprint !== repoFingerprint2) {
-    return void 0;
-  }
-  return parsed;
-}
-function isEngineRunState(value) {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  const candidate = value;
-  return candidate.version === 1 && typeof candidate.apiBaseUrl === "string" && typeof candidate.appId === "string" && typeof candidate.repoFingerprint === "string" && typeof candidate.runId === "string" && typeof candidate.phase === "string" && ENGINE_PHASES.includes(candidate.phase) && typeof candidate.designComplete === "boolean" && Array.isArray(candidate.tombstonedCodes) && Array.isArray(candidate.clusters) && typeof candidate.providerSessions === "object" && candidate.providerSessions !== null;
-}
-
 // src/engine/worktree.ts
 import { spawn as spawn2 } from "child_process";
-import { mkdtemp, writeFile as writeFile2 } from "fs/promises";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join5 } from "path";
+import { cp, lstat, mkdir, mkdtemp, rm, writeFile as writeFile2 } from "fs/promises";
+import { tmpdir } from "os";
+import { dirname, join as join4, relative, resolve as resolve2, sep as sep2 } from "path";
 var WorktreeError = class extends Error {
   constructor(code, message) {
     super(message);
@@ -2463,7 +2566,7 @@ var WorktreeError = class extends Error {
   code;
 };
 function git(cwd, args) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve7) => {
     const child = spawn2("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
@@ -2473,8 +2576,8 @@ function git(cwd, args) {
     child.stderr.on("data", (chunk) => {
       stderr += String(chunk);
     });
-    child.on("error", () => resolve4({ ok: false, stdout, stderr: "git is not available" }));
-    child.on("close", (exitCode) => resolve4({ 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) {
@@ -2484,21 +2587,64 @@ async function must(cwd, args) {
   }
   return result.stdout;
 }
-async function createWorktree(repoPath, force = false) {
+function safeRepoFile(repoPath, file) {
+  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;
+}
+async function dirtyFiles(repoPath) {
+  const tracked = await must(repoPath, ["diff", "--name-only", "-z", "HEAD"]);
+  const untracked = await must(repoPath, ["ls-files", "--others", "--exclude-standard", "-z"]);
+  return [...new Set((tracked + untracked).split("\0").filter(Boolean))];
+}
+async function seedWorktree(repoPath, worktreePath, files) {
+  for (const file of files) {
+    const source = safeRepoFile(repoPath, file);
+    const destination = safeRepoFile(worktreePath, file);
+    try {
+      await lstat(source);
+      await mkdir(dirname(destination), { recursive: true });
+      await cp(source, destination, { recursive: true, force: true });
+    } catch {
+      await rm(destination, { recursive: true, force: true });
+    }
+  }
+}
+async function createWorktree(repoPath, force = false, allowedDirtyFiles = []) {
   const inside = await git(repoPath, ["rev-parse", "--is-inside-work-tree"]);
   if (!inside.ok) {
     throw new WorktreeError("not_a_repo", "the target directory is not a git repository");
   }
-  const status = await must(repoPath, ["status", "--porcelain"]);
-  if (status.trim() !== "" && !force) {
+  const dirty = await dirtyFiles(repoPath);
+  const allowed = new Set(allowedDirtyFiles);
+  const unexpected = dirty.filter((file) => !allowed.has(file));
+  if (unexpected.length > 0 && !force) {
     throw new WorktreeError(
       "dirty_repo",
-      "the repository has uncommitted changes \u2014 commit or stash them, or rerun with --force"
+      `the repository has unrelated uncommitted changes (${unexpected.slice(0, 3).join(", ")}) \u2014 commit or stash them, or rerun with --force`
     );
   }
-  const baseRef = (await must(repoPath, ["rev-parse", "HEAD"])).trim();
-  const path = await mkdtemp(join5(tmpdir2(), "whisperr-worktree-"));
+  let baseRef = (await must(repoPath, ["rev-parse", "HEAD"])).trim();
+  const path = await mkdtemp(join4(tmpdir(), "whisperr-worktree-"));
   await must(repoPath, ["worktree", "add", "--detach", "--force", path, "HEAD"]);
+  const seedFiles = force ? dirty : dirty.filter((file) => allowed.has(file));
+  if (seedFiles.length > 0) {
+    await seedWorktree(repoPath, path, seedFiles);
+    await must(path, ["add", "-A"]);
+    await must(path, [
+      "-c",
+      "user.name=Whisperr Wizard",
+      "-c",
+      "user.email=wizard@whisperr.net",
+      "commit",
+      "--no-gpg-sign",
+      "-m",
+      "Whisperr resume checkpoint"
+    ]);
+    baseRef = (await must(path, ["rev-parse", "HEAD"])).trim();
+  }
   return { path, baseRef, repoPath };
 }
 async function worktreePatch(handle) {
@@ -2509,7 +2655,7 @@ async function applyPatchToRepo(handle, patch) {
   if (patch.trim() === "") {
     return;
   }
-  await new Promise((resolve4, reject) => {
+  await new Promise((resolve7, reject) => {
     const child = spawn2("git", ["apply", "--whitespace=nowarn"], {
       cwd: handle.repoPath,
       stdio: ["pipe", "ignore", "pipe"]
@@ -2521,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) {
-        resolve4();
+        resolve7();
       } else {
         reject(new WorktreeError("git_failed", `git apply failed: ${stderr.trim()}`));
       }
@@ -2529,13 +2675,27 @@ async function applyPatchToRepo(handle, patch) {
     child.stdin.end(patch);
   });
 }
-async function savePartialPatch(handle, destination) {
-  const patch = await worktreePatch(handle);
+async function commitWorktreeCheckpoint(handle) {
+  await must(handle.path, ["add", "-A"]);
+  const patch = await must(handle.path, ["diff", "--cached", "--binary", handle.baseRef]);
   if (patch.trim() === "") {
-    return void 0;
+    return;
   }
-  await writeFile2(destination, patch, { mode: 384 });
-  return destination;
+  await must(handle.path, [
+    "-c",
+    "user.name=Whisperr Wizard",
+    "-c",
+    "user.email=wizard@whisperr.net",
+    "commit",
+    "--no-gpg-sign",
+    "-m",
+    "Whisperr integration checkpoint"
+  ]);
+  handle.baseRef = (await must(handle.path, ["rev-parse", "HEAD"])).trim();
+}
+async function discardWorktreeChanges(handle) {
+  await must(handle.path, ["reset", "--hard", handle.baseRef]);
+  await must(handle.path, ["clean", "-fd"]);
 }
 async function removeWorktree(handle) {
   await git(handle.repoPath, ["worktree", "remove", "--force", handle.path]);
@@ -2560,7 +2720,7 @@ async function runEngine(input) {
     throw error;
   }
   const runId = bootstrap.run.id;
-  input.provider.onRunReady?.(runId);
+  input.provider.onRunReady?.(runId, bootstrap.run.modelConversationId);
   const patchPhase = async (phase, message) => {
     try {
       await runs.patchRun(runId, { phase, ...message ? { message } : {} });
@@ -2573,45 +2733,42 @@ async function runEngine(input) {
     } catch {
     }
   };
-  let state;
-  try {
-    state = loadRunState(input.config.apiBaseUrl, input.session.appId, input.repoFingerprint) ?? freshState(input, runId);
-    if (state.runId !== runId) {
-      state = freshState(input, runId);
-    }
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    await failRun(`state initialization failed: ${reason}`);
-    return { kind: "aborted", reason: `state initialization failed: ${reason}` };
-  }
-  const persist = () => saveRunState(state);
   let registered;
-  if (!state.designComplete) {
-    try {
+  try {
+    const projectEvents = bootstrap.snapshot.events.filter(
+      (event) => event.projectId === bootstrap.project.id
+    );
+    const placed = registeredFromSnapshot(projectEvents);
+    const missingPlacement = projectEvents.filter((event) => !event.anchorFile);
+    if (placed.length === 0 || missingPlacement.length > 0) {
+      input.sink.emit({
+        phase: "surveying",
+        action: projectEvents.length === 0 ? "no saved progress found; starting a fresh survey" : "saved events need placement recovery; verifying the repository"
+      });
       await patchPhase("surveying");
       const survey = await runSurvey(
         input.provider,
         input.models,
         input.repoPath,
         bootstrap,
-        input.sink,
-        state.providerSessions.survey
+        input.sink
       );
       if (survey.outcome.kind !== "completed") {
         await failRun(`survey ${survey.outcome.kind}`);
         return { kind: "aborted", reason: `survey ${survey.outcome.kind}` };
       }
-      state.providerSessions.survey = survey.outcome.sessionId;
-      persist();
       await patchPhase("designing");
+      const recoverableCodes = new Set(missingPlacement.map((event) => event.code));
+      const existingCodes = bootstrap.snapshot.events.filter((event) => !recoverableCodes.has(event.code)).map((event) => event.code);
       const selection = await runSelection(
         input.provider,
         input.models,
         input.repoPath,
         bootstrap,
         survey.report,
-        state.tombstonedCodes,
-        input.sink
+        [],
+        input.sink,
+        existingCodes
       );
       if (!selection.finished) {
         const reason = selection.outcome === "completed" ? "selection did not call finish_selection" : `selection ${selection.outcome}`;
@@ -2631,189 +2788,443 @@ async function runEngine(input) {
         await failRun("no events accepted for instrumentation");
         return { kind: "aborted", reason: "no events accepted for instrumentation" };
       }
-      const approvedCodes = new Set(approved.map((event) => event.code));
-      for (const event of selection.proposed) {
-        if (!approvedCodes.has(event.code) && !state.tombstonedCodes.includes(event.code)) {
-          state.tombstonedCodes.push(event.code);
-        }
-      }
-      persist();
       await patchPhase("persisting", `registering ${approved.length} events`);
-      registered = await registerApprovedEvents(runs, runId, approved, input.sink);
-      state.designComplete = true;
-      state.clusters = deriveClusters(placementsFor(registered));
-      persist();
-    } catch (error) {
-      const reason = error instanceof Error ? error.message : String(error);
-      await failRun(`design failed: ${reason}`);
-      return { kind: "aborted", reason: `design failed: ${reason}` };
+      const newlyRegistered = await registerApprovedEvents(runs, runId, approved, input.sink);
+      registered = mergeRegistered(placed, newlyRegistered);
+      const unresolved = projectEvents.filter((event) => !registered.some((candidate) => candidate.code === event.code)).map((event) => event.code);
+      if (unresolved.length > 0) {
+        throw new Error(`could not recover placements for: ${unresolved.join(", ")}`);
+      }
+    } else {
+      registered = placed;
+      input.sink.emit({
+        phase: "integrating",
+        action: `found ${registered.length} saved events; verifying current files`
+      });
     }
-  } else {
-    registered = rebuildRegistered(state, bootstrap);
-    input.sink.emit({ phase: "designing", action: `resumed with ${registered.length} registered events` });
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    await failRun(`design failed: ${reason}`);
+    return { kind: "aborted", reason: `design failed: ${reason}` };
   }
   if (registered.length === 0) {
     await failRun("no events registered for this project");
     return { kind: "aborted", reason: "no events registered for this project" };
   }
+  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") {
+      changedFiles2.add(event.anchorFile);
+    }
+  }
+  let identifyWired = prior?.identifyWired === true && await setupLooksPresent(input.repoPath, changedFiles2);
+  const progress = () => ({
+    changedFiles: [...changedFiles2].sort(),
+    identifyWired,
+    verificationStatus: "pending",
+    events: buildEvidence(registered, eventStatuses)
+  });
+  const saveProgress = async () => {
+    await runs.saveProgress(runId, progress());
+  };
+  try {
+    await saveProgress();
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    await failRun(`progress initialization failed: ${reason}`);
+    return { kind: "aborted", reason: `progress initialization failed: ${reason}` };
+  }
   await patchPhase("binding");
   let worktree;
   try {
-    worktree = await createWorktree(input.repoPath, input.force ?? false);
+    worktree = await createWorktree(
+      input.repoPath,
+      input.force ?? false,
+      [...changedFiles2]
+    );
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
     await failRun(reason);
     return { kind: "aborted", reason };
   }
-  state.worktreePath = worktree.path;
-  persist();
+  const checkpoint = async () => {
+    const patch = await worktreePatch(worktree);
+    if (patch.trim() === "") {
+      return [];
+    }
+    const files = patchFiles(patch);
+    for (const file of files) {
+      changedFiles2.add(file);
+    }
+    await saveProgress();
+    await applyPatchToRepo(worktree, patch);
+    await commitWorktreeCheckpoint(worktree);
+    return files;
+  };
   try {
     const bindings = await writeBindingsModule(worktree, input.target, registered);
-    const deps = {
+    if (!identifyWired) {
+      const setupCompleted = await runSdkSetupPass({
+        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 () => {
+        }
+      }, bindings);
+      if (!setupCompleted) {
+        throw new Error("SDK setup did not complete");
+      }
+      await checkpoint();
+      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();
+    }
+    const pending = registered.filter((event) => {
+      const status = eventStatuses.get(event.code) ?? "planned";
+      return status === "planned" || status === "failed";
+    });
+    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)
+          );
+          return {
+            ...worker,
+            integration,
+            patch: await worktreePatch(worker.handle)
+          };
+        } catch (error) {
+          return {
+            ...worker,
+            integration: void 0,
+            patch: "",
+            error: error instanceof Error ? error.message : String(error)
+          };
+        }
+      }));
+      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: applied ? `merged and saved ${placement.eventCode}` : `${placement.eventCode} needs manual attention`
+          });
+        }
+        if (worker.handle) {
+          await removeWorktree(worker.handle).catch(() => {
+          });
+        }
+      }
+    }
+    await saveProgress();
+    const unfinished = registered.filter((event) => {
+      const status = eventStatuses.get(event.code) ?? "planned";
+      return status === "planned" || status === "failed";
+    });
+    if (unfinished.length > 0) {
+      throw new Error(
+        `${unfinished.length} event${unfinished.length === 1 ? "" : "s"} still need integration`
+      );
+    }
+    await patchPhase("verifying");
+    const verificationWorktree = await createWorktree(
+      input.repoPath,
+      input.force ?? false,
+      [...changedFiles2]
+    );
+    const verificationDeps = {
       provider: input.provider,
       models: input.models,
-      worktree,
+      worktree: verificationWorktree,
       target: input.target,
       playbookSystemPrompt: input.playbookSystemPrompt,
       registered,
       ingestion: bootstrap.ingestion,
       sink: input.sink,
-      saveClusters: (clusters) => {
-        state.clusters = clusters;
-        persist();
+      saveClusters: () => {
+      },
+      discardChanges: async () => discardWorktreeChanges(verificationWorktree),
+      onClusterIntegrated: async () => {
       }
     };
-    const identifyWired = await runSdkSetupPass(deps, bindings);
-    await patchPhase("integrating");
-    const integration = await runClusterIntegration(
-      deps,
-      state.clusters,
-      async () => worktreePatch(worktree)
-    );
-    state.clusters = integration.clusters;
-    persist();
-    const finalVerify = await finalizeIntegration(deps);
-    const patch = await worktreePatch(worktree);
-    const changedFiles2 = patchFiles(patch);
+    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");
-    const evidence = buildEvidence(registered, integration.eventStatuses, changedFiles2);
-    await completeRun(
-      runs,
-      runId,
-      evidence,
-      integration.eventStatuses,
-      changedFiles2,
+    await runs.completeRun(runId, {
+      changedFiles: [...changedFiles2].sort(),
       identifyWired,
-      finalVerify.status,
-      finalVerify.command
-    );
-    const summaryLines = summarize(registered, integration.eventStatuses);
-    const applied = patch.trim() !== "" && await input.callbacks.confirmApply(patch, summaryLines);
-    if (applied) {
-      await applyPatchToRepo(worktree, patch);
-    }
-    const partialPatchPath = applied ? void 0 : await savePartialPatch(worktree, join6(input.repoPath, ".whisperr-wizard.patch"));
-    await removeWorktree(worktree);
-    state.worktreePath = void 0;
-    persist();
-    const hasFailures = [...integration.eventStatuses.values()].some(
-      (status) => status === "failed"
-    );
+      verificationStatus: finalVerify.status,
+      ...finalVerify.command ? { verificationCommand: finalVerify.command } : {},
+      events: buildEvidence(registered, eventStatuses)
+    });
+    await removeWorktree(worktree).catch(() => {
+    });
+    const summaryLines = summarize(registered, eventStatuses);
+    const hasFailures = [...eventStatuses.values()].some((status) => status === "failed");
     return {
       kind: hasFailures ? "partial" : "completed",
       runId,
       registered,
-      eventStatuses: integration.eventStatuses,
-      reportEvents: buildReportEvents(registered, integration.eventStatuses),
-      changedFiles: changedFiles2,
+      eventStatuses,
+      reportEvents: buildReportEvents(registered, eventStatuses, eventFailureReasons),
+      changedFiles: [...changedFiles2].sort(),
       identifyWired,
-      applied,
-      partialPatchPath: partialPatchPath ?? void 0,
+      applied: changedFiles2.size > 0,
       summary: summaryLines.join("\n")
     };
   } 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);
-    const partialPatchPath = await savePartialPatch(
-      worktree,
-      join6(input.repoPath, ".whisperr-wizard.patch")
-    ).catch(() => void 0);
-    persist();
+    await removeWorktree(worktree).catch(() => {
+    });
     return {
       kind: "partial",
       runId,
       registered,
-      eventStatuses: /* @__PURE__ */ new Map(),
-      reportEvents: buildReportEvents(registered, /* @__PURE__ */ new Map()),
-      changedFiles: [],
-      identifyWired: false,
-      applied: false,
-      partialPatchPath: partialPatchPath ?? void 0,
-      summary: `Integration stopped early: ${reason}. Registered events are saved; rerun to resume.`
+      eventStatuses,
+      reportEvents: buildReportEvents(registered, eventStatuses, eventFailureReasons),
+      changedFiles: [...changedFiles2].sort(),
+      identifyWired,
+      applied: changedFiles2.size > 0,
+      summary: `Integration stopped early: ${reason}. Saved event progress will be verified on rerun.`
     };
   }
 }
-function freshState(input, runId) {
-  return {
-    version: 1,
-    apiBaseUrl: input.config.apiBaseUrl,
-    appId: input.session.appId,
-    repoFingerprint: input.repoFingerprint,
-    runId,
-    phase: "authorizing",
-    providerSessions: {},
-    designComplete: false,
-    tombstonedCodes: [],
-    clusters: [],
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
+function registeredFromSnapshot(events) {
+  return events.filter((event) => Boolean(event.anchorFile)).map((event) => ({
+    code: event.code,
+    name: event.name,
+    reasoning: event.reasoning,
+    eventId: event.id,
+    anchorFile: event.anchorFile.replaceAll("\\", "/"),
+    ...event.anchorSymbol ? { anchorSymbol: event.anchorSymbol } : {},
+    payloadSchema: event.payloadSchema ?? {}
+  }));
 }
-function rebuildRegistered(state, bootstrap) {
-  const byCode = new Map(bootstrap.snapshot.events.map((event) => [event.code, event]));
-  const registered = [];
-  for (const cluster of state.clusters) {
-    for (const placement of cluster.events) {
-      const event = byCode.get(placement.eventCode);
-      if (!event) {
-        continue;
-      }
-      registered.push({
-        code: event.code,
-        name: event.name,
-        reasoning: event.reasoning,
-        eventId: event.id,
-        anchorFile: placement.file,
-        anchorSymbol: placement.symbol,
-        payloadSchema: event.payloadSchema ?? {}
+function mergeRegistered(existing, added) {
+  const merged = new Map(existing.map((event) => [event.code, event]));
+  for (const event of added) {
+    merged.set(event.code, event);
+  }
+  return [...merged.values()].sort((a, b) => a.code.localeCompare(b.code));
+}
+async function reconcileProgress(repoPath, registered, prior, sink) {
+  const priorById = new Map((prior?.events ?? []).map((event) => [event.eventId, event]));
+  const statuses = /* @__PURE__ */ new Map();
+  for (const event of registered) {
+    const saved = priorById.get(event.eventId);
+    if (saved?.status === "unsupported") {
+      statuses.set(event.code, "unsupported");
+      continue;
+    }
+    const present = await fileContainsWrapper(repoPath, event.anchorFile, event.code);
+    const savedIntegrated = saved && saved.status !== "planned" && saved.status !== "failed";
+    const status = present ? savedIntegrated ? saved.status : "applied" : "planned";
+    statuses.set(event.code, status);
+    if (saved && saved.status !== status) {
+      sink.emit({
+        phase: "verifying",
+        file: event.anchorFile,
+        action: present ? `recovered ${event.code} from the current code` : `${event.code} is missing and will be integrated again`
       });
     }
   }
-  return registered;
+  return statuses;
 }
-function buildEvidence(registered, statuses, changedFiles2) {
-  const changed = new Set(changedFiles2);
-  return registered.map((event) => {
-    const status = statuses.get(event.code) ?? "planned";
-    const needsFile = status !== "planned" && status !== "unsupported" && status !== "failed";
-    const file = changed.has(event.anchorFile) ? event.anchorFile : changedFiles2[0];
-    return {
-      eventId: event.eventId,
-      eventCode: event.code,
-      ...needsFile && file ? { file } : {},
-      status
-    };
-  });
+async function fileContainsWrapper(repoPath, file, eventCode) {
+  try {
+    const path = safeRepoPath(repoPath, file);
+    const content = await readFile3(path, "utf8");
+    return content.includes(eventWrapperName(eventCode));
+  } catch {
+    return false;
+  }
 }
-async function completeRun(runs, runId, evidence, _statuses, changedFiles2, identifyWired, verificationStatus, verificationCommand2) {
-  await runs.completeRun(runId, {
-    changedFiles: changedFiles2,
-    identifyWired,
-    verificationStatus,
-    ...verificationCommand2 ? { verificationCommand: verificationCommand2 } : {},
-    events: evidence
-  });
+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 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 && identifyFound && sdkInitializationFound;
+}
+function safeRepoPath(repoPath, file) {
+  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;
 }
-function buildReportEvents(registered, statuses) {
+function buildEvidence(registered, statuses) {
+  return registered.map((event) => ({
+    eventId: event.eventId,
+    eventCode: event.code,
+    file: event.anchorFile,
+    status: statuses.get(event.code) ?? "planned"
+  }));
+}
+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";
@@ -2821,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" }
     };
   });
 }
@@ -2852,9 +3263,9 @@ import {
 
 // src/core/git.ts
 import { spawn as spawn3 } from "child_process";
-import { createHash as createHash4 } from "crypto";
-import { readFile as readFile2 } from "fs/promises";
-import { basename as basename2, join as join7 } from "path";
+import { createHash as createHash3 } from "crypto";
+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;
   if (!isRepo) return { isRepo: false };
@@ -2903,7 +3314,7 @@ async function revertToCheckpoint(repoPath, checkpoint) {
 async function repoFingerprint(repoPath) {
   const remote = await run(repoPath, ["remote", "get-url", "origin"]);
   const seed = remote.ok && remote.stdout.trim() ? normalizeRemote(remote.stdout.trim()) : `dir:${basename2(repoPath)}`;
-  return createHash4("sha256").update(seed).digest("hex").slice(0, 16);
+  return createHash3("sha256").update(seed).digest("hex").slice(0, 16);
 }
 function normalizeRemote(url) {
   return url.replace(/^git@([^:]+):/, "$1/").replace(/^https?:\/\//, "").replace(/\.git$/, "").replace(/\/+$/, "").toLowerCase();
@@ -2920,7 +3331,7 @@ async function scanWiredEvents(repoPath, files, eventTypes) {
   const contents = [];
   for (const file of files) {
     try {
-      contents.push({ file, content: await readFile2(join7(repoPath, file), "utf8") });
+      contents.push({ file, content: await readFile4(join5(repoPath, file), "utf8") });
     } catch {
       continue;
     }
@@ -2950,14 +3361,14 @@ function escapeRegExp(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function run(cwd, args) {
-  return new Promise((resolve4) => {
+  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) => resolve4({ ok: code === 0, stdout, stderr }));
-    child.on("error", () => resolve4({ ok: false, stdout, stderr }));
+    child.on("close", (code) => resolve7({ ok: code === 0, stdout, stderr }));
+    child.on("error", () => resolve7({ ok: false, stdout, stderr }));
   });
 }
 
@@ -3196,7 +3607,7 @@ function coverageNote(coverage) {
 }
 
 // src/core/toolPolicy.ts
-import { isAbsolute, relative, resolve } 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";
@@ -3292,9 +3703,9 @@ function isSecretPathLike(value) {
 }
 function isPathInsideRepo(pathValue, repoPath) {
   if (pathValue.includes("..")) return false;
-  const repoRoot = resolve(repoPath);
-  const candidate = isAbsolute(pathValue) ? resolve(pathValue) : resolve(repoRoot, pathValue);
-  const rel = relative(repoRoot, candidate);
+  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);
 }
 function evaluateReadLike(secretValues, repoPathValues, context) {
@@ -3417,9 +3828,9 @@ function normalizePathLike(value) {
   return stripOuterQuotes(value.trim()).replace(/\\/g, "/");
 }
 function repoRelativePath(pathValue, repoPath) {
-  const repoRoot = resolve(repoPath);
-  const candidate = isAbsolute(pathValue) ? resolve(pathValue) : resolve(repoRoot, pathValue);
-  return normalizePathLike(relative(repoRoot, candidate));
+  const repoRoot = resolve4(repoPath);
+  const candidate = isAbsolute(pathValue) ? resolve4(pathValue) : resolve4(repoRoot, pathValue);
+  return normalizePathLike(relative2(repoRoot, candidate));
 }
 function isSensitiveWritePath(pathValue, repoPath) {
   const parts = repoRelativePath(pathValue, repoPath).split("/").map((part) => stripOuterQuotes(part.trim().toLowerCase())).filter(Boolean);
@@ -4387,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(
@@ -4408,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: {
@@ -4421,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) {
@@ -4471,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 readFileSync3, statSync, writeFileSync as writeFileSync2 } from "fs";
-import { join as join8, resolve as resolve2, sep } from "path";
+import { readdirSync, readFileSync as readFileSync2, statSync, writeFileSync } from "fs";
+import { join as join6, resolve as resolve5, sep as sep4 } from "path";
 function jailedPath(cwd, candidate) {
-  const resolved = resolve2(cwd, candidate);
-  if (resolved !== cwd && !resolved.startsWith(cwd + sep)) {
+  const resolved = resolve5(cwd, candidate);
+  if (resolved !== cwd && !resolved.startsWith(cwd + sep4)) {
     throw new Error(`path ${candidate} escapes the repository`);
   }
   return resolved;
@@ -4507,7 +4940,7 @@ function fileTools(cwd, allowWrite) {
       },
       handler: async (input) => {
         const path = guardedPath(cwd, "Read", String(input.path ?? ""));
-        const content = readFileSync3(path, "utf8");
+        const content = readFileSync2(path, "utf8");
         return { content: content.slice(0, 4e4) };
       }
     },
@@ -4523,7 +4956,7 @@ function fileTools(cwd, allowWrite) {
       handler: async (input) => {
         const target9 = guardedPath(cwd, "Glob", String(input.path ?? "."));
         const entries = readdirSync(target9).filter((entry) => !isSecretPathLike(entry)).map((entry) => {
-          const kind = statSync(join8(target9, entry)).isDirectory() ? "dir" : "file";
+          const kind = statSync(join6(target9, entry)).isDirectory() ? "dir" : "file";
           return `${kind}:${entry}`;
         });
         return { entries: entries.slice(0, 500) };
@@ -4543,7 +4976,7 @@ function fileTools(cwd, allowWrite) {
         },
         handler: async (input) => {
           const path = guardedPath(cwd, "Write", String(input.path ?? ""));
-          writeFileSync2(path, String(input.content ?? ""));
+          writeFileSync(path, String(input.content ?? ""));
           return { ok: true };
         }
       },
@@ -4562,12 +4995,12 @@ function fileTools(cwd, allowWrite) {
         },
         handler: async (input) => {
           const path = guardedPath(cwd, "Edit", String(input.path ?? ""));
-          const content = readFileSync3(path, "utf8");
+          const content = readFileSync2(path, "utf8");
           const oldText = String(input.oldText ?? "");
           if (!content.includes(oldText)) {
             return { ok: false, reason: "oldText not found" };
           }
-          writeFileSync2(path, content.replace(oldText, String(input.newText ?? "")));
+          writeFileSync(path, content.replace(oldText, String(input.newText ?? "")));
           return { ok: true };
         }
       }
@@ -4577,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");
     }
@@ -4588,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)
       }
@@ -4601,43 +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) {
+    onRunReady(readyRunId, resumeSessionId) {
       runId = readyRunId;
+      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) => ({
@@ -4647,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 }
@@ -4663,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"
@@ -4710,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) {
+    onRunReady(runId, resumeSessionId) {
+      disabledProviders.clear();
       for (const provider of providers) {
-        provider.onRunReady?.(runId);
+        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);
     }
   };
 }
@@ -4729,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;
@@ -4768,16 +5337,7 @@ async function tryEngineFlow(options) {
     playbookSystemPrompt: playbook.systemPrompt,
     sink,
     callbacks: {
-      reviewEvents: async (proposed) => reviewEventsInTerminal(proposed, theme2),
-      confirmApply: async (patch, summaryLines) => {
-        p.note(summaryLines.join("\n"), "Integration result");
-        const lineCount = patch.split("\n").length;
-        const answer = await p.confirm({
-          message: `Apply these changes to your working tree? (${lineCount} patch lines)`,
-          initialValue: true
-        });
-        return answer === true;
-      }
+      reviewEvents: async (proposed) => reviewEventsInTerminal(proposed, theme2)
     }
   });
   if (result.kind === "wrong_mode") {
@@ -4827,7 +5387,7 @@ async function reviewEventsInTerminal(proposed, theme2) {
   });
   p.note(lines.join("\n\n"), `Proposed events (${proposed.length})`);
   const selection = await p.multiselect({
-    message: "Register these events? Deselect any you don't want.",
+    message: "Register and integrate these events? Deselect any you don't want.",
     options: proposed.map((event) => ({ value: event.code, label: event.code, hint: event.name })),
     initialValues: proposed.map((event) => event.code),
     required: false
@@ -5070,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((resolve4) => {
+  return new Promise((resolve7) => {
     const child = spawn4(command, { cwd: repoPath, shell: true, env: process.env });
     let out = "";
     const append = (d) => {
@@ -5081,11 +5641,11 @@ function runVerifyCommand(repoPath, command, opts = {}) {
     child.stderr?.on("data", append);
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
-      resolve4({ 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);
-      resolve4({
+      resolve7({
         ran: true,
         ok: code === 0,
         command,
@@ -5097,7 +5657,7 @@ function runVerifyCommand(repoPath, command, opts = {}) {
     });
     child.on("error", () => {
       clearTimeout(timer);
-      resolve4({ ran: true, ok: false, command, output: tail2(out), toolMissing: true });
+      resolve7({ ran: true, ok: false, command, output: tail2(out), toolMissing: true });
     });
   });
 }
@@ -5107,8 +5667,8 @@ function tail2(s) {
 }
 
 // src/core/version.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { dirname as dirname3, join as join9, parse } from "path";
+import { readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname3, join as join7, parse } from "path";
 import { fileURLToPath } from "url";
 var PACKAGE_NAME = "@whisperr/wizard";
 function packageVersion() {
@@ -5116,7 +5676,7 @@ function packageVersion() {
   const { root } = parse(dir);
   while (true) {
     try {
-      const pkg = JSON.parse(readFileSync4(join9(dir, "package.json"), "utf8"));
+      const pkg = JSON.parse(readFileSync3(join7(dir, "package.json"), "utf8"));
       if (pkg.name === PACKAGE_NAME && pkg.version) return pkg.version;
     } catch {
     }
@@ -5254,7 +5814,7 @@ function banner() {
 
 // src/cli.ts
 async function run2(options) {
-  const repoPath = resolve3(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."));