@whisperr/wizard 0.7.4 → 0.9.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 resolve7 } from "path";
 import * as p2 from "@clack/prompts";
 import open2 from "open";
 
@@ -1260,6 +1260,25 @@ async function pollFirstEvent(config, session, opts = {}) {
   return { received: false };
 }
 
+// src/core/version.ts
+import { readFileSync } from "fs";
+import { dirname, join as join2, parse } from "path";
+import { fileURLToPath } from "url";
+var PACKAGE_NAME = "@whisperr/wizard";
+function packageVersion() {
+  let dir = dirname(fileURLToPath(import.meta.url));
+  const { root } = parse(dir);
+  while (true) {
+    try {
+      const pkg = JSON.parse(readFileSync(join2(dir, "package.json"), "utf8"));
+      if (pkg.name === PACKAGE_NAME && pkg.version) return pkg.version;
+    } catch {
+    }
+    if (dir === root) return "0.0.0";
+    dir = dirname(dir);
+  }
+}
+
 // src/engine/output.ts
 function formatProgressLine(event) {
   const parts = [event.phase];
@@ -1308,8 +1327,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 readFile4 } from "fs/promises";
+import { basename, resolve as resolve4, sep as sep4 } from "path";
 
 // src/engine/bindings.ts
 function bindingsTargetFor(target9) {
@@ -1515,11 +1534,13 @@ 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;
+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,47 +1550,35 @@ 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)
       });
     }
   }
-  return clusters;
+  return fileSlices.map((slice) => {
+    const events = [...slice.events].sort((a, b) => a.eventCode.localeCompare(b.eventCode));
+    return {
+      id: clusterIdFor(
+        [slice.file],
+        events.map((event) => event.eventId || event.eventCode),
+        slice.position
+      ),
+      files: [slice.file],
+      events,
+      status: "pending",
+      attempts: 0
+    };
+  });
 }
-var TERMINAL_STATUSES = ["reviewed", "failed_resumable", "blocked"];
+var TERMINAL_STATUSES = ["verified", "reviewed", "failed_resumable", "blocked"];
 function nextPendingCluster(clusters) {
   return clusters.find((cluster) => cluster.status === "pending" || cluster.status === "editing");
 }
@@ -1587,8 +1596,10 @@ function transitionCluster(clusters, clusterId, status, note3) {
 }
 
 // src/engine/integrate.ts
-import { writeFile } from "fs/promises";
-import { join as join3 } from "path";
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile2, stat as stat2, writeFile } from "fs/promises";
+import { join as join4, resolve, sep } from "path";
+import { z } from "zod";
 
 // src/engine/budgets.ts
 var OVERFLOW_PATTERNS = [
@@ -1600,6 +1611,8 @@ var OVERFLOW_PATTERNS = [
 ];
 var TRANSIENT_PATTERNS = [
   /rate.?limit/i,
+  /quota/i,
+  /\b429\b/,
   /overloaded/i,
   /timeout/i,
   /timed out/i,
@@ -1629,10 +1642,15 @@ 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";
-import { join as join2 } from "path";
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join3 } from "path";
 var JS_TARGETS = /* @__PURE__ */ new Set(["web-js", "nextjs", "node", "react-native"]);
 function resolveVerifySteps(repoPath, target9) {
   if (target9 === "flutter") {
@@ -1646,7 +1664,10 @@ function resolveVerifySteps(repoPath, target9) {
     } else if (hasTsconfig(repoPath)) {
       steps.push({ kind: "typecheck", command: "npx", args: ["--no-install", "tsc", "--noEmit"] });
     }
-    if (steps.length === 0 && scripts.build) {
+    if (scripts.lint) {
+      steps.push({ kind: "lint", command: npmCommand(), args: ["run", "lint"] });
+    }
+    if (scripts.build) {
       steps.push({ kind: "build", command: npmCommand(), args: ["run", "build"] });
     }
     return steps;
@@ -1655,7 +1676,7 @@ function resolveVerifySteps(repoPath, target9) {
 }
 function packageScripts(repoPath) {
   try {
-    const parsed = JSON.parse(readFileSync(join2(repoPath, "package.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync2(join3(repoPath, "package.json"), "utf8"));
     return parsed.scripts ?? {};
   } catch {
     return {};
@@ -1663,7 +1684,7 @@ function packageScripts(repoPath) {
 }
 function hasTsconfig(repoPath) {
   try {
-    readFileSync(join2(repoPath, "tsconfig.json"), "utf8");
+    readFileSync2(join3(repoPath, "tsconfig.json"), "utf8");
     return true;
   } catch {
     return false;
@@ -1673,7 +1694,7 @@ function npmCommand() {
   return process.platform === "win32" ? "npm.cmd" : "npm";
 }
 function runVerifyStep(cwd, step, timeoutMs = 3e5) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve8) => {
     const child = spawn(step.command, step.args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
     let output = "";
     const capture = (chunk) => {
@@ -1688,11 +1709,11 @@ function runVerifyStep(cwd, step, timeoutMs = 3e5) {
     }, timeoutMs);
     child.on("error", (error) => {
       clearTimeout(timer);
-      resolve6({ ...step, ok: false, output: String(error) });
+      resolve8({ ...step, ok: false, output: String(error) });
     });
     child.on("close", (exitCode) => {
       clearTimeout(timer);
-      resolve6({ ...step, ok: exitCode === 0, output });
+      resolve8({ ...step, ok: exitCode === 0, output });
     });
   });
 }
@@ -1703,21 +1724,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";
@@ -1740,34 +1746,116 @@ var REVIEW_CHECKLIST = [
 ].join("\n");
 async function writeBindingsModule(worktree, target9, registered) {
   const bindings = generateBindings(target9, registered);
-  await writeFile(join3(worktree.path, bindings.relativePath), bindings.content);
+  await writeFile(join4(worktree.path, bindings.relativePath), bindings.content);
   return bindings;
 }
-async function runSdkSetupPass(deps, bindings) {
+async function runSdkSetupPass(deps, bindings, validate) {
   deps.sink.emit({ phase: "binding", action: "installing SDK and wiring identify()" });
-  const outcome = await deps.provider.invoke(
-    {
-      role: "edit",
-      systemPrompt: deps.playbookSystemPrompt,
-      userPrompt: [
-        "CORE SETUP for the Whisperr SDK in this repository. Do exactly this, then stop:",
-        "1. Add and install the Whisperr SDK dependency for this stack.",
-        `2. Initialize it once at app startup with API key ${deps.ingestion.apiKey} and base URL ${deps.ingestion.baseUrl}.`,
-        `3. The generated bindings module at ${bindings.relativePath} queues events until bound.`,
-        `   ${bindings.bindInstruction}`,
-        "   You may move the generated file to the idiomatic source directory (fix imports), but never edit its generated content.",
-        "4. Wire identify() for the END USER (paying customer) at login success and session restore; reset() on logout.",
-        "   Never instrument admin/staff/operator paths.",
-        "Do not instrument product events yet. Do not run builds."
-      ].join("\n"),
-      tools: [],
-      allowRepoWrite: true,
-      cwd: deps.worktree.path
-    },
-    deps.models.edit,
+  const allowedFiles = await sdkSetupFiles(deps.worktree.path, deps.survey, bindings.relativePath);
+  const invocation = {
+    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:",
+      "1. Add and install the Whisperr SDK dependency for this stack.",
+      `2. Initialize it once at app startup with API key ${deps.ingestion.apiKey} and base URL ${deps.ingestion.baseUrl}.`,
+      `3. The deterministic bindings module at ${bindings.relativePath} queues events until bound.`,
+      `   ${bindings.bindInstruction}`,
+      "   Never edit the generated bindings content.",
+      "4. Wire identify() for the END USER (paying customer) at login success AND session restoration.",
+      "5. Wire reset() at every end-user logout anchor.",
+      "Never instrument admin/staff/operator paths. Do not insert any product event calls. Do not run builds.",
+      "",
+      `Saved stack and identity anchors:
+${JSON.stringify({
+        stack: deps.survey?.stack,
+        identifyAnchors: deps.survey?.identifyAnchors ?? [],
+        logoutAnchors: deps.survey?.logoutAnchors ?? []
+      })}`,
+      "",
+      `You may access only:
+${allowedFiles.map((file) => `- ${file}`).join("\n")}`
+    ].join("\n"),
+    tools: [],
+    repositoryAccess: { mode: "sdk_setup", allowedFiles },
+    allowRepoWrite: true,
+    cwd: deps.worktree.path
+  };
+  let outcome = await deps.provider.invoke(
+    invocation,
+    modelConfigFor(deps.models, "sdk_setup", "edit"),
     (action) => deps.sink.emit({ phase: "binding", action })
   );
-  return outcome.kind === "completed";
+  const passesValidation = async () => {
+    if (!validate) return true;
+    try {
+      return await validate();
+    } catch {
+      return false;
+    }
+  };
+  let valid = outcome.kind === "completed" && await passesValidation();
+  if (!valid && deps.provider.invokeFallback) {
+    await deps.discardChanges();
+    await writeFile(join4(deps.worktree.path, bindings.relativePath), bindings.content);
+    deps.sink.emit({ phase: "binding", action: "Opus setup rolled back; retrying with Sol" });
+    outcome = await deps.provider.invokeFallback(
+      { ...invocation, sessionKey: "sdk_setup:sol" },
+      modelConfigFor(deps.models, "repair", "edit"),
+      (action) => deps.sink.emit({ phase: "binding", action })
+    );
+    valid = outcome.kind === "completed" && await passesValidation();
+  }
+  return valid;
+}
+async function sdkSetupFiles(repoPath, survey, bindingsFile) {
+  const candidates = /* @__PURE__ */ new Set([
+    bindingsFile,
+    ...survey?.stack.entryPoints ?? [],
+    ...survey?.identifyAnchors.map((anchor) => anchor.file) ?? [],
+    ...survey?.logoutAnchors.map((anchor) => anchor.file) ?? [],
+    ...survey?.featureAreas.flatMap(
+      (area) => area.files.filter(isSdkConfigurationFile)
+    ) ?? [],
+    "package.json",
+    "package-lock.json",
+    "pnpm-lock.yaml",
+    "yarn.lock",
+    "bun.lock",
+    "bun.lockb",
+    "pyproject.toml",
+    "requirements.txt",
+    "Pipfile",
+    "Package.swift",
+    "Podfile",
+    "pubspec.yaml",
+    "go.mod",
+    "composer.json",
+    "tsconfig.json",
+    "next.config.js",
+    "next.config.mjs",
+    "next.config.ts",
+    "vite.config.js",
+    "vite.config.ts",
+    "app.json",
+    "Info.plist"
+  ]);
+  const available = [];
+  for (const file of candidates) {
+    try {
+      if ((await stat2(join4(repoPath, file))).isFile()) available.push(file.replaceAll("\\", "/"));
+    } catch {
+    }
+  }
+  return [...new Set(available)].sort();
+}
+function isSdkConfigurationFile(file) {
+  const normalized = file.replaceAll("\\", "/");
+  return /(^|\/)(?:[^/]*config[^/]*|settings[^/]*|Info\.plist|AndroidManifest\.xml|Podfile|pubspec\.yaml)$/.test(
+    normalized
+  );
 }
 function clusterPrompt(cluster, registered, bindings) {
   const byCode = new Map(registered.map((event) => [event.code, event]));
@@ -1794,41 +1882,10 @@ function clusterPrompt(cluster, registered, bindings) {
     "Only edit the listed files (plus imports of the bindings module). Then stop."
   ].join("\n");
 }
-async function reviewCluster(deps, cluster, diff) {
-  const outcome = await deps.provider.invoke(
-    {
-      role: "review",
-      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."
-      ].join("\n"),
-      userPrompt: [
-        "Checklist:",
-        REVIEW_CHECKLIST,
-        "",
-        `Events expected: ${cluster.events.map((event) => event.eventCode).join(", ")}`,
-        "",
-        "Diff:",
-        diff.length > 6e4 ? diff.slice(0, 6e4) + "\n\u2026(truncated)" : diff
-      ].join("\n"),
-      tools: [],
-      allowRepoWrite: false,
-      cwd: deps.worktree.path
-    },
-    deps.models.review,
-    (action) => deps.sink.emit({ phase: "reviewing", action })
-  );
-  if (outcome.kind !== "completed") {
-    return { ok: false, notes: `review pass did not complete (${outcome.kind})` };
-  }
-  const ok = /verdict:\s*pass/i.test(outcome.text);
-  return { ok, notes: outcome.text.trim() };
-}
-async function runClusterIntegration(deps, initialClusters, clusterDiff) {
+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 +1901,46 @@ 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: [],
+      repositoryAccess: { mode: "cluster", allowedFiles: cluster.files },
+      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 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();
+      deps.sink.emit({
+        phase: "integrating",
+        cluster: { index, total },
+        action: "Terra attempt rolled back; retrying the clean cluster with Sol"
+      });
+      edit = await deps.provider.invokeFallback(
+        { ...invocation, task: "repair", sessionKey: `cluster_sol:${cluster.id}` },
+        modelConfigFor(deps.models, "repair", "edit"),
+        (action) => deps.sink.emit({ phase: "integrating", cluster: { index, total }, action })
+      );
+      structural = edit.kind === "completed" ? await structuralClusterCheck(deps.worktree.path, cluster) : { ok: false, notes: `Sol 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,40 +1948,9 @@ 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);
-      }
-    }
+    const finalStatus = "syntax_verified";
     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;
-    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);
     }
@@ -1911,19 +1961,281 @@ async function runClusterIntegration(deps, initialClusters, clusterDiff) {
   }
   return { clusters, eventStatuses };
 }
-async function finalizeIntegration(deps) {
-  const steps = resolveVerifySteps(deps.worktree.path, deps.target);
+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");
+      const wrapper = eventWrapperName(placement.eventCode);
+      if (!content.includes(wrapper)) {
+        missing.push(`${placement.eventCode}: wrapper call missing from ${placement.file}`);
+      }
+      if (content.includes("<<<<<<<") || content.includes(">>>>>>>")) {
+        missing.push(`${placement.eventCode}: merge conflict marker in ${placement.file}`);
+      }
+      if (/\.(?:ts|tsx|js|jsx|swift|dart|kt|java|go|py|php)$/.test(placement.file) && !balancedSourceDelimiters(content)) {
+        missing.push(`${placement.eventCode}: basic syntax delimiters are unbalanced in ${placement.file}`);
+      }
+      if (/\.(?:ts|tsx|js|jsx)$/.test(placement.file) && content.includes("WhisperrEvents.") && !/import[\s\S]{0,300}\bWhisperrEvents\b/.test(content)) {
+        missing.push(`${placement.eventCode}: WhisperrEvents import is missing from ${placement.file}`);
+      }
+    } catch {
+      missing.push(`${placement.eventCode}: cannot read ${placement.file}`);
+    }
+  }
+  return {
+    ok: missing.length === 0,
+    notes: missing.join("; ")
+  };
+}
+function balancedSourceDelimiters(content) {
+  const stack = [];
+  const pairs = { ")": "(", "]": "[", "}": "{" };
+  let quote = "";
+  let escaped = false;
+  let lineComment = false;
+  let blockComment = false;
+  for (let index = 0; index < content.length; index += 1) {
+    const char = content[index];
+    const next = content[index + 1] ?? "";
+    if (lineComment) {
+      if (char === "\n") lineComment = false;
+      continue;
+    }
+    if (blockComment) {
+      if (char === "*" && next === "/") {
+        blockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === quote) {
+        quote = "";
+      }
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      lineComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      blockComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === "'" || char === '"' || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "(" || char === "[" || char === "{") stack.push(char);
+    if (pairs[char] && stack.pop() !== pairs[char]) return false;
+  }
+  return stack.length === 0 && !quote && !blockComment;
+}
+async function reviewIntegratedFile(deps, file, events, sessionSuffix = "") {
+  let verdict;
+  let issues = [];
+  let notes = "";
+  const expectedCodes = new Set(events.map((event) => event.code));
+  const finishTool = {
+    name: "finish_review",
+    description: "Return the semantic verdict for this one file and its exact event contracts.",
+    inputSchema: {
+      verdict: z.enum(["pass", "fail"]),
+      issues: z.array(z.object({
+        eventCode: z.string(),
+        reason: z.string()
+      })).max(100),
+      notes: z.string().optional()
+    },
+    jsonSchema: {
+      type: "object",
+      properties: {
+        verdict: { type: "string", enum: ["pass", "fail"] },
+        issues: {
+          type: "array",
+          maxItems: 100,
+          items: {
+            type: "object",
+            properties: {
+              eventCode: { type: "string" },
+              reason: { type: "string" }
+            },
+            required: ["eventCode", "reason"]
+          }
+        },
+        notes: { type: "string" }
+      },
+      required: ["verdict", "issues"]
+    },
+    handler: async (input) => {
+      const rawIssues = Array.isArray(input.issues) ? input.issues : [];
+      const normalized = [];
+      for (const candidate of rawIssues) {
+        const issue = candidate;
+        const eventCode = String(issue.eventCode ?? "").trim();
+        const reason = String(issue.reason ?? "").trim();
+        if (!expectedCodes.has(eventCode) || !reason) {
+          return { ok: false, reason: "issues must name an expected event and a concrete reason" };
+        }
+        normalized.push({ eventCode, reason });
+      }
+      verdict = input.verdict === "pass" ? "pass" : "fail";
+      issues = normalized;
+      notes = String(input.notes ?? "").trim();
+      if (verdict === "pass" && issues.length > 0) {
+        return { ok: false, reason: "a passing verdict cannot include issues" };
+      }
+      return { ok: true };
+    }
+  };
+  const content = await readFile2(resolve(deps.worktree.path, file), "utf8");
+  const contracts = events.map((event) => ({
+    code: event.code,
+    reasoning: event.reasoning,
+    anchorFile: event.anchorFile,
+    anchorSymbol: event.anchorSymbol,
+    payloadSchema: event.payloadSchema
+  }));
+  const surveyAnchors = deps.survey?.integratableCallSites.filter((anchor) => anchor.file === file) ?? [];
+  const key = createHash2("sha256").update(file).digest("hex").slice(0, 12);
+  const outcome = await deps.provider.invoke(
+    {
+      role: "review",
+      task: "review",
+      sessionKey: `review:${key}${sessionSuffix}`,
+      systemPrompt: [
+        "You are the file-isolated semantic review pass for product analytics instrumentation.",
+        "Use finish_review exactly once. Do not browse the repository and do not edit files."
+      ].join("\n"),
+      userPrompt: [
+        "Validate every expected wrapper call for:",
+        "- placement after the confirmed outcome rather than intent",
+        "- deduplication, especially view/render/navigation events",
+        "- payload correctness against the exact contract",
+        "- absence of personal identifiers",
+        "- generated wrapper usage rather than raw track calls",
+        "",
+        `Event contracts:
+${JSON.stringify(contracts)}`,
+        `Saved survey anchors:
+${JSON.stringify(surveyAnchors)}`,
+        "",
+        `Expanded context for ${file}:
+${content.slice(0, 6e4)}`
+      ].join("\n"),
+      tools: [finishTool],
+      repositoryAccess: { mode: "review" },
+      allowRepoWrite: false,
+      cwd: deps.worktree.path
+    },
+    modelConfigFor(deps.models, "review", "review"),
+    (action) => deps.sink.emit({ phase: "reviewing", file, action })
+  );
+  if (outcome.kind !== "completed" || verdict === void 0) {
+    return {
+      ok: false,
+      issues: events.map((event) => ({
+        eventCode: event.code,
+        reason: `semantic review did not finish (${outcome.kind})`
+      })),
+      notes: `semantic review did not finish (${outcome.kind})`
+    };
+  }
+  return { ok: verdict === "pass" && issues.length === 0, issues, notes };
+}
+async function repairIntegratedFile(deps, file, events, review) {
+  const key = createHash2("sha256").update(file).digest("hex").slice(0, 12);
+  deps.sink.emit({ phase: "reviewing", file, action: "Sol is repairing semantic review failures" });
+  const outcome = await deps.provider.invoke(
+    {
+      role: "edit",
+      task: "repair",
+      sessionKey: `semantic_repair:${key}`,
+      systemPrompt: deps.playbookSystemPrompt,
+      userPrompt: [
+        `Repair only ${file}.`,
+        "Preserve the exact event set and generated wrappers. Do not add events or edit other files.",
+        "Correct placement timing, deduplication, payloads, PII safety, and wrapper usage as reported.",
+        `Issues:
+${JSON.stringify(review.issues)}`,
+        `Contracts:
+${JSON.stringify(events.map((event) => ({
+          code: event.code,
+          anchorSymbol: event.anchorSymbol,
+          payloadSchema: event.payloadSchema,
+          reasoning: event.reasoning
+        })))}`
+      ].join("\n"),
+      tools: [],
+      repositoryAccess: { mode: "repair", allowedFiles: [file] },
+      allowRepoWrite: true,
+      cwd: deps.worktree.path
+    },
+    modelConfigFor(deps.models, "repair", "edit"),
+    (action) => deps.sink.emit({ phase: "reviewing", file, action })
+  );
+  return outcome.kind === "completed";
+}
+async function finalizeIntegration(deps, verifyCwd = deps.worktree.path) {
+  const steps = resolveVerifySteps(verifyCwd, deps.target);
   deps.sink.emit({ phase: "verifying", action: "final verification pass" });
-  const results = await runVerifySteps(deps.worktree.path, steps);
+  const results = await runVerifySteps(verifyCwd, steps);
   return {
     results,
     status: runVerificationStatus(results),
     command: verificationCommand(results)
   };
 }
+async function repairVerification(deps, results, cycle = 1) {
+  const failed = results.filter((result) => !result.ok);
+  if (failed.length === 0) return true;
+  deps.sink.emit({ phase: "verifying", action: "Sol is repairing final verification failures" });
+  const allowedFiles = deps.allowedRepairFiles ?? deps.registered.map((event) => event.anchorFile);
+  const outcome = await deps.provider.invoke(
+    {
+      role: "edit",
+      task: "repair",
+      sessionKey: `final_repair:${cycle}`,
+      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: [],
+      repositoryAccess: { mode: "repair", allowedFiles },
+      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";
+import { createHash as createHash3 } from "crypto";
 var RunsApiError = class extends Error {
   constructor(message, status, code) {
     super(message);
@@ -1935,7 +2247,7 @@ var RunsApiError = class extends Error {
   code;
 };
 function itemIdempotencyKey(kind, code, extra = "") {
-  return createHash2("sha256").update(`${kind}
+  return createHash3("sha256").update(`${kind}
 ${code}
 ${extra}`).digest("hex").slice(0, 32);
 }
@@ -1997,6 +2309,20 @@ var RunsClient = class {
       payload
     }).then(normalizeItemWriteResult);
   }
+  persistSurveyArtifact(runId, content, metadata) {
+    return this.request(
+      "POST",
+      `/wizard/runs/${runId}/artifacts/survey`,
+      artifactRequest(content, metadata)
+    );
+  }
+  commitDesign(runId, content, events, metadata) {
+    return this.request(
+      "POST",
+      `/wizard/runs/${runId}/design/commit`,
+      { ...artifactRequest(content, metadata), events }
+    );
+  }
   completeRun(runId, completion) {
     return this.request(
       "POST",
@@ -2056,9 +2382,59 @@ function normalizeRunBootstrap(payload) {
       setupStatus: stringValue(snapshotSource.setupStatus),
       events
     },
-    ingestion: { apiKey: ingestion.apiKey, baseUrl: ingestion.baseUrl }
+    ingestion: { apiKey: ingestion.apiKey, baseUrl: ingestion.baseUrl },
+    artifacts: normalizeArtifacts(value.artifacts ?? snapshotSource.artifacts)
   };
 }
+function normalizeArtifacts(payload) {
+  if (!Array.isArray(payload)) return [];
+  return payload.flatMap((candidate) => {
+    const value = record(candidate);
+    const kind = value?.kind;
+    if (kind !== "survey" && kind !== "event_design" || typeof value?.contentHash !== "string" || !/^[0-9a-f]{64}$/.test(value.contentHash) || typeof value.model !== "string" || typeof value.createdAt !== "string") {
+      return [];
+    }
+    return [{
+      kind,
+      content: value.content,
+      contentHash: value.contentHash,
+      model: value.model,
+      ...typeof value.effort === "string" ? { effort: value.effort } : {},
+      ...typeof value.serviceTier === "string" ? { serviceTier: value.serviceTier } : {},
+      fastMode: value.fastMode === true,
+      ...typeof value.frozenAt === "string" ? { frozenAt: value.frozenAt } : {},
+      createdAt: value.createdAt
+    }];
+  });
+}
+function artifactRequest(content, metadata) {
+  return {
+    content,
+    contentHash: artifactContentHash(content),
+    model: metadata.model,
+    ...metadata.effort ? { effort: metadata.effort } : {},
+    ...metadata.serviceTier ? { serviceTier: metadata.serviceTier } : {},
+    fastMode: metadata.fastMode === true
+  };
+}
+function artifactContentHash(content) {
+  return createHash3("sha256").update(stableJSONStringify(content)).digest("hex");
+}
+function stableJSONStringify(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map(stableJSONStringify).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => left.localeCompare(right));
+    return `{${entries.map(
+      ([key, item]) => `${canonicalJSONString(key)}:${stableJSONStringify(item)}`
+    ).join(",")}}`;
+  }
+  return canonicalJSONString(value);
+}
+function canonicalJSONString(value) {
+  return JSON.stringify(value).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
 function normalizeIntegrationProgress(payload) {
   const value = record(payload);
   if (!value || !Array.isArray(value.changedFiles) || !Array.isArray(value.events)) {
@@ -2096,7 +2472,9 @@ function isSnapshotEvent(value) {
 }
 
 // src/engine/selection.ts
-import { z } from "zod";
+import { readFile as readFile3, stat as stat3 } from "fs/promises";
+import { resolve as resolve2, sep as sep2 } from "path";
+import { z as z2 } from "zod";
 
 // src/engine/prompts.ts
 var SURVEY_SYSTEM_PROMPT = [
@@ -2104,8 +2482,8 @@ var SURVEY_SYSTEM_PROMPT = [
   "Map the repository so a later pass can pick the product's important lifecycle events.",
   "You cannot edit files. Be fast and decisive; read entry points and feature roots, not every file.",
   "",
-  "Report, in plain markdown:",
-  "1. Stack: frameworks, package manager, app entry point file.",
+  "Finish by calling finish_survey exactly once. Its structured fields must contain:",
+  "1. Stack: frameworks, package manager, and app entry point files.",
   "2. Feature areas: name, root directory, and every relevant file containing",
   "   committed end-user actions or meaningful lifecycle transitions.",
   "3. The end-user identify() anchor: the login/signup success and session-restore call sites for the",
@@ -2114,7 +2492,8 @@ var SURVEY_SYSTEM_PROMPT = [
   "5. Exhaustive inventory of integratable call sites: file, function/symbol,",
   "   confirmed outcome or state transition, available non-PII payload fields,",
   "   and whether similar paths exist elsewhere.",
-  "Cite concrete file paths for every claim. Do not propose event names yet."
+  "Cite concrete repository-relative paths for every claim. Do not propose event names yet.",
+  "Never copy raw source code into the result."
 ].join("\n");
 function surveyUserPrompt(repoPath, onboardingContext) {
   return [
@@ -2122,13 +2501,13 @@ function surveyUserPrompt(repoPath, onboardingContext) {
     "",
     onboardingContext ? "Business context from onboarding:\n" + onboardingContext : "",
     "",
-    "Produce the survey report now."
+    "Complete the structured survey now."
   ].join("\n");
 }
 var SELECTION_SYSTEM_PROMPT = [
   "You are the event-selection pass of the Whisperr integration wizard.",
   "From the survey report and business context, choose the IMPORTANT product events this codebase",
-  "can actually emit, and propose each one with the propose_event tool.",
+  "can actually emit, and propose them with propose_event_batch calls.",
   "",
   "Rules \u2014 these are hard constraints:",
   "- Only propose an event with a concrete call site: a real file and function where the committed",
@@ -2156,11 +2535,11 @@ var SELECTION_SYSTEM_PROMPT = [
   "  government ids, usernames, passwords, device ids, or IP addresses. Domain metrics are welcome.",
   "- The end user is the paying customer/consumer. Never instrument admin, staff, or operator actions.",
   "",
-  "Call propose_event once per event. When done, call finish_selection with a one-line summary."
+  "Use only propose_event_batch for proposals. When done, call finish_event_design with a one-line summary."
 ].join("\n");
 function selectionUserPrompt(surveyReport, onboardingContext, existingEventCodes, rejectedCodes) {
   return [
-    "Survey report:",
+    "Saved structured survey artifact:",
     surveyReport,
     "",
     onboardingContext ? "Business context from onboarding:\n" + onboardingContext : "",
@@ -2271,38 +2650,108 @@ function validateProposedEvent(input, seen, rejected) {
   };
 }
 async function runSurvey(provider, models, repoPath, bootstrap, sink, resumeSessionId) {
-  sink.emit({ phase: "surveying", action: "mapping the repository" });
-  const outcome = await provider.invoke(
-    {
-      role: "survey",
-      systemPrompt: SURVEY_SYSTEM_PROMPT,
-      userPrompt: surveyUserPrompt(repoPath, renderOnboardingContext(bootstrap.onboardingContext)),
-      tools: [],
-      allowRepoWrite: false,
-      cwd: repoPath,
-      resumeSessionId
+  let survey;
+  let finished = false;
+  const finishSurvey = {
+    name: "finish_survey",
+    description: "Return the complete structured repository survey without raw source code.",
+    inputSchema: {
+      stack: z2.object({
+        frameworks: z2.array(z2.string()).max(30),
+        packageManager: z2.string().optional(),
+        entryPoints: z2.array(z2.string()).max(50)
+      }),
+      featureAreas: z2.array(z2.object({
+        name: z2.string(),
+        root: z2.string(),
+        files: z2.array(z2.string()).max(200)
+      })).max(200),
+      identifyAnchors: z2.array(z2.object({
+        file: z2.string(),
+        symbol: z2.string().optional(),
+        description: z2.string()
+      })).max(50),
+      logoutAnchors: z2.array(z2.object({
+        file: z2.string(),
+        symbol: z2.string().optional(),
+        description: z2.string()
+      })).max(50),
+      existingAnalytics: z2.array(z2.object({
+        file: z2.string(),
+        symbol: z2.string().optional(),
+        description: z2.string()
+      })).max(100),
+      integratableCallSites: z2.array(z2.object({
+        file: z2.string(),
+        symbol: z2.string().optional(),
+        description: z2.string(),
+        outcome: z2.string(),
+        payloadFields: z2.array(z2.string()).max(50),
+        similarPaths: z2.array(z2.string()).max(50)
+      })).max(500)
     },
-    models.survey,
+    jsonSchema: surveyJSONSchema(),
+    handler: async (input) => {
+      if (finished) {
+        return { ok: false, reason: "survey is already frozen" };
+      }
+      const normalized = normalizeSurveyArtifact(input);
+      if (!normalized) {
+        return { ok: false, reason: "survey fields or repository-relative paths are invalid" };
+      }
+      survey = normalized;
+      finished = true;
+      return { ok: true, callSites: normalized.integratableCallSites.length };
+    }
+  };
+  sink.emit({ phase: "surveying", action: "mapping the repository" });
+  const invocation = {
+    role: "survey",
+    task: "survey",
+    sessionKey: "survey",
+    systemPrompt: SURVEY_SYSTEM_PROMPT,
+    userPrompt: surveyUserPrompt(repoPath, renderOnboardingContext(bootstrap.onboardingContext)),
+    tools: [finishSurvey],
+    repositoryAccess: { mode: "survey" },
+    allowRepoWrite: false,
+    cwd: repoPath,
+    resumeSessionId
+  };
+  let outcome = await provider.invoke(
+    invocation,
+    modelConfigFor(models, "survey", "survey"),
     (action) => sink.emit({ phase: "surveying", action })
   );
-  return { report: outcome.kind === "completed" ? outcome.text : "", outcome };
+  if (outcome.kind === "completed" && !finished && provider.invokeFallback) {
+    survey = void 0;
+    finished = false;
+    sink.emit({ phase: "surveying", action: "Opus survey was invalid; retrying once with Sol" });
+    outcome = await provider.invokeFallback(
+      { ...invocation, sessionKey: "survey:sol_retry" },
+      modelConfigFor(models, "repair", "survey"),
+      (action) => sink.emit({ phase: "surveying", action })
+    );
+  }
+  return { survey, finished, outcome };
 }
-async function runSelection(provider, models, repoPath, bootstrap, surveyReport, rejectedCodes, sink, existingEventCodes = bootstrap.snapshot.events.map((event) => event.code)) {
+async function runSelection(provider, models, repoPath, bootstrap, survey, rejectedCodes, sink, existingEventCodes = bootstrap.snapshot.events.map((event) => event.code), recoveryCodes = []) {
   const proposed = [];
   const seen = /* @__PURE__ */ new Set();
   const rejected = new Set(rejectedCodes);
+  const existing = new Set(existingEventCodes.map(normalizeEventCode));
+  const recovery = new Set(recoveryCodes.map(normalizeEventCode));
   let summary = "";
   let finished = false;
   const proposeTool = {
     name: "propose_event",
     description: "Propose one important, concretely-anchored product event. Returns ok:true when accepted.",
     inputSchema: {
-      code: z.string().describe("lowercase snake_case event code"),
-      name: z.string().describe("short human-readable name"),
-      reasoning: z.string().describe("why this event matters for this business"),
-      anchorFile: z.string().describe("repository file where the committed action happens"),
-      anchorSymbol: z.string().optional().describe("function/symbol at the anchor"),
-      payloadSchema: z.record(z.string(), z.string()).optional().describe("important payload fields: name -> short description; no personal identifiers")
+      code: z2.string().describe("lowercase snake_case event code"),
+      name: z2.string().describe("short human-readable name"),
+      reasoning: z2.string().describe("why this event matters for this business"),
+      anchorFile: z2.string().describe("repository file where the committed action happens"),
+      anchorSymbol: z2.string().optional().describe("function/symbol at the anchor"),
+      payloadSchema: z2.record(z2.string(), z2.string()).optional().describe("important payload fields: name -> short description; no personal identifiers")
     },
     jsonSchema: {
       type: "object",
@@ -2321,6 +2770,9 @@ async function runSelection(provider, models, repoPath, bootstrap, surveyReport,
       required: ["code", "name", "reasoning", "anchorFile"]
     },
     handler: async (input) => {
+      if (finished) {
+        return { ok: false, reason: "event design is already frozen" };
+      }
       const candidate = {
         code: String(input.code ?? ""),
         name: String(input.name ?? ""),
@@ -2333,6 +2785,16 @@ async function runSelection(provider, models, repoPath, bootstrap, surveyReport,
       if (!validated.ok) {
         return { ok: false, reason: validated.reason };
       }
+      if (recovery.size > 0 && !recovery.has(validated.event.code)) {
+        return { ok: false, reason: `placement recovery cannot create event ${validated.event.code}` };
+      }
+      if (existing.has(validated.event.code) && !recovery.has(validated.event.code)) {
+        return { ok: false, reason: `event ${validated.event.code} is already registered` };
+      }
+      const anchorError = await validateAnchor(repoPath, validated.event);
+      if (anchorError) {
+        return { ok: false, reason: anchorError };
+      }
       seen.add(validated.event.code);
       proposed.push(validated.event);
       sink.emit({
@@ -2343,10 +2805,41 @@ 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: z2.array(z2.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.",
-    inputSchema: { summary: z.string().describe("one line on what was selected and why") },
+    name: "finish_event_design",
+    description: "Freeze the complete batch after every important event has been proposed.",
+    inputSchema: { summary: z2.string().describe("one line on what was selected and why") },
     jsonSchema: {
       type: "object",
       properties: { summary: { type: "string", description: "one line on what was selected and why" } },
@@ -2359,60 +2852,204 @@ async function runSelection(provider, models, repoPath, bootstrap, surveyReport,
     }
   };
   sink.emit({ phase: "designing", action: "selecting important events" });
-  const outcome = await provider.invoke(
-    {
-      role: "design",
-      systemPrompt: SELECTION_SYSTEM_PROMPT,
-      userPrompt: selectionUserPrompt(
-        surveyReport,
-        renderOnboardingContext(bootstrap.onboardingContext),
-        existingEventCodes,
-        rejectedCodes
-      ),
-      tools: [proposeTool, finishTool],
-      allowRepoWrite: false,
-      cwd: repoPath
-    },
-    models.design,
+  const invocation = {
+    role: "design",
+    task: "design",
+    sessionKey: "design",
+    systemPrompt: SELECTION_SYSTEM_PROMPT,
+    userPrompt: selectionUserPrompt(
+      JSON.stringify(survey),
+      renderOnboardingContext(bootstrap.onboardingContext),
+      existingEventCodes,
+      rejectedCodes
+    ),
+    tools: [proposeBatchTool, finishTool],
+    repositoryAccess: { mode: "none" },
+    allowRepoWrite: false,
+    cwd: repoPath
+  };
+  let outcome = await provider.invoke(
+    invocation,
+    modelConfigFor(models, "design", "design"),
     (action) => sink.emit({ phase: "designing", action })
   );
+  if (outcome.kind === "completed" && (!finished || proposed.length === 0) && provider.invokeFallback) {
+    proposed.length = 0;
+    seen.clear();
+    summary = "";
+    finished = false;
+    sink.emit({ phase: "designing", action: "Opus design was invalid; retrying once with Sol" });
+    outcome = await provider.invokeFallback(
+      { ...invocation, sessionKey: "design:sol_retry" },
+      modelConfigFor(models, "repair", "design"),
+      (action) => sink.emit({ phase: "designing", action })
+    );
+  }
   return {
     outcome: outcome.kind,
     finished,
     proposed,
     summary,
-    surveyReport,
+    survey,
     sessionId: outcome.sessionId
   };
 }
-async function registerApprovedEvents(runs, runId, approved, sink) {
-  const registered = [];
-  for (const event of approved) {
-    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;
+async function validateAnchor(repoPath, event) {
+  const root = resolve2(repoPath);
+  const path = resolve2(root, event.anchorFile);
+  if (path === root || !path.startsWith(root + sep2)) {
+    return `${event.code}: anchor escapes the repository`;
+  }
+  try {
+    const info = await stat3(path);
+    if (!info.isFile()) return `${event.code}: anchor is not a file`;
+    if (event.anchorSymbol) {
+      const content = await readFile3(path, "utf8");
+      if (!content.includes(event.anchorSymbol)) {
+        return `${event.code}: anchor symbol ${event.anchorSymbol} is not present in ${event.anchorFile}`;
       }
-      throw error;
     }
-    registered.push({ ...event, eventId: result.id || result.item?.id || "" });
-    sink.emit({ phase: "persisting", file: event.anchorFile, action: `registered ${event.code}` });
+  } catch {
+    return `${event.code}: anchor file ${event.anchorFile} does not exist`;
+  }
+  return void 0;
+}
+function surveyJSONSchema() {
+  const anchor = {
+    type: "object",
+    properties: {
+      file: { type: "string" },
+      symbol: { type: "string" },
+      description: { type: "string" }
+    },
+    required: ["file", "description"]
+  };
+  return {
+    type: "object",
+    properties: {
+      stack: {
+        type: "object",
+        properties: {
+          frameworks: { type: "array", items: { type: "string" }, maxItems: 30 },
+          packageManager: { type: "string" },
+          entryPoints: { type: "array", items: { type: "string" }, maxItems: 50 }
+        },
+        required: ["frameworks", "entryPoints"]
+      },
+      featureAreas: {
+        type: "array",
+        maxItems: 200,
+        items: {
+          type: "object",
+          properties: {
+            name: { type: "string" },
+            root: { type: "string" },
+            files: { type: "array", items: { type: "string" }, maxItems: 200 }
+          },
+          required: ["name", "root", "files"]
+        }
+      },
+      identifyAnchors: { type: "array", items: anchor, maxItems: 50 },
+      logoutAnchors: { type: "array", items: anchor, maxItems: 50 },
+      existingAnalytics: { type: "array", items: anchor, maxItems: 100 },
+      integratableCallSites: {
+        type: "array",
+        maxItems: 500,
+        items: {
+          ...anchor,
+          properties: {
+            ...anchor.properties,
+            outcome: { type: "string" },
+            payloadFields: { type: "array", items: { type: "string" }, maxItems: 50 },
+            similarPaths: { type: "array", items: { type: "string" }, maxItems: 50 }
+          },
+          required: ["file", "description", "outcome", "payloadFields", "similarPaths"]
+        }
+      }
+    },
+    required: [
+      "stack",
+      "featureAreas",
+      "identifyAnchors",
+      "logoutAnchors",
+      "existingAnalytics",
+      "integratableCallSites"
+    ]
+  };
+}
+function normalizeSurveyArtifact(input) {
+  const safePath = (value2) => {
+    if (typeof value2 !== "string") return void 0;
+    const normalized = value2.trim().replaceAll("\\", "/");
+    if (!normalized || normalized.startsWith("/") || /^[a-z]:/i.test(normalized) || normalized.split("/").some((part) => !part || part === "." || part === "..")) {
+      return void 0;
+    }
+    return normalized;
+  };
+  const stringList = (value2, max) => Array.isArray(value2) && value2.length <= max && value2.every((item) => typeof item === "string" && item.trim()) ? [...new Set(value2.map((item) => String(item).trim()))] : void 0;
+  const value = input;
+  const stack = value.stack;
+  const frameworks = stringList(stack?.frameworks, 30);
+  const entryPoints = stringList(stack?.entryPoints, 50);
+  if (!stack || !frameworks || !entryPoints || entryPoints.some((file) => !safePath(file))) {
+    return void 0;
   }
-  return registered;
+  const anchors = (raw, max) => {
+    if (!Array.isArray(raw) || raw.length > max) return void 0;
+    const result = [];
+    for (const item of raw) {
+      const row = item;
+      const file = safePath(row?.file);
+      const description = typeof row?.description === "string" ? row.description.trim() : "";
+      if (!file || !description) return void 0;
+      result.push({
+        file,
+        ...typeof row.symbol === "string" && row.symbol.trim() ? { symbol: row.symbol.trim() } : {},
+        description
+      });
+    }
+    return result;
+  };
+  if (!Array.isArray(value.featureAreas) || value.featureAreas.length > 200) return void 0;
+  const featureAreas = [];
+  for (const item of value.featureAreas) {
+    const row = item;
+    const root = safePath(row?.root);
+    const files = stringList(row?.files, 200);
+    if (typeof row?.name !== "string" || !row.name.trim() || !root || !files || files.some((file) => !safePath(file))) return void 0;
+    featureAreas.push({ name: row.name.trim(), root, files: files.map((file) => safePath(file)) });
+  }
+  const identifyAnchors = anchors(value.identifyAnchors, 50);
+  const logoutAnchors = anchors(value.logoutAnchors, 50);
+  const existingAnalytics = anchors(value.existingAnalytics, 100);
+  const baseCallSites = anchors(value.integratableCallSites, 500);
+  if (!identifyAnchors || !logoutAnchors || !existingAnalytics || !baseCallSites || !Array.isArray(value.integratableCallSites)) return void 0;
+  const integratableCallSites = [];
+  for (let index = 0; index < baseCallSites.length; index += 1) {
+    const row = value.integratableCallSites[index];
+    const outcome = typeof row.outcome === "string" ? row.outcome.trim() : "";
+    const payloadFields = stringList(row.payloadFields, 50);
+    const similarPaths = stringList(row.similarPaths, 50);
+    if (!outcome || !payloadFields || !similarPaths || similarPaths.some((file) => !safePath(file))) return void 0;
+    integratableCallSites.push({
+      ...baseCallSites[index],
+      outcome,
+      payloadFields,
+      similarPaths: similarPaths.map((file) => safePath(file))
+    });
+  }
+  return {
+    stack: {
+      frameworks,
+      ...typeof stack.packageManager === "string" && stack.packageManager.trim() ? { packageManager: stack.packageManager.trim() } : {},
+      entryPoints: entryPoints.map((file) => safePath(file))
+    },
+    featureAreas,
+    identifyAnchors,
+    logoutAnchors,
+    existingAnalytics,
+    integratableCallSites
+  };
 }
 function placementsFor(registered) {
   return registered.map((event) => ({
@@ -2428,7 +3065,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 as dirname2, join as join5, relative, resolve as resolve3, sep as sep3 } from "path";
 var WorktreeError = class extends Error {
   constructor(code, message) {
     super(message);
@@ -2438,7 +3075,7 @@ var WorktreeError = class extends Error {
   code;
 };
 function git(cwd, args) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve8) => {
     const child = spawn2("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
@@ -2448,8 +3085,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", () => resolve8({ ok: false, stdout, stderr: "git is not available" }));
+    child.on("close", (exitCode) => resolve8({ ok: exitCode === 0, stdout, stderr }));
   });
 }
 async function must(cwd, args) {
@@ -2460,8 +3097,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 = resolve3(repoPath, file);
+  if (path === repoPath || !path.startsWith(repoPath + sep3) || relative(repoPath, path).startsWith("..")) {
     throw new WorktreeError("git_failed", `unsafe progress file path: ${file}`);
   }
   return path;
@@ -2499,7 +3136,7 @@ async function createWorktree(repoPath, force = false, allowedDirtyFiles = []) {
     );
   }
   let baseRef = (await must(repoPath, ["rev-parse", "HEAD"])).trim();
-  const path = await mkdtemp(join4(tmpdir(), "whisperr-worktree-"));
+  const path = await mkdtemp(join5(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) {
@@ -2524,12 +3161,18 @@ async function worktreePatch(handle) {
   return must(handle.path, ["diff", "--cached", "--binary", handle.baseRef]);
 }
 async function applyPatchToRepo(handle, patch) {
+  return applyPatch(handle.repoPath, patch, false);
+}
+async function reversePatchInRepo(repoPath, patch) {
+  return applyPatch(repoPath, patch, true);
+}
+async function applyPatch(repoPath, patch, reverse) {
   if (patch.trim() === "") {
     return;
   }
-  await new Promise((resolve6, reject) => {
-    const child = spawn2("git", ["apply", "--whitespace=nowarn"], {
-      cwd: handle.repoPath,
+  await new Promise((resolve8, reject) => {
+    const child = spawn2("git", ["apply", ...reverse ? ["--reverse"] : [], "--whitespace=nowarn"], {
+      cwd: repoPath,
       stdio: ["pipe", "ignore", "pipe"]
     });
     let stderr = "";
@@ -2539,31 +3182,13 @@ async function applyPatchToRepo(handle, patch) {
     child.on("error", (error) => reject(new WorktreeError("git_failed", String(error))));
     child.on("close", (exitCode) => {
       if (exitCode === 0) {
-        resolve6();
+        resolve8();
       } else {
-        reject(new WorktreeError("git_failed", `git apply failed: ${stderr.trim()}`));
-      }
-    });
-    child.stdin.end(patch);
-  });
-}
-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;
-  }
-  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();
+        reject(new WorktreeError("git_failed", `git apply failed: ${stderr.trim()}`));
+      }
+    });
+    child.stdin.end(patch);
+  });
 }
 async function discardWorktreeChanges(handle) {
   await must(handle.path, ["reset", "--hard", handle.baseRef]);
@@ -2577,6 +3202,16 @@ async function removeWorktree(handle) {
 // src/engine/orchestrator.ts
 async function runEngine(input) {
   const runs = new RunsClient(input.config, input.session);
+  const phaseTimings = [];
+  let activePhase = "authorizing";
+  let phaseStartedAt = Date.now();
+  let timingsFinished = false;
+  const finishTimings = () => {
+    if (!timingsFinished) {
+      phaseTimings.push({ phase: activePhase, ms: Date.now() - phaseStartedAt });
+      timingsFinished = true;
+    }
+  };
   let bootstrap;
   try {
     bootstrap = await runs.createOrResumeRun({
@@ -2594,6 +3229,11 @@ async function runEngine(input) {
   const runId = bootstrap.run.id;
   input.provider.onRunReady?.(runId, bootstrap.run.modelConversationId);
   const patchPhase = async (phase, message) => {
+    if (phase !== activePhase) {
+      phaseTimings.push({ phase: activePhase, ms: Date.now() - phaseStartedAt });
+      activePhase = phase;
+      phaseStartedAt = Date.now();
+    }
     try {
       await runs.patchRun(runId, { phase, ...message ? { message } : {} });
     } catch {
@@ -2605,6 +3245,7 @@ async function runEngine(input) {
     } catch {
     }
   };
+  let survey = artifactContent(bootstrap, "survey");
   let registered;
   try {
     const projectEvents = bootstrap.snapshot.events.filter(
@@ -2617,17 +3258,24 @@ async function runEngine(input) {
         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
-      );
-      if (survey.outcome.kind !== "completed") {
-        await failRun(`survey ${survey.outcome.kind}`);
-        return { kind: "aborted", reason: `survey ${survey.outcome.kind}` };
+      if (!survey) {
+        await patchPhase("surveying");
+        const surveyRun = await runSurvey(
+          input.provider,
+          input.models,
+          input.repoPath,
+          bootstrap,
+          input.sink
+        );
+        if (surveyRun.outcome.kind !== "completed" || !surveyRun.finished || !surveyRun.survey) {
+          await failRun(`survey ${surveyRun.outcome.kind}`);
+          return { kind: "aborted", reason: `survey ${surveyRun.outcome.kind}` };
+        }
+        survey = surveyRun.survey;
+        const config2 = modelConfigForTask(input.models, "survey", "survey");
+        await runs.persistSurveyArtifact(runId, survey, modelMetadata(config2));
+      } else {
+        input.sink.emit({ phase: "surveying", action: "reusing the saved immutable survey" });
       }
       await patchPhase("designing");
       const recoverableCodes = new Set(missingPlacement.map((event) => event.code));
@@ -2637,13 +3285,14 @@ async function runEngine(input) {
         input.models,
         input.repoPath,
         bootstrap,
-        survey.report,
+        survey,
         [],
         input.sink,
-        existingCodes
+        existingCodes,
+        [...recoverableCodes]
       );
       if (!selection.finished) {
-        const reason = selection.outcome === "completed" ? "selection did not call finish_selection" : `selection ${selection.outcome}`;
+        const reason = selection.outcome === "completed" ? "design did not call finish_event_design" : `design ${selection.outcome}`;
         await failRun(reason);
         return { kind: "aborted", reason };
       }
@@ -2651,18 +3300,29 @@ async function runEngine(input) {
         await failRun("selection finished with no accepted events");
         return { kind: "aborted", reason: "selection finished with no accepted events" };
       }
-      const approved = await input.callbacks.reviewEvents(selection.proposed);
-      if (approved === null) {
-        await failRun("selection rejected by user");
-        return { kind: "aborted", reason: "selection rejected by user" };
-      }
-      if (approved.length === 0) {
-        await failRun("no events accepted for instrumentation");
-        return { kind: "aborted", reason: "no events accepted for instrumentation" };
+      if (recoverableCodes.size > 0 && (selection.proposed.length !== recoverableCodes.size || selection.proposed.some((event) => !recoverableCodes.has(event.code)))) {
+        throw new Error("placement recovery must cover the frozen event set exactly");
       }
-      await patchPhase("persisting", `registering ${approved.length} events`);
-      const newlyRegistered = await registerApprovedEvents(runs, runId, approved, input.sink);
-      registered = mergeRegistered(placed, newlyRegistered);
+      await patchPhase("persisting", `registering ${selection.proposed.length} events`);
+      const design = {
+        surveyHash: artifactContentHash(survey),
+        summary: selection.summary,
+        events: [...selection.proposed].sort((a, b) => a.code.localeCompare(b.code))
+      };
+      const config = modelConfigForTask(input.models, "design", "design");
+      const committed = await runs.commitDesign(
+        runId,
+        design,
+        design.events.map(eventRequest),
+        modelMetadata(config)
+      );
+      registered = registeredFromSnapshot(
+        committed.events.filter((event) => event.projectId === bootstrap.project.id)
+      );
+      input.sink.emit({
+        phase: "persisting",
+        action: `designed and registered ${selection.proposed.length} events`
+      });
       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(", ")}`);
@@ -2686,17 +3346,19 @@ 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();
+  let verificationStatus = "pending";
   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);
+  let identifyWired = prior?.identifyWired === true && await setupLooksPresent(input.repoPath, changedFiles2, survey);
   const progress = () => ({
     changedFiles: [...changedFiles2].sort(),
     identifyWired,
-    verificationStatus: "pending",
+    verificationStatus,
     events: buildEvidence(registered, eventStatuses)
   });
   const saveProgress = async () => {
@@ -2711,6 +3373,7 @@ async function runEngine(input) {
   }
   await patchPhase("binding");
   let worktree;
+  const ownedPatches = [];
   try {
     worktree = await createWorktree(
       input.repoPath,
@@ -2722,8 +3385,9 @@ async function runEngine(input) {
     await failRun(reason);
     return { kind: "aborted", reason };
   }
-  const checkpoint = async () => {
-    const patch = await worktreePatch(worktree);
+  const setupWorktree = worktree;
+  const checkpoint = async (handle, kind, eventCodes = []) => {
+    const patch = await worktreePatch(handle);
     if (patch.trim() === "") {
       return [];
     }
@@ -2732,102 +3396,351 @@ async function runEngine(input) {
       changedFiles2.add(file);
     }
     await saveProgress();
-    await applyPatchToRepo(worktree, patch);
-    await commitWorktreeCheckpoint(worktree);
+    await applyPatchToRepo(handle, patch);
+    ownedPatches.push({ patch, files, eventCodes, kind });
     return files;
   };
   try {
-    const bindings = await writeBindingsModule(worktree, input.target, registered);
+    const bindings = await writeBindingsModule(setupWorktree, input.target, registered);
     if (!identifyWired) {
+      const validateSetup = async () => {
+        if (await readFile4(resolve4(setupWorktree.path, bindings.relativePath), "utf8") !== bindings.content) {
+          return false;
+        }
+        const candidatePatch = await worktreePatch(setupWorktree);
+        if (patchAddsProductEvents(candidatePatch, bindings.relativePath, registered)) {
+          return false;
+        }
+        return setupLooksPresent(
+          setupWorktree.path,
+          new Set(patchFiles(candidatePatch)),
+          survey
+        );
+      };
       const setupCompleted = await runSdkSetupPass({
         provider: input.provider,
         models: input.models,
-        worktree,
+        worktree: setupWorktree,
         target: input.target,
         playbookSystemPrompt: input.playbookSystemPrompt,
         registered,
         ingestion: bootstrap.ingestion,
+        survey,
         sink: input.sink,
         saveClusters: () => {
         },
-        discardChanges: async () => discardWorktreeChanges(worktree),
+        discardChanges: async () => discardWorktreeChanges(setupWorktree),
         onClusterIntegrated: async () => {
         }
-      }, bindings);
+      }, bindings, validateSetup);
       if (!setupCompleted) {
-        throw new Error("SDK setup did not complete");
+        throw new Error("SDK setup did not complete or failed deterministic validation");
+      }
+      const setupPatch = await worktreePatch(setupWorktree);
+      const setupFiles = patchFiles(setupPatch);
+      if (!await setupLooksPresent(setupWorktree.path, new Set(setupFiles), survey)) {
+        throw new Error("SDK initialization, identify(), session restoration, or logout reset() could not be verified");
+      }
+      await checkpoint(setupWorktree, "setup");
+      identifyWired = await setupLooksPresent(input.repoPath, changedFiles2, survey);
+      if (!identifyWired) {
+        throw new Error("SDK initialization, bindings, identify(), and reset() could not be verified");
       }
-      await checkpoint();
-      identifyWired = true;
       await saveProgress();
     } else {
-      await checkpoint();
+      await checkpoint(setupWorktree, "setup");
     }
     const pending = registered.filter((event) => {
       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
-          );
-          verified.set(placement.eventCode, present ? status : "failed");
+    await patchPhase("integrating");
+    await removeWorktree(setupWorktree).catch(() => {
+    });
+    worktree = void 0;
+    const queue = [...clusters];
+    const active = /* @__PURE__ */ new Map();
+    const lockedFiles = /* @__PURE__ */ new Set();
+    let workerSequence = 0;
+    while (queue.length > 0 || active.size > 0) {
+      while (active.size < 4) {
+        const nextIndex = queue.findIndex((cluster2) => !lockedFiles.has(cluster2.files[0]));
+        if (nextIndex < 0) break;
+        const cluster = queue.splice(nextIndex, 1)[0];
+        const file = cluster.files[0];
+        lockedFiles.add(file);
+        const id2 = workerSequence++;
+        active.set(id2, runClusterWorker(input, bootstrap, registered, survey, changedFiles2, cluster));
+      }
+      if (active.size === 0) break;
+      const { id, result: worker } = await Promise.race(
+        [...active.entries()].map(async ([id2, task]) => ({ id: id2, result: await task }))
+      );
+      active.delete(id);
+      lockedFiles.delete(worker.cluster.files[0]);
+      const returned = worker.integration?.clusters[0];
+      let applied = false;
+      let failure = worker.error ?? returned?.note ?? "cluster patch could not be merged";
+      if (returned?.status === "verified" && worker.handle) {
+        const files = patchFiles(worker.patch);
+        const unexpected = files.filter((file) => !worker.cluster.files.includes(file));
+        if (unexpected.length === 0) {
+          try {
+            for (const file of files) changedFiles2.add(file);
+            await saveProgress();
+            await applyPatchToRepo(worker.handle, worker.patch);
+            ownedPatches.push({
+              patch: worker.patch,
+              files,
+              eventCodes: worker.cluster.events.map((event) => event.eventCode),
+              kind: "cluster"
+            });
+            applied = true;
+          } catch (error) {
+            failure = `serial patch merge failed: ${error instanceof Error ? error.message : String(error)}`;
+          }
+        } else {
+          failure = `cluster edited files outside its isolation boundary: ${unexpected.join(", ")}`;
         }
-        await checkpoint();
-        for (const placement of cluster.events) {
-          eventStatuses.set(
-            placement.eventCode,
-            verified.get(placement.eventCode) ?? "failed"
-          );
+      }
+      if (!applied && worker.cluster.events.length > 1) {
+        const singles = worker.cluster.events.map((event, index) => ({
+          id: clusterIdFor([event.file], [event.eventId || event.eventCode], index),
+          files: [event.file],
+          events: [event],
+          status: "pending",
+          attempts: 0
+        }));
+        queue.push(...singles);
+        input.sink.emit({
+          phase: "integrating",
+          file: worker.cluster.files[0],
+          action: "Sol could not finish the cluster; retrying each event independently"
+        });
+      } else {
+        for (const placement of worker.cluster.events) {
+          const status = applied ? "syntax_verified" : "failed";
+          eventStatuses.set(placement.eventCode, status);
+          if (!applied) eventFailureReasons.set(placement.eventCode, failure);
           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`
           });
         }
       }
-    };
-    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);
-      }
+      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("reviewing");
+    const reviewableByFile = groupEventsByFile(registered.filter(
+      (event) => eventStatuses.get(event.code) === "syntax_verified"
+    ));
+    if (reviewableByFile.size > 0) {
+      const reviewWorktree = await createWorktree(
+        input.repoPath,
+        input.force ?? false,
+        [...changedFiles2]
       );
+      const reviewDeps = integrationDeps(
+        input,
+        bootstrap,
+        registered,
+        survey,
+        reviewWorktree,
+        [...changedFiles2]
+      );
+      const reviews = await mapLimit(
+        [...reviewableByFile.entries()],
+        2,
+        async ([file, events]) => ({
+          file,
+          events,
+          review: await reviewIntegratedFile(reviewDeps, file, events)
+        })
+      );
+      await removeWorktree(reviewWorktree).catch(() => {
+      });
+      for (const reviewed of reviews) {
+        if (reviewed.review.ok) {
+          for (const event of reviewed.events) eventStatuses.set(event.code, "reviewed");
+          await saveProgress();
+          continue;
+        }
+        const repairWorktree = await createWorktree(
+          input.repoPath,
+          input.force ?? false,
+          [...changedFiles2]
+        );
+        const repairDeps = integrationDeps(
+          input,
+          bootstrap,
+          registered,
+          survey,
+          repairWorktree,
+          [...changedFiles2]
+        );
+        const repaired = await repairIntegratedFile(
+          repairDeps,
+          reviewed.file,
+          reviewed.events,
+          reviewed.review
+        );
+        const reviewCluster = {
+          id: clusterIdFor([reviewed.file], reviewed.events.map((event) => event.eventId)),
+          files: [reviewed.file],
+          events: placementsFor(reviewed.events),
+          status: "verified",
+          attempts: 1
+        };
+        const structural = repaired ? await structuralClusterCheck(repairWorktree.path, reviewCluster) : { ok: false, notes: "Sol repair did not complete" };
+        const recheck = structural.ok ? await reviewIntegratedFile(repairDeps, reviewed.file, reviewed.events, ":recheck") : { ok: false, issues: [], notes: structural.notes };
+        const repairPatch = await worktreePatch(repairWorktree);
+        const repairFiles = patchFiles(repairPatch);
+        if (repaired && structural.ok && recheck.ok && repairFiles.every((file) => file === reviewed.file)) {
+          for (const file of repairFiles) changedFiles2.add(file);
+          await saveProgress();
+          await applyPatchToRepo(repairWorktree, repairPatch);
+          ownedPatches.push({
+            patch: repairPatch,
+            files: repairFiles,
+            eventCodes: reviewed.events.map((event) => event.code),
+            kind: "semantic"
+          });
+          for (const event of reviewed.events) eventStatuses.set(event.code, "reviewed");
+        } else {
+          const reasons = reviewed.review.issues.map((issue) => issue.reason).join("; ") || recheck.notes || structural.notes;
+          await rollbackFileEventPatches(
+            input.repoPath,
+            reviewed.file,
+            ownedPatches
+          );
+          for (const event of reviewed.events) {
+            eventStatuses.set(event.code, "failed");
+            eventFailureReasons.set(event.code, reasons.slice(0, 500));
+          }
+        }
+        await removeWorktree(repairWorktree).catch(() => {
+        });
+        await saveProgress();
+      }
     }
     await patchPhase("verifying");
-    const finalVerify = await finalizeIntegration(deps);
+    let verificationWorktree = await createWorktree(
+      input.repoPath,
+      input.force ?? false,
+      [...changedFiles2]
+    );
+    let verificationDeps = integrationDeps(
+      input,
+      bootstrap,
+      registered,
+      survey,
+      verificationWorktree,
+      [...changedFiles2]
+    );
+    let finalVerify = await finalizeIntegration(verificationDeps, input.repoPath);
+    for (let cycle = 0; finalVerify.status === "failed" && cycle < 2; cycle += 1) {
+      const repaired = await repairVerification(verificationDeps, finalVerify.results, cycle + 1);
+      if (!repaired) break;
+      const repairPatch = await worktreePatch(verificationWorktree);
+      const repairFiles = patchFiles(repairPatch);
+      const allowedRepairFiles = new Set(verificationDeps.allowedRepairFiles ?? []);
+      const structural = await structuralRepairCheck(
+        verificationWorktree.path,
+        registered,
+        repairFiles
+      );
+      if (repairPatch.trim() === "" || repairFiles.some((file) => !allowedRepairFiles.has(file)) || !structural.ok) {
+        break;
+      }
+      for (const file of repairFiles) changedFiles2.add(file);
+      await saveProgress();
+      await applyPatchToRepo(verificationWorktree, repairPatch);
+      ownedPatches.push({
+        patch: repairPatch,
+        files: repairFiles,
+        eventCodes: registered.map((event) => event.code),
+        kind: "verification"
+      });
+      await removeWorktree(verificationWorktree).catch(() => {
+      });
+      finalVerify = await finalizeIntegration(verificationDeps, input.repoPath);
+      if (finalVerify.status === "failed" && cycle + 1 < 2) {
+        verificationWorktree = await createWorktree(
+          input.repoPath,
+          input.force ?? false,
+          [...changedFiles2]
+        );
+        verificationDeps = integrationDeps(
+          input,
+          bootstrap,
+          registered,
+          survey,
+          verificationWorktree,
+          [...changedFiles2]
+        );
+      }
+    }
+    verificationStatus = finalVerify.status;
+    if (finalVerify.status !== "passed") {
+      await removeWorktree(verificationWorktree).catch(() => {
+      });
+      await rollbackOwnedPatches(input.repoPath, ownedPatches);
+      changedFiles2.clear();
+      identifyWired = false;
+      for (const event of registered) {
+        eventStatuses.set(event.code, "failed");
+        eventFailureReasons.set(
+          event.code,
+          `final verification ${finalVerify.status}${finalVerify.command ? `: ${finalVerify.command}` : ""}`
+        );
+      }
+      await saveProgress();
+      throw new Error(`final verification ${finalVerify.status} after two Sol repair cycles`);
+    }
+    await removeWorktree(verificationWorktree).catch(() => {
+    });
+    identifyWired = await setupLooksPresent(input.repoPath, changedFiles2, survey);
+    if (!identifyWired) {
+      await rollbackOwnedPatches(input.repoPath, ownedPatches);
+      changedFiles2.clear();
+      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, identify(), and logout reset() must be present before completion");
+    }
+    for (const event of registered) {
+      if (eventStatuses.get(event.code) === "reviewed") {
+        eventStatuses.set(event.code, "build_verified");
+      }
+    }
+    await saveProgress();
+    const failures = registered.filter((event) => eventStatuses.get(event.code) !== "build_verified");
+    if (failures.length > 0) {
+      const reason = `${failures.length} event${failures.length === 1 ? "" : "s"} could not be verified`;
+      await failRun(reason);
+      finishTimings();
+      return {
+        kind: "partial",
+        runId,
+        registered,
+        eventStatuses,
+        reportEvents: buildReportEvents(registered, eventStatuses, eventFailureReasons),
+        changedFiles: [...changedFiles2].sort(),
+        identifyWired,
+        applied: changedFiles2.size > 0,
+        summary: summarize(registered, eventStatuses).join("\n"),
+        verificationStatus,
+        phaseTimings,
+        modelRoutes: modelRoutes(input.models)
+      };
+    }
     await patchPhase("reporting");
     await runs.completeRun(runId, {
       changedFiles: [...changedFiles2].sort(),
@@ -2836,38 +3749,194 @@ async function runEngine(input) {
       ...finalVerify.command ? { verificationCommand: finalVerify.command } : {},
       events: buildEvidence(registered, eventStatuses)
     });
-    await removeWorktree(worktree).catch(() => {
+    if (worktree) await removeWorktree(worktree).catch(() => {
     });
     const summaryLines = summarize(registered, eventStatuses);
-    const hasFailures = [...eventStatuses.values()].some((status) => status === "failed");
+    finishTimings();
     return {
-      kind: hasFailures ? "partial" : "completed",
+      kind: "completed",
       runId,
       registered,
       eventStatuses,
-      reportEvents: buildReportEvents(registered, eventStatuses),
+      reportEvents: buildReportEvents(registered, eventStatuses, eventFailureReasons),
       changedFiles: [...changedFiles2].sort(),
       identifyWired,
       applied: changedFiles2.size > 0,
-      summary: summaryLines.join("\n")
+      summary: summaryLines.join("\n"),
+      verificationStatus,
+      phaseTimings,
+      modelRoutes: modelRoutes(input.models)
     };
   } 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(() => {
+    if (worktree) await removeWorktree(worktree).catch(() => {
     });
+    finishTimings();
     return {
       kind: "partial",
       runId,
       registered,
       eventStatuses,
-      reportEvents: buildReportEvents(registered, 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.`
+      summary: `Integration stopped early: ${reason}. Saved event progress will be verified on rerun.`,
+      verificationStatus,
+      phaseTimings,
+      modelRoutes: modelRoutes(input.models)
+    };
+  }
+}
+function artifactContent(bootstrap, kind) {
+  return bootstrap.artifacts.find((artifact) => artifact.kind === kind)?.content;
+}
+function modelConfigForTask(models, task, role) {
+  return models[task] ?? models[role];
+}
+function modelMetadata(config) {
+  return {
+    model: config.model,
+    ...config.effort ? { effort: config.effort } : {},
+    ...config.serviceTier ? { serviceTier: config.serviceTier } : {},
+    fastMode: config.fastMode === true
+  };
+}
+function eventRequest(event) {
+  return {
+    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 } : {}
+  };
+}
+async function runClusterWorker(input, bootstrap, registered, survey, changedFiles2, cluster) {
+  let handle;
+  try {
+    handle = await createWorktree(input.repoPath, input.force ?? false, [...changedFiles2]);
+    const deps = integrationDeps(input, bootstrap, registered, survey, handle, [...changedFiles2]);
+    const integration = await runClusterIntegration(
+      deps,
+      [cluster],
+      async () => worktreePatch(handle)
+    );
+    return {
+      cluster,
+      handle,
+      integration,
+      patch: await worktreePatch(handle)
+    };
+  } catch (error) {
+    return {
+      cluster,
+      handle,
+      patch: "",
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function integrationDeps(input, bootstrap, registered, survey, worktree, allowedRepairFiles) {
+  return {
+    provider: input.provider,
+    models: input.models,
+    worktree,
+    target: input.target,
+    playbookSystemPrompt: input.playbookSystemPrompt,
+    registered,
+    ingestion: bootstrap.ingestion,
+    survey,
+    allowedRepairFiles: allowedRepairFiles.filter(
+      (file) => file !== generateBindings(input.target, registered).relativePath
+    ),
+    sink: input.sink,
+    saveClusters: () => {
+    },
+    discardChanges: async () => discardWorktreeChanges(worktree),
+    onClusterIntegrated: async () => {
+    }
+  };
+}
+function groupEventsByFile(events) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const current = grouped.get(event.anchorFile) ?? [];
+    current.push(event);
+    grouped.set(event.anchorFile, current);
+  }
+  return grouped;
+}
+async function structuralRepairCheck(repoPath, events, files) {
+  const repairedFiles = new Set(files);
+  for (const [file, fileEvents] of groupEventsByFile(
+    events.filter((event) => repairedFiles.has(event.anchorFile))
+  )) {
+    const result = await structuralClusterCheck(repoPath, {
+      id: clusterIdFor([file], fileEvents.map((event) => event.eventId)),
+      files: [file],
+      events: placementsFor(fileEvents),
+      status: "verified",
+      attempts: 1
+    });
+    if (!result.ok) return result;
+  }
+  return { ok: true, notes: "" };
+}
+async function mapLimit(values, limit, operation) {
+  const results = new Array(values.length);
+  let nextIndex = 0;
+  const workers = Array.from({ length: Math.min(limit, values.length) }, async () => {
+    for (; ; ) {
+      const index = nextIndex++;
+      if (index >= values.length) return;
+      results[index] = await operation(values[index]);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+async function rollbackFileEventPatches(repoPath, file, patches) {
+  for (let index = patches.length - 1; index >= 0; index -= 1) {
+    const patch = patches[index];
+    if (patch.rolledBack || patch.kind !== "cluster" && patch.kind !== "semantic" || !patch.files.includes(file)) {
+      continue;
+    }
+    await reversePatchInRepo(repoPath, patch.patch);
+    patch.rolledBack = true;
+  }
+}
+async function rollbackOwnedPatches(repoPath, patches) {
+  for (let index = patches.length - 1; index >= 0; index -= 1) {
+    const patch = patches[index];
+    if (patch.rolledBack) continue;
+    await reversePatchInRepo(repoPath, patch.patch);
+    patch.rolledBack = true;
+  }
+}
+function modelRoutes(models) {
+  const result = {};
+  for (const task of ["survey", "design", "sdk_setup", "cluster_edit", "review", "repair"]) {
+    const role = task === "survey" || task === "design" ? task : task === "review" ? "review" : "edit";
+    const config = models[task] ?? models[role];
+    result[task] = {
+      model: config.model,
+      ...config.effort ? { effort: config.effort } : {},
+      serviceTier: config.fastMode ? "fast" : config.serviceTier ?? "default",
+      maxTurns: config.maxTurns,
+      maxMs: config.maxMs,
+      ...config.maxOutputTokens ? { maxOutputTokens: config.maxOutputTokens } : {}
     };
   }
+  return result;
 }
 function registeredFromSnapshot(events) {
   return events.filter((event) => Boolean(event.anchorFile)).map((event) => ({
@@ -2880,13 +3949,6 @@ function registeredFromSnapshot(events) {
     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();
@@ -2913,32 +3975,46 @@ 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 readFile4(path, "utf8");
     return content.includes(eventWrapperName(eventCode));
   } catch {
     return false;
   }
 }
-async function setupLooksPresent(repoPath, changedFiles2) {
+async function setupLooksPresent(repoPath, changedFiles2, survey) {
   let bindingsFound = false;
   let bindingCallFound = false;
+  let identifyFound = false;
+  let resetFound = false;
+  let sdkInitializationFound = false;
+  const contents = /* @__PURE__ */ new Map();
   for (const file of changedFiles2) {
     try {
-      const content = await readFile2(safeRepoPath(repoPath, file), "utf8");
+      const content = await readFile4(safeRepoPath(repoPath, file), "utf8");
+      contents.set(file, content);
       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);
+        resetFound ||= /\breset\s*\(/.test(content);
+        sdkInitializationFound ||= /whisperr/i.test(content) && /(initiali[sz]e|configure|client|setup)/i.test(content);
       }
     } catch {
     }
   }
-  return bindingsFound && bindingCallFound;
+  const identifyAnchorsCovered = (survey?.identifyAnchors ?? []).every(
+    (anchor) => /\bidentify\s*\(/.test(contents.get(anchor.file) ?? "")
+  );
+  const logoutAnchorsCovered = (survey?.logoutAnchors ?? []).every(
+    (anchor) => /\breset\s*\(/.test(contents.get(anchor.file) ?? "")
+  );
+  return bindingsFound && bindingCallFound && identifyFound && resetFound && sdkInitializationFound && identifyAnchorsCovered && logoutAnchorsCovered;
 }
 function safeRepoPath(repoPath, file) {
-  const root = resolve2(repoPath);
-  const path = resolve2(root, file);
-  if (path === root || !path.startsWith(root + sep2)) {
+  const root = resolve4(repoPath);
+  const path = resolve4(root, file);
+  if (path === root || !path.startsWith(root + sep4)) {
     throw new Error(`unsafe progress file path: ${file}`);
   }
   return path;
@@ -2951,7 +4027,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 +4035,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" }
     };
   });
 }
@@ -2979,6 +4055,21 @@ function patchFiles(patch) {
   }
   return [...files];
 }
+function patchAddsProductEvents(patch, bindingsFile, events) {
+  const wrappers = events.map((event) => eventWrapperName(event.code));
+  let file = "";
+  for (const line of patch.split("\n")) {
+    const header = /^\+\+\+ b\/(.+)$/.exec(line);
+    if (header?.[1]) {
+      file = header[1];
+      continue;
+    }
+    if (file !== bindingsFile && line.startsWith("+") && !line.startsWith("+++") && wrappers.some((wrapper) => line.includes(wrapper))) {
+      return true;
+    }
+  }
+  return false;
+}
 
 // src/engine/providers/claude.ts
 import { createSdkMcpServer, query as query2, tool } from "@anthropic-ai/claude-agent-sdk";
@@ -2990,9 +4081,9 @@ 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 { basename as basename2, join as join5 } from "path";
+import { createHash as createHash4 } from "crypto";
+import { readFile as readFile5 } from "fs/promises";
+import { basename as basename2, join as join6 } from "path";
 async function takeCheckpoint(repoPath) {
   const isRepo = (await run(repoPath, ["rev-parse", "--is-inside-work-tree"])).ok;
   if (!isRepo) return { isRepo: false };
@@ -3041,7 +4132,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 createHash3("sha256").update(seed).digest("hex").slice(0, 16);
+  return createHash4("sha256").update(seed).digest("hex").slice(0, 16);
 }
 function normalizeRemote(url) {
   return url.replace(/^git@([^:]+):/, "$1/").replace(/^https?:\/\//, "").replace(/\.git$/, "").replace(/\/+$/, "").toLowerCase();
@@ -3058,7 +4149,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 readFile5(join6(repoPath, file), "utf8") });
     } catch {
       continue;
     }
@@ -3088,14 +4179,14 @@ function escapeRegExp(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function run(cwd, args) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve8) => {
     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) => resolve8({ ok: code === 0, stdout, stderr }));
+    child.on("error", () => resolve8({ ok: false, stdout, stderr }));
   });
 }
 
@@ -3334,7 +4425,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 resolve5 } 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 +4521,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 = resolve5(repoPath);
+  const candidate = isAbsolute(pathValue) ? resolve5(pathValue) : resolve5(repoRoot, pathValue);
   const rel = relative2(repoRoot, candidate);
   return rel === "" || !!rel && !rel.startsWith("..") && !isAbsolute(rel);
 }
@@ -3448,6 +4539,12 @@ function evaluateReadLike(secretValues, repoPathValues, context) {
         message: "blocked: reads must stay inside the target repository"
       };
     }
+    if (context.allowedFiles && !allowedPath(value, context)) {
+      return {
+        behavior: "deny",
+        message: "blocked: this task may only access its explicitly supplied repository files"
+      };
+    }
   }
   return { behavior: "allow" };
 }
@@ -3465,8 +4562,19 @@ function evaluateWrite(input, context) {
   if (isSensitiveWritePath(pathValue, context.repoPath)) {
     return { behavior: "deny", message: SENSITIVE_WRITE_DENIAL };
   }
+  if (context.allowedFiles && !allowedPath(pathValue, context)) {
+    return {
+      behavior: "deny",
+      message: "blocked: this task may only edit its explicitly supplied repository files"
+    };
+  }
   return { behavior: "allow" };
 }
+function allowedPath(pathValue, context) {
+  if (!context.allowedFiles) return true;
+  const relativePath = repoRelativePath(pathValue, context.repoPath);
+  return context.allowedFiles.has(relativePath);
+}
 function evaluateBash(input) {
   const command = firstString(input, ["command"]);
   if (!command) {
@@ -3555,8 +4663,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 = resolve5(repoPath);
+  const candidate = isAbsolute(pathValue) ? resolve5(pathValue) : resolve5(repoRoot, pathValue);
   return normalizePathLike(relative2(repoRoot, candidate));
 }
 function isSensitiveWritePath(pathValue, repoPath) {
@@ -4423,7 +5531,7 @@ async function runPass(opts) {
   }
   return { summary, costUsd, ok, maxedOut };
 }
-function buildToolPolicyHooks(repoPath, trustedTools) {
+function buildToolPolicyHooks(repoPath, trustedTools, allowedFiles) {
   return {
     PreToolUse: [
       {
@@ -4432,7 +5540,8 @@ function buildToolPolicyHooks(repoPath, trustedTools) {
             if (input.hook_event_name !== "PreToolUse") return { continue: true };
             const decision = evaluateToolUse(input.tool_name, toolInputRecord(input.tool_input), {
               repoPath,
-              trustedTools
+              trustedTools,
+              allowedFiles
             });
             if (decision.behavior === "allow") {
               return { continue: true };
@@ -4450,9 +5559,9 @@ function buildToolPolicyHooks(repoPath, trustedTools) {
     ]
   };
 }
-function createToolPermissionCallback(repoPath, trustedTools) {
+function createToolPermissionCallback(repoPath, trustedTools, allowedFiles) {
   return async (toolName, input, options) => {
-    const decision = evaluateToolUse(toolName, input, { repoPath, trustedTools });
+    const decision = evaluateToolUse(toolName, input, { repoPath, trustedTools, allowedFiles });
     return decision.behavior === "allow" ? { behavior: "allow", toolUseID: options.toolUseID } : {
       behavior: "deny",
       message: decision.message,
@@ -4519,14 +5628,19 @@ function short(s, max = 60) {
 
 // src/engine/providers/claude.ts
 var READ_ONLY_TOOLS2 = ["Read", "Glob", "Grep"];
-var EDIT_TOOLS = ["Read", "Edit", "Write", "Bash", "Glob", "Grep"];
+var CONSTRAINED_EDIT_TOOLS = ["Read", "Edit", "Write"];
+var SETUP_TOOLS = ["Read", "Edit", "Write", "Bash"];
 var FAST_MODE_MODELS = /* @__PURE__ */ new Set(["claude-opus-5", "claude-opus-4-8"]);
 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(
@@ -4536,16 +5650,28 @@ function createClaudeProvider(config, session) {
         })
       );
       const trustedTools = trustedEngineMcpTools(invocation.tools);
-      const allowedTools = [
-        ...invocation.allowRepoWrite ? EDIT_TOOLS : READ_ONLY_TOOLS2,
-        ...trustedTools
-      ];
+      const accessMode = invocation.repositoryAccess?.mode ?? (invocation.allowRepoWrite ? "repair" : "survey");
+      const repositoryTools = accessMode === "none" || accessMode === "review" ? [] : accessMode === "survey" ? READ_ONLY_TOOLS2 : accessMode === "sdk_setup" ? SETUP_TOOLS : CONSTRAINED_EDIT_TOOLS;
+      const allowedTools = [...repositoryTools, ...trustedTools];
+      const allowedFiles = invocation.repositoryAccess?.allowedFiles ? new Set(invocation.repositoryAccess.allowedFiles.map((file) => file.replaceAll("\\", "/"))) : void 0;
       let sessionId = invocation.resumeSessionId;
       let costUsd = 0;
       let turns = 0;
       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"}`,
+          `X-Whisperr-Wizard-Fallback: ${invocation.fallback ? "true" : "false"}`
+        ].filter(Boolean).join("\n");
         const response = query2({
           prompt: invocation.userPrompt,
           options: {
@@ -4556,12 +5682,17 @@ function createClaudeProvider(config, session) {
             ...roleConfig.effort ? { effort: roleConfig.effort } : {},
             tools: [...allowedTools],
             ...hostTools.length > 0 ? { mcpServers: { engine: createSdkMcpServer({ name: "engine", tools: hostTools }) } } : {},
-            hooks: buildToolPolicyHooks(invocation.cwd, trustedTools),
-            canUseTool: createToolPermissionCallback(invocation.cwd, trustedTools),
+            hooks: buildToolPolicyHooks(invocation.cwd, trustedTools, allowedFiles),
+            canUseTool: createToolPermissionCallback(invocation.cwd, trustedTools, allowedFiles),
             maxTurns: roleConfig.maxTurns,
-            ...supportsClaudeFastMode(roleConfig.model) ? { settings: { fastMode: true } } : {},
+            ...roleConfig.maxOutputTokens ? { taskBudget: { total: roleConfig.maxOutputTokens } } : {},
+            ...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,30 +5740,37 @@ 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 { readdirSync, readFileSync as readFileSync3, statSync, writeFileSync } from "fs";
+import { join as join7, resolve as resolve6, sep as sep5 } from "path";
 function jailedPath(cwd, candidate) {
-  const resolved = resolve4(cwd, candidate);
-  if (resolved !== cwd && !resolved.startsWith(cwd + sep3)) {
+  const resolved = resolve6(cwd, candidate);
+  if (resolved !== cwd && !resolved.startsWith(cwd + sep5)) {
     throw new Error(`path ${candidate} escapes the repository`);
   }
   return resolved;
 }
-function guardedPath(cwd, toolName, candidate) {
+function guardedPath(cwd, toolName, candidate, allowedFiles) {
   const path = jailedPath(cwd, candidate);
   const decision = evaluateToolUse(
     toolName,
     toolName === "Glob" ? { path: candidate, pattern: "*" } : { file_path: candidate },
-    { repoPath: cwd }
+    { repoPath: cwd, allowedFiles }
   );
   if (decision.behavior === "deny") {
     throw new Error(decision.message);
   }
   return path;
 }
-function fileTools(cwd, allowWrite) {
+function fileTools(cwd, allowWrite, access = { mode: allowWrite ? "repair" : "survey" }) {
+  if (access.mode === "none" || access.mode === "review") {
+    return [];
+  }
+  const allowedFiles = access.allowedFiles ? new Set(access.allowedFiles.map((file) => file.replaceAll("\\", "/"))) : void 0;
   const tools = [
     {
       name: "read_file",
@@ -4644,8 +5782,8 @@ function fileTools(cwd, allowWrite) {
         required: ["path"]
       },
       handler: async (input) => {
-        const path = guardedPath(cwd, "Read", String(input.path ?? ""));
-        const content = readFileSync2(path, "utf8");
+        const path = guardedPath(cwd, "Read", String(input.path ?? ""), allowedFiles);
+        const content = readFileSync3(path, "utf8");
         return { content: content.slice(0, 4e4) };
       }
     },
@@ -4659,9 +5797,9 @@ function fileTools(cwd, allowWrite) {
         required: ["path"]
       },
       handler: async (input) => {
-        const target9 = guardedPath(cwd, "Glob", String(input.path ?? "."));
+        const target9 = guardedPath(cwd, "Glob", String(input.path ?? "."), allowedFiles);
         const entries = readdirSync(target9).filter((entry) => !isSecretPathLike(entry)).map((entry) => {
-          const kind = statSync(join6(target9, entry)).isDirectory() ? "dir" : "file";
+          const kind = statSync(join7(target9, entry)).isDirectory() ? "dir" : "file";
           return `${kind}:${entry}`;
         });
         return { entries: entries.slice(0, 500) };
@@ -4680,7 +5818,7 @@ function fileTools(cwd, allowWrite) {
           required: ["path", "content"]
         },
         handler: async (input) => {
-          const path = guardedPath(cwd, "Write", String(input.path ?? ""));
+          const path = guardedPath(cwd, "Write", String(input.path ?? ""), allowedFiles);
           writeFileSync(path, String(input.content ?? ""));
           return { ok: true };
         }
@@ -4699,8 +5837,8 @@ function fileTools(cwd, allowWrite) {
           required: ["path", "oldText", "newText"]
         },
         handler: async (input) => {
-          const path = guardedPath(cwd, "Edit", String(input.path ?? ""));
-          const content = readFileSync2(path, "utf8");
+          const path = guardedPath(cwd, "Edit", String(input.path ?? ""), allowedFiles);
+          const content = readFileSync3(path, "utf8");
           const oldText = String(input.oldText ?? "");
           if (!content.includes(oldText)) {
             return { ok: false, reason: "oldText not found" };
@@ -4715,8 +5853,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 +5865,12 @@ 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,
+            "X-Whisperr-Wizard-Fallback": sessionKey.startsWith("fallback:") ? "true" : "false"
+          }
         },
         body: JSON.stringify(body)
       }
@@ -4739,45 +5883,65 @@ 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 allTools = [...invocation.tools, ...fileTools(invocation.cwd, invocation.allowRepoWrite)];
+      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, invocation.repositoryAccess)
+      ];
       const toolsByName = new Map(allTools.map((tool2) => [tool2.name, tool2]));
       const toolDefs = allTools.map((tool2) => ({
         type: "function",
@@ -4786,7 +5950,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 +5971,10 @@ 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 } : {},
+            ...roleConfig.maxOutputTokens ? { max_output_tokens: roleConfig.maxOutputTokens } : {}
+          }, sessionKey, task);
           const items = response.output ?? [];
           const calls = items.filter(
             (item) => item.type === "function_call"
@@ -4849,18 +6020,115 @@ 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((resolve8) => this.waiting.push(resolve8));
+    }
+    this.active += 1;
+    try {
+      return await operation();
+    } finally {
+      this.active -= 1;
+      this.waiting.shift()?.();
+    }
+  }
+};
+function shouldFallback(outcome) {
+  return outcome.kind !== "completed";
+}
+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 disabledRoutes = /* @__PURE__ */ new Set();
+  const semaphoreFor = (key, concurrency) => {
+    let semaphore = semaphores.get(key);
+    if (!semaphore) {
+      semaphore = new Semaphore(concurrency ?? fallbackConcurrency);
+      semaphores.set(key, semaphore);
+    }
+    return semaphore;
+  };
+  const invocationRouteKey = (invocation, config) => `${invocation.task ?? invocation.role}:${config.model}`;
+  const routeFor = (invocation) => normalized.get(invocation.task ?? invocation.role) ?? normalized.get(invocation.role);
+  const call = (provider, concurrency, invocation, config, onProgress, key = invocationRouteKey(invocation, config)) => semaphoreFor(key, concurrency).run(() => provider.invoke(invocation, config, onProgress));
+  const fallbackInvocation = (invocation) => ({
+    ...invocation,
+    fallback: true,
+    sessionKey: `fallback:${invocation.sessionKey ?? invocation.task ?? invocation.role}`
+  });
   return {
     name: "routed",
     onRunReady(runId, resumeSessionId) {
+      disabledRoutes.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);
+      }
+      const routeKey = invocationRouteKey(invocation, config);
+      if (disabledRoutes.has(routeKey)) {
+        return call(
+          fallback,
+          fallbackConcurrency,
+          fallbackInvocation(invocation),
+          route.fallbackConfig ?? config,
+          onProgress,
+          `fallback:${routeKey}`
+        );
+      }
+      return call(route.provider, route.concurrency, invocation, config, onProgress).then(
+        async (outcome) => {
+          if (shouldDisableProvider(outcome)) {
+            disabledRoutes.add(routeKey);
+          }
+          if (!invocation.allowRepoWrite && shouldFallback(outcome)) {
+            onProgress(`${route.provider.name} unavailable; continuing with ${fallback.name}`);
+            return call(
+              fallback,
+              fallbackConcurrency,
+              fallbackInvocation(invocation),
+              route.fallbackConfig ?? config,
+              onProgress,
+              `fallback:${routeKey}`
+            );
+          }
+          return outcome;
+        }
+      );
+    },
+    invokeFallback(invocation, config, onProgress) {
+      return call(
+        fallback,
+        fallbackConcurrency,
+        fallbackInvocation(invocation),
+        config,
+        onProgress,
+        `fallback:${invocationRouteKey(invocation, config)}`
+      );
     }
   };
 }
@@ -4868,26 +6136,86 @@ 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 sol = "gpt-5.6-sol";
+  const opus = "claude-opus-5";
+  const opusOnly = process.env.WHISPERR_WIZARD_PRESET?.trim() === "claude-default" || config.offline === true;
+  if (opusOnly) {
+    const survey2 = { model: model("survey", opus), effort: "medium", fastMode: true, maxTurns: 30, maxMs: 5 * MINUTE };
+    const design2 = { model: model("design", opus), effort: "medium", fastMode: true, maxTurns: 80, maxMs: 20 * MINUTE };
+    const sdkSetup2 = { model: model("sdk_setup", opus), effort: "medium", fastMode: true, maxTurns: 60, maxMs: 12 * MINUTE };
+    const clusterEdit2 = { model: model("cluster_edit", opus), effort: "medium", fastMode: true, maxTurns: 60, maxMs: 12 * MINUTE };
+    const repair2 = { model: model("repair", opus), effort: "medium", fastMode: true, maxTurns: 30, maxMs: 8 * MINUTE };
+    const review2 = { model: model("review", opus), effort: "medium", fastMode: true, maxTurns: 30, maxMs: 8 * MINUTE };
+    return {
+      survey: survey2,
+      design: design2,
+      edit: sdkSetup2,
+      review: review2,
+      sdk_setup: sdkSetup2,
+      cluster_edit: clusterEdit2,
+      repair: repair2
+    };
+  }
+  const survey = { model: model("survey", opus), effort: "low", fastMode: true, maxTurns: 30, maxMs: 5 * MINUTE };
+  const design = { model: model("design", opus), effort: "low", fastMode: true, maxTurns: 20, maxMs: 5 * MINUTE };
+  const sdkSetup = { model: model("sdk_setup", opus), effort: "low", fastMode: true, maxTurns: 30, maxMs: 6 * 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: 20,
+    maxMs: 4 * MINUTE,
+    maxOutputTokens: 8e3
+  };
+  const repair = {
+    model: model("repair", sol),
+    effort: "medium",
+    serviceTier: "priority",
+    maxTurns: 30,
+    maxMs: 8 * MINUTE,
+    maxOutputTokens: 12e3
+  };
+  const review = {
+    model: model("review", sol),
+    effort: "medium",
+    serviceTier: "priority",
+    maxTurns: 8,
+    maxMs: 3 * MINUTE,
+    maxOutputTokens: 4e3
+  };
   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";
-  if (preset === "sol-design") {
-    const openai = createOpenAIProvider(config, session);
-    return createRoutedProvider({ survey: openai, design: openai, review: openai }, claude);
-  }
-  return claude;
+  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);
+  return createRoutedProvider({
+    survey: { provider: claude, concurrency: 3, fallbackConfig: models.repair },
+    design: { provider: claude, concurrency: 3, fallbackConfig: models.repair },
+    sdk_setup: { provider: claude, concurrency: 2, fallbackConfig: models.repair },
+    cluster_edit: { provider: openai, concurrency: 4, fallbackConfig: models.repair },
+    review: { provider: openai, concurrency: 2, fallbackConfig: models.review },
+    repair: { provider: openai, concurrency: 2, fallbackConfig: models.repair }
+  }, openai, 2);
 }
 async function tryEngineFlow(options) {
   const { repoPath, fingerprint, config, session, playbook, theme: theme2 } = options;
   const startedAt = Date.now();
+  const models = engineModelConfig(config);
   const sink = createProgressSink({
     json: false,
     isTTY: Boolean(process.stdout.isTTY),
@@ -4899,16 +6227,13 @@ async function tryEngineFlow(options) {
     config,
     session,
     provider: engineProvider(config, session),
-    models: engineModelConfig(config),
+    models,
     target: playbook.target.id,
     projectKind: ["node", "python", "php", "go", "express", "django", "fastapi", "laravel", "spring-boot"].includes(
       playbook.target.id
     ) ? "backend" : "frontend",
     playbookSystemPrompt: playbook.systemPrompt,
-    sink,
-    callbacks: {
-      reviewEvents: async (proposed) => reviewEventsInTerminal(proposed, theme2)
-    }
+    sink
   });
   if (result.kind === "wrong_mode") {
     return { handled: false, exitCode: 0 };
@@ -4925,11 +6250,18 @@ async function tryEngineFlow(options) {
     target: playbook.target.id,
     repo_fingerprint: fingerprint,
     identify_wired: result.identifyWired,
-    verified: null,
+    verified: result.verificationStatus === "passed" ? true : result.verificationStatus === "failed" ? false : null,
+    verification_status: result.verificationStatus,
     cost_usd: 0,
     duration_ms: Date.now() - startedAt,
     summary: result.summary.slice(0, 2e3),
     events: result.reportEvents,
+    wizard_version: packageVersion(),
+    planner_model: models.survey.model,
+    editor_model: models.cluster_edit?.model ?? models.edit.model,
+    effort: models.cluster_edit?.effort ?? models.edit.effort,
+    phase_timings: result.phaseTimings,
+    model_routes: result.modelRoutes,
     exit_class: result.kind === "completed" ? "engine_completed" : "engine_partial"
   });
   if (result.applied && result.registered.length > 0) {
@@ -4942,32 +6274,6 @@ async function tryEngineFlow(options) {
   }
   return { handled: true, exitCode: result.kind === "completed" ? 0 : 1 };
 }
-async function reviewEventsInTerminal(proposed, theme2) {
-  if (proposed.length === 0) {
-    return [];
-  }
-  const lines = proposed.map((event) => {
-    const fields = Object.keys(event.payloadSchema);
-    return [
-      `${theme2.bright(event.code)} \u2014 ${event.name}`,
-      `  ${event.reasoning}`,
-      `  anchor: ${event.anchorFile}${event.anchorSymbol ? ` (${event.anchorSymbol})` : ""}`,
-      fields.length > 0 ? `  payload: ${fields.join(", ")}` : "  payload: none"
-    ].join("\n");
-  });
-  p.note(lines.join("\n\n"), `Proposed events (${proposed.length})`);
-  const selection = await p.multiselect({
-    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
-  });
-  if (p.isCancel(selection)) {
-    return null;
-  }
-  const chosen = new Set(selection);
-  return proposed.filter((event) => chosen.has(event.code));
-}
 
 // src/core/opportunities.ts
 function normalizeCode(value) {
@@ -5200,7 +6506,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((resolve8) => {
     const child = spawn4(command, { cwd: repoPath, shell: true, env: process.env });
     let out = "";
     const append = (d) => {
@@ -5211,11 +6517,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 });
+      resolve8({ ran: true, ok: false, command, output: tail2(out), timedOut: true });
     }, timeoutMs);
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve6({
+      resolve8({
         ran: true,
         ok: code === 0,
         command,
@@ -5227,7 +6533,7 @@ function runVerifyCommand(repoPath, command, opts = {}) {
     });
     child.on("error", () => {
       clearTimeout(timer);
-      resolve6({ ran: true, ok: false, command, output: tail2(out), toolMissing: true });
+      resolve8({ ran: true, ok: false, command, output: tail2(out), toolMissing: true });
     });
   });
 }
@@ -5236,25 +6542,6 @@ function tail2(s) {
   return t.length > MAX_OUTPUT ? `\u2026${t.slice(-MAX_OUTPUT)}` : t;
 }
 
-// src/core/version.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname4, join as join7, parse } from "path";
-import { fileURLToPath } from "url";
-var PACKAGE_NAME = "@whisperr/wizard";
-function packageVersion() {
-  let dir = dirname4(fileURLToPath(import.meta.url));
-  const { root } = parse(dir);
-  while (true) {
-    try {
-      const pkg = JSON.parse(readFileSync3(join7(dir, "package.json"), "utf8"));
-      if (pkg.name === PACKAGE_NAME && pkg.version) return pkg.version;
-    } catch {
-    }
-    if (dir === root) return "0.0.0";
-    dir = dirname4(dir);
-  }
-}
-
 // src/core/gapreport.ts
 function buildGapReport(input) {
   const outcomes = new Map(
@@ -5384,7 +6671,7 @@ function banner() {
 
 // src/cli.ts
 async function run2(options) {
-  const repoPath = resolve5(options.path ?? process.cwd());
+  const repoPath = resolve7(options.path ?? process.cwd());
   const config = resolveConfig(options);
   console.log(banner());
   p2.intro(theme.signal("Let's wire Whisperr into your app."));
@@ -5496,40 +6783,23 @@ Flutter is live today; ${theme.bright(
   }
   const tick = useIntegrationSpinner ? setInterval(updateIntegrationMessage, 1e3) : void 0;
   const additions = { proposed: 0, applied: [] };
-  const interactive = Boolean(process.stdout.isTTY && process.stdin.isTTY);
   const outcome = await runIntegrationAgent({
     repoPath,
     config,
     session,
     playbook: chosen.playbook,
     manifest,
-    // The plan is always shown — it's the last look at what's about to change
-    // in their code. It only becomes a question under --review-plan; the
-    // default run reads it out and keeps going.
+    // The plan is informational. Event selection is frozen automatically, so
+    // integration never pauses at a terminal approval prompt.
     async onPlanReady(plan) {
       if (useIntegrationSpinner) {
         spin.stop(theme.success("Placement plan ready"));
       }
       p2.note(renderPlacementPlan(plan), "Placement plan");
-      const placeEntries = plan.filter((entry) => entry.decision === "place");
-      let selectedEvents = placeEntries.map((entry) => entry.event);
-      if (config.reviewPlan && interactive && placeEntries.length) {
-        const selection = await p2.multiselect({
-          message: "Wire these events?",
-          options: placeEntries.map((entry) => ({
-            value: entry.event,
-            label: entry.event,
-            hint: `${entry.file ?? "unknown file"}@${entry.anchor ?? "unknown anchor"}`
-          })),
-          initialValues: selectedEvents,
-          required: false
-        });
-        selectedEvents = p2.isCancel(selection) ? [] : selection;
-      }
       if (useIntegrationSpinner) {
         spin.start(theme.bright("Continuing integration"));
       }
-      return filterEventPlan(plan, selectedEvents);
+      return plan;
     },
     async onOpportunitiesReady(raw) {
       if (useIntegrationSpinner) spin.stop(theme.success("Planning done"));
@@ -6097,12 +7367,6 @@ function formatDuration(ms) {
   const seconds = String(totalSeconds % 60).padStart(2, "0");
   return `${minutes}m${seconds}s`;
 }
-function filterEventPlan(plan, selectedEvents) {
-  const selected = new Set(selectedEvents);
-  return plan.map(
-    (entry) => entry.decision === "place" && !selected.has(entry.event) ? { ...entry, decision: "skip", reason: "Deselected in plan review." } : entry
-  );
-}
 function renderPlacementPlan(plan) {
   return plan.map((entry) => {
     if (entry.decision === "place") {
@@ -6228,7 +7492,6 @@ function printHelp() {
       `  ${theme.bright("Options")}`,
       "    --offline         Use a demo manifest, no account/browser needed",
       "    --force           Proceed without a clean git tree (no safe undo)",
-      "    --review-plan     Confirm the placement plan before anything is wired",
       "    --propose-only    Send new events/interventions for dashboard approval",
       "                      instead of adding them to your universe now",
       "    --strict-review   Review the finished diff with the deeper planner model",