@whisperr/wizard 0.5.4 → 0.7.0

package/dist/index.js

@@ -1,19 +1,18 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { readFileSync, realpathSync } from "fs";
-import { dirname as dirname2, join as join4 } from "path";
-import { fileURLToPath } from "url";
+import { realpathSync } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/cli.ts
-import { resolve as resolve2 } from "path";
-import * as p from "@clack/prompts";
+import { resolve as resolve3 } from "path";
+import * as p2 from "@clack/prompts";
 import open2 from "open";
 
 // src/core/config.ts
 var DEFAULT_API_BASE = "https://api.whisperr.net";
 var DEFAULT_MODEL = "claude-sonnet-5";
-var DEFAULT_PLANNER_MODEL = "claude-opus-4-8";
+var DEFAULT_PLANNER_MODEL = "claude-opus-5";
 var DEFAULT_EFFORT = "high";
 var EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
 function resolveEffort() {
@@ -41,7 +40,10 @@ function resolveConfig(flags = {}) {
     // cleanly and keeps whatever already landed. Real runs finish well under it.
     budgetUsd: Number(process.env.WHISPERR_WIZARD_BUDGET_USD) || 25,
     directAnthropicKey,
-    offline
+    offline,
+    reviewPlan: flags.reviewPlan ?? false,
+    proposeOnly: flags.proposeOnly ?? false,
+    strictReview: flags.strictReview ?? false
   };
 }
 
@@ -938,7 +940,7 @@ var ALL_PLAYBOOKS = [
   swiftPlaybook
 ];
 function playbookByTargetId(id) {
-  return ALL_PLAYBOOKS.find((p2) => p2.target.id === id);
+  return ALL_PLAYBOOKS.find((p3) => p3.target.id === id);
 }
 
 // src/core/detect.ts
@@ -980,7 +982,7 @@ function makeDetectContext(repoPath) {
 async function detectStack(repoPath) {
   const ctx = makeDetectContext(repoPath);
   const results = await Promise.all(
-    ALL_PLAYBOOKS.map((p2) => p2.detect(ctx).catch(() => null))
+    ALL_PLAYBOOKS.map((p3) => p3.detect(ctx).catch(() => null))
   );
   return results.filter((d) => d !== null).sort((a, b) => b.confidence - a.confidence);
 }
@@ -1124,7 +1126,18 @@ function mockManifest(appId, config) {
     appName: "Acme (dev)",
     ingestionApiKey: "wrk_offline_demo_key_do_not_use",
     ingestionBaseUrl: config.apiBaseUrl,
-    businessContext: "B2C subscription app. Free trial converts to a paid monthly plan. Churn risk concentrates around trial end and the first failed payment.",
+    // Same labelled shape whisperr-go renders from the app's onboarding
+    // business context, so an offline run exercises the real prompt.
+    businessContext: [
+      "Product: Acme (Acme Inc)",
+      "What it does: B2C subscription app; a free trial converts to a paid monthly plan",
+      "Industry: Software / Productivity",
+      "Who the paying end user is: individual consumers on the trial-to-paid path",
+      "How it charges: monthly subscription",
+      "Activation moment: first project created after signup",
+      "Churn-risk signals onboarding identified: trial ending unused; first failed payment",
+      "Healthy-usage signals: weekly active project edits"
+    ].join("\n"),
     identify: {
       traits: [
         { name: "plan", description: "free | trial | pro" },
@@ -1173,425 +1186,1690 @@ function mockManifest(appId, config) {
   };
 }
 
-// src/core/agent.ts
-import {
-  query
-} from "@anthropic-ai/claude-agent-sdk";
+// src/engine/cli.ts
+import * as p from "@clack/prompts";
 
-// src/core/git.ts
-import { spawn } from "child_process";
-import { createHash } from "crypto";
-import { mkdir, readFile as readFile2, rm, writeFile } from "fs/promises";
-import { basename, dirname, join as join2 } from "path";
-async function takeCheckpoint(repoPath) {
-  const isRepo = (await run(repoPath, ["rev-parse", "--is-inside-work-tree"])).ok;
-  if (!isRepo) return { isRepo: false };
-  const branch = (await run(repoPath, ["rev-parse", "--abbrev-ref", "HEAD"])).stdout.trim();
-  const head = await run(repoPath, ["rev-parse", "HEAD"]);
-  return {
-    isRepo: true,
-    baseRef: head.ok ? head.stdout.trim() : void 0,
-    branch: branch || void 0
-  };
+// src/core/report.ts
+function scrubSummary(text) {
+  return scrubTerminalControls(text).replace(/sk-ant-[A-Za-z0-9_-]+/g, "[redacted]").replace(/sk-[A-Za-z0-9]{16,}/g, "[redacted]").replace(/AKIA[0-9A-Z]{16}/g, "[redacted]").replace(/Bearer\s+[A-Za-z0-9._-]+/g, "[redacted]").replace(
+    /\b(ANTHROPIC_(?:AUTH_TOKEN|API_KEY))\s*=\s*["']?[^"'\s]+["']?/gi,
+    "$1=[redacted]"
+  );
 }
-async function changedFiles(repoPath, checkpoint) {
-  if (!checkpoint.isRepo) return [];
-  const tracked = await run(repoPath, ["diff", "--name-only"]);
-  const untracked = await run(repoPath, [
-    "ls-files",
-    "--others",
-    "--exclude-standard"
-  ]);
-  const set = /* @__PURE__ */ new Set();
-  for (const f of `${tracked.stdout}
-${untracked.stdout}`.split("\n")) {
-    if (f.trim()) set.add(f.trim());
+async function postRunReport(config, session, report) {
+  if (config.offline) return { ok: true };
+  try {
+    const res = await fetch(`${config.apiBaseUrl}/wizard/report`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${session.token}`
+      },
+      body: JSON.stringify(report)
+    });
+    if (res.ok) return { ok: true };
+    return {
+      ok: false,
+      status: res.status,
+      detail: await responseDetail(res)
+    };
+  } catch (err) {
+    return { ok: false, detail: detailSlice(errorMessage(err)) };
   }
-  return [...set];
 }
-function revertHint(checkpoint) {
-  if (!checkpoint.isRepo || !checkpoint.baseRef) return void 0;
-  return `git restore . && git clean -fd   (back to ${checkpoint.baseRef.slice(0, 7)})`;
+async function responseDetail(res) {
+  try {
+    return detailSlice(await res.text());
+  } catch (err) {
+    return detailSlice(errorMessage(err));
+  }
 }
-async function wasTrackedAtCheckpoint(repoPath, checkpoint, file) {
-  if (!checkpoint.isRepo) return false;
-  if (checkpoint.baseRef) {
-    const res2 = await run(repoPath, [
-      "ls-tree",
-      "--name-only",
-      checkpoint.baseRef,
-      "--",
-      file
-    ]);
-    return res2.ok && res2.stdout.trim() !== "";
-  }
-  const res = await run(repoPath, ["ls-files", "--", file]);
-  return res.ok && res.stdout.trim() !== "";
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
 }
-async function isWorkingTreeClean(repoPath) {
-  const status = await run(repoPath, ["status", "--porcelain"]);
-  return status.ok && status.stdout.trim() === "";
+function detailSlice(detail) {
+  const sliced = detail.slice(0, 200).trim();
+  return sliced || void 0;
 }
-async function revertToCheckpoint(repoPath, checkpoint) {
-  if (!checkpoint.isRepo) return false;
-  if (checkpoint.baseRef) {
-    const reset = await run(repoPath, ["reset", "--hard", checkpoint.baseRef]);
-    const clean2 = await run(repoPath, ["clean", "-fd"]);
-    return reset.ok && clean2.ok;
-  }
-  const restore = await run(repoPath, ["restore", "."]);
-  const clean = await run(repoPath, ["clean", "-fd"]);
-  return restore.ok && clean.ok;
+function scrubTerminalControls(value) {
+  return value.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "").replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?/g, "").replace(/[\x00-\x1f\x7f]/g, " ").replace(/ {2,}/g, " ").trim();
 }
-async function snapshotChanges(repoPath, checkpoint) {
-  const snapshot = /* @__PURE__ */ new Map();
-  for (const file of await changedFiles(repoPath, checkpoint)) {
+
+// src/core/verify.ts
+async function pollFirstEvent(config, session, opts = {}) {
+  if (config.offline) return { received: false };
+  const timeoutMs = opts.timeoutMs ?? 12e4;
+  const intervalMs = opts.intervalMs ?? 3e3;
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (opts.signal?.aborted) return { received: false };
     try {
-      snapshot.set(file, await readFile2(join2(repoPath, file)));
+      const res = await fetch(`${config.apiBaseUrl}/wizard/first-event`, {
+        headers: { authorization: `Bearer ${session.token}` }
+      });
+      if (res.ok) {
+        const body = await res.json();
+        if (body.received) {
+          return { received: true, eventType: body.event_type };
+        }
+      }
     } catch {
-      snapshot.set(file, null);
-    }
-  }
-  return snapshot;
-}
-function snapshotsEqual(a, b) {
-  if (a.size !== b.size) return false;
-  for (const [file, content] of a) {
-    const other = b.get(file);
-    if (other === void 0) return false;
-    if (content === null || other === null) {
-      if (content !== other) return false;
-    } else if (!content.equals(other)) {
-      return false;
     }
+    await new Promise((r) => setTimeout(r, intervalMs));
   }
-  return true;
+  return { received: false };
 }
-async function restoreToSnapshot(repoPath, checkpoint, snapshot) {
-  try {
-    const current = await changedFiles(repoPath, checkpoint);
-    for (const file of /* @__PURE__ */ new Set([...current, ...snapshot.keys()])) {
-      const recorded = snapshot.get(file);
-      const path = join2(repoPath, file);
-      if (recorded === void 0) {
-        if (checkpoint.baseRef) {
-          const co = await run(repoPath, ["checkout", checkpoint.baseRef, "--", file]);
-          if (co.ok) continue;
-        }
-        await rm(path, { force: true });
-      } else if (recorded === null) {
-        await rm(path, { force: true });
-      } else {
-        await mkdir(dirname(path), { recursive: true });
-        await writeFile(path, recorded);
+
+// src/engine/output.ts
+function formatProgressLine(event) {
+  const parts = [event.phase];
+  if (event.cluster) {
+    parts.push(`cluster ${event.cluster.index}/${event.cluster.total}`);
+  }
+  if (event.file) {
+    parts.push(event.file);
+  }
+  parts.push(event.action);
+  return parts.join(" \xB7 ");
+}
+function createProgressSink(options) {
+  const interval = options.heartbeatIntervalMs ?? 15e3;
+  const now = options.now ?? (() => Date.now());
+  let lastLineAt = 0;
+  let lastLine = "";
+  const writeLine = (line) => {
+    lastLineAt = now();
+    lastLine = line;
+    options.write(line);
+  };
+  return {
+    emit(event) {
+      if (options.json) {
+        writeLine(JSON.stringify({ kind: "progress", ...event }));
+        return;
+      }
+      const line = formatProgressLine(event);
+      if (!options.isTTY && line === lastLine) {
+        return;
       }
+      writeLine(line);
+    },
+    heartbeat(phase, action) {
+      if (now() - lastLineAt < interval) {
+        return;
+      }
+      if (options.json) {
+        writeLine(JSON.stringify({ kind: "heartbeat", phase, action }));
+        return;
+      }
+      writeLine(`${phase} \xB7 still working \xB7 ${action}`);
     }
-    return true;
-  } catch {
-    return false;
-  }
-}
-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:${basename(repoPath)}`;
-  return createHash("sha256").update(seed).digest("hex").slice(0, 16);
-}
-function normalizeRemote(url) {
-  return url.replace(/^git@([^:]+):/, "$1/").replace(/^https?:\/\//, "").replace(/\.git$/, "").replace(/\/+$/, "").toLowerCase();
+  };
 }
-async function scanWiredEvents(repoPath, files, eventTypes) {
-  const wired = /* @__PURE__ */ new Map();
-  const patterns = eventTypes.map((e) => ({
-    eventType: e,
-    trackRe: new RegExp(
-      `\\btrack\\s*\\(\\s*[\\s\\S]{0,160}?['"\`]${escapeRegExp(e)}['"\`]`
-    ),
-    literalRe: quotedLiteralRegExp(e)
-  }));
-  const contents = [];
-  for (const file of files) {
-    try {
-      contents.push({ file, content: await readFile2(join2(repoPath, file), "utf8") });
-    } catch {
+
+// src/engine/orchestrator.ts
+import { basename, join as join6 } from "path";
+
+// src/engine/clusters.ts
+import { createHash } from "crypto";
+import { dirname } from "path";
+var MIN_CLUSTER_EVENTS = 3;
+var MAX_CLUSTER_EVENTS = 8;
+function clusterIdFor(files) {
+  const digest = createHash("sha256").update([...files].sort().join("\n")).digest("hex");
+  return `cluster_${digest.slice(0, 12)}`;
+}
+function deriveClusters(placements) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const placement of placements) {
+    const existing = byFile.get(placement.file) ?? [];
+    existing.push(placement);
+    byFile.set(placement.file, existing);
+  }
+  const byDirectory = /* @__PURE__ */ new Map();
+  for (const [file, events] of byFile) {
+    const directory = dirname(file);
+    const bucket = byDirectory.get(directory) ?? { files: /* @__PURE__ */ new Set(), events: [] };
+    bucket.files.add(file);
+    bucket.events.push(...events);
+    byDirectory.set(directory, bucket);
+  }
+  const clusters = [];
+  const pending = [];
+  for (const directory of [...byDirectory.keys()].sort()) {
+    const bucket = byDirectory.get(directory);
+    if (bucket.events.length >= MIN_CLUSTER_EVENTS) {
+      pending.push(bucket);
       continue;
     }
-  }
-  for (const { file, content } of contents) {
-    for (const { eventType, trackRe } of patterns) {
-      if (!wired.has(eventType) && trackRe.test(content)) {
-        wired.set(eventType, file);
-      }
+    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 { file, content } of contents) {
-    for (const { eventType, literalRe } of patterns) {
-      if (!wired.has(eventType) && literalRe.test(content)) {
-        wired.set(eventType, file);
-      }
+  for (const bucket of pending) {
+    const events = [...bucket.events].sort((a, b) => a.eventCode.localeCompare(b.eventCode));
+    for (let start = 0; start < events.length; start += MAX_CLUSTER_EVENTS) {
+      const slice = events.slice(start, start + MAX_CLUSTER_EVENTS);
+      const files = [...new Set(slice.map((event) => event.file))].sort();
+      clusters.push({
+        id: clusterIdFor(files.length > 0 ? files : [`slice_${start}`]),
+        files,
+        events: slice,
+        status: "pending",
+        attempts: 0
+      });
     }
   }
-  return wired;
+  return clusters;
 }
-function quotedLiteralRegExp(eventType) {
-  const leftBoundary = /^\w/.test(eventType) ? "\\b" : "";
-  const rightBoundary = /\w$/.test(eventType) ? "\\b" : "";
-  return new RegExp(`(['"\`])${leftBoundary}${escapeRegExp(eventType)}${rightBoundary}\\1`);
+var TERMINAL_STATUSES = ["reviewed", "failed_resumable", "blocked"];
+function nextPendingCluster(clusters) {
+  return clusters.find((cluster) => cluster.status === "pending" || cluster.status === "editing");
 }
-function escapeRegExp(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function clustersComplete(clusters) {
+  return clusters.every((cluster) => TERMINAL_STATUSES.includes(cluster.status));
 }
-function run(cwd, args) {
-  return new Promise((resolve3) => {
-    const child = spawn("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) => resolve3({ ok: code === 0, stdout, stderr }));
-    child.on("error", () => resolve3({ ok: false, stdout, stderr }));
+function transitionCluster(clusters, clusterId, status, note3) {
+  return clusters.map((cluster) => {
+    if (cluster.id !== clusterId) {
+      return cluster;
+    }
+    const attempts = status === "editing" ? cluster.attempts + 1 : cluster.attempts;
+    return { ...cluster, status, attempts, note: note3 ?? cluster.note };
   });
 }
 
-// src/core/opportunities.ts
-import { readFile as readFile3, rm as rm2 } from "fs/promises";
+// src/engine/integrate.ts
+import { writeFile } from "fs/promises";
 import { join as join3 } from "path";
-var OPPORTUNITIES_FILE = "whisperr-opportunities.json";
-function normalizeCode(value) {
-  return value.trim().toLowerCase().replace(/[ \-./]/g, "_").replace(/[^a-z0-9_]/g, "").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+
+// src/engine/bindings.ts
+function bindingsTargetFor(target9) {
+  switch (target9) {
+    case "swift":
+      return "swift";
+    case "flutter":
+      return "dart";
+    default:
+      return "typescript";
+  }
+}
+function camelCase(code) {
+  return code.split("_").map((part, index) => index === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function generateBindings(target9, events) {
+  switch (bindingsTargetFor(target9)) {
+    case "swift":
+      return generateSwift(events);
+    case "dart":
+      return generateDart(events);
+    default:
+      return generateTypeScript(events);
+  }
+}
+function generateTypeScript(events) {
+  const lines = [
+    "// Generated by @whisperr/wizard \u2014 do not edit by hand.",
+    "// Call bindWhisperr(client) once right after the Whisperr SDK is initialized;",
+    "// events tracked before binding are queued, never dropped.",
+    "",
+    "type WhisperrPayloadValue = string | number | boolean;",
+    "type WhisperrClientLike = {",
+    "  track: (event: string, payload?: Record<string, WhisperrPayloadValue>) => unknown;",
+    "};",
+    "",
+    "let boundClient: WhisperrClientLike | null = null;",
+    "const queued: Array<[string, Record<string, WhisperrPayloadValue> | undefined]> = [];",
+    "",
+    "export function bindWhisperr(client: WhisperrClientLike): void {",
+    "  boundClient = client;",
+    "  while (queued.length > 0) {",
+    "    const [event, payload] = queued.shift()!;",
+    "    try { client.track(event, payload); } catch { /* analytics must never break the app */ }",
+    "  }",
+    "}",
+    "",
+    "function emit(event: string, payload?: Record<string, WhisperrPayloadValue>): void {",
+    "  if (boundClient) {",
+    "    try { boundClient.track(event, payload); } catch { /* analytics must never break the app */ }",
+    "  } else {",
+    "    queued.push([event, payload]);",
+    "  }",
+    "}",
+    "",
+    "export const WhisperrEvents = {"
+  ];
+  for (const event of events) {
+    const fields = Object.keys(event.payloadSchema);
+    for (const field of fields) {
+      lines.push(`  /** ${field}: ${event.payloadSchema[field]} */`);
+    }
+    if (fields.length === 0) {
+      lines.push(`  ${camelCase(event.code)}(): void {`, `    emit("${event.code}");`, "  },");
+    } else {
+      const params = fields.map((field) => `${camelCase(field)}: WhisperrPayloadValue`).join("; ");
+      const entries = fields.map((field) => `"${field}": ${camelCase(field)}`).join(", ");
+      lines.push(
+        `  ${camelCase(event.code)}(payload: { ${params} }): void {`,
+        `    const { ${fields.map((field) => camelCase(field)).join(", ")} } = payload;`,
+        `    emit("${event.code}", { ${entries} });`,
+        "  },"
+      );
+    }
+  }
+  lines.push("};", "");
+  return {
+    relativePath: "whisperr-events.ts",
+    content: lines.join("\n"),
+    bindInstruction: "Import { bindWhisperr } from the generated whisperr-events module and call bindWhisperr(client) once, immediately after the Whisperr SDK client is created at app startup."
+  };
+}
+function generateSwift(events) {
+  const lines = [
+    "// Generated by @whisperr/wizard \u2014 do not edit by hand.",
+    "// Call WhisperrEvents.bind(track:) once right after the Whisperr SDK is ready;",
+    "// events tracked before binding are queued, never dropped.",
+    "",
+    "import Foundation",
+    "",
+    "enum WhisperrEvents {",
+    "    typealias TrackFunction = (String, [String: String]) -> Void",
+    "    private static var boundTrack: TrackFunction?",
+    "    private static var queued: [(String, [String: String])] = []",
+    "    private static let lock = NSLock()",
+    "",
+    "    static func bind(track: @escaping TrackFunction) {",
+    "        lock.lock()",
+    "        boundTrack = track",
+    "        let pending = queued",
+    "        queued.removeAll()",
+    "        lock.unlock()",
+    "        for (event, payload) in pending { track(event, payload) }",
+    "    }",
+    "",
+    "    private static func emit(_ event: String, _ payload: [String: String] = [:]) {",
+    "        lock.lock()",
+    "        if let track = boundTrack {",
+    "            lock.unlock()",
+    "            track(event, payload)",
+    "        } else {",
+    "            queued.append((event, payload))",
+    "            lock.unlock()",
+    "        }",
+    "    }",
+    ""
+  ];
+  for (const event of events) {
+    const fields = Object.keys(event.payloadSchema);
+    for (const field of fields) {
+      lines.push(`    /// ${field}: ${event.payloadSchema[field]}`);
+    }
+    if (fields.length === 0) {
+      lines.push(`    static func ${camelCase(event.code)}() {`, `        emit("${event.code}")`, "    }", "");
+    } else {
+      const params = fields.map((field) => `${camelCase(field)}: String`).join(", ");
+      const entries = fields.map((field) => `"${field}": ${camelCase(field)}`).join(", ");
+      lines.push(
+        `    static func ${camelCase(event.code)}(${params}) {`,
+        `        emit("${event.code}", [${entries}])`,
+        "    }",
+        ""
+      );
+    }
+  }
+  lines.push("}", "");
+  return {
+    relativePath: "WhisperrEvents.swift",
+    content: lines.join("\n"),
+    bindInstruction: "Call WhisperrEvents.bind(track:) once, immediately after Whisperr SDK initialization completes, forwarding to the SDK's track call. String payload values only."
+  };
+}
+function generateDart(events) {
+  const lines = [
+    "// Generated by @whisperr/wizard \u2014 do not edit by hand.",
+    "// Call WhisperrEvents.bind(track) once right after the Whisperr SDK is ready;",
+    "// events tracked before binding are queued, never dropped.",
+    "",
+    "typedef WhisperrTrack = void Function(String event, Map<String, Object> payload);",
+    "",
+    "class WhisperrEvents {",
+    "  static WhisperrTrack? _track;",
+    "  static final List<MapEntry<String, Map<String, Object>>> _queued = [];",
+    "",
+    "  static void bind(WhisperrTrack track) {",
+    "    _track = track;",
+    "    for (final entry in _queued) {",
+    "      track(entry.key, entry.value);",
+    "    }",
+    "    _queued.clear();",
+    "  }",
+    "",
+    "  static void _emit(String event, [Map<String, Object> payload = const {}]) {",
+    "    final track = _track;",
+    "    if (track != null) {",
+    "      track(event, payload);",
+    "    } else {",
+    "      _queued.add(MapEntry(event, payload));",
+    "    }",
+    "  }",
+    ""
+  ];
+  for (const event of events) {
+    const fields = Object.keys(event.payloadSchema);
+    for (const field of fields) {
+      lines.push(`  /// ${field}: ${event.payloadSchema[field]}`);
+    }
+    if (fields.length === 0) {
+      lines.push(`  static void ${camelCase(event.code)}() => _emit('${event.code}');`, "");
+    } else {
+      const params = fields.map((field) => `required Object ${camelCase(field)}`).join(", ");
+      const entries = fields.map((field) => `'${field}': ${camelCase(field)}`).join(", ");
+      lines.push(
+        `  static void ${camelCase(event.code)}({${params}}) =>`,
+        `      _emit('${event.code}', {${entries}});`,
+        ""
+      );
+    }
+  }
+  lines.push("}", "");
+  return {
+    relativePath: "whisperr_events.dart",
+    content: lines.join("\n"),
+    bindInstruction: "Call WhisperrEvents.bind(track) once, immediately after the Whisperr SDK is initialized, forwarding to the SDK's track call."
+  };
+}
+
+// src/engine/budgets.ts
+var OVERFLOW_PATTERNS = [
+  /prompt is too long/i,
+  /context.{0,20}(length|window|limit).{0,20}exceed/i,
+  /exceeds? .{0,20}context/i,
+  /maximum context/i,
+  /input is too long/i
+];
+var TRANSIENT_PATTERNS = [
+  /rate.?limit/i,
+  /overloaded/i,
+  /timeout/i,
+  /timed out/i,
+  /econnreset/i,
+  /socket hang up/i,
+  /5\d\d/,
+  /temporarily unavailable/i
+];
+function classifyFailure(message) {
+  const text = message ?? "";
+  if (OVERFLOW_PATTERNS.some((pattern) => pattern.test(text))) {
+    return "context_overflow";
+  }
+  if (TRANSIENT_PATTERNS.some((pattern) => pattern.test(text))) {
+    return "transient";
+  }
+  return "fatal";
+}
+var MAX_CLUSTER_ATTEMPTS = 2;
+function nextClusterStatusAfterFailure(failure, attempts) {
+  if (failure === "transient" && attempts < MAX_CLUSTER_ATTEMPTS) {
+    return "pending";
+  }
+  if (failure === "fatal") {
+    return "blocked";
+  }
+  return "failed_resumable";
 }
-async function collectOpportunities(repoPath, manifest, checkpoint) {
-  const path = join3(repoPath, OPPORTUNITIES_FILE);
-  if (await wasTrackedAtCheckpoint(repoPath, checkpoint, OPPORTUNITIES_FILE)) {
-    return { events: [], interventions: [] };
+
+// src/engine/verify.ts
+import { spawn } from "child_process";
+import { readFileSync } from "fs";
+import { join as join2 } from "path";
+var JS_TARGETS = /* @__PURE__ */ new Set(["web-js", "nextjs", "node", "react-native"]);
+function resolveVerifySteps(repoPath, target9) {
+  if (target9 === "flutter") {
+    return [{ kind: "analyze", command: "flutter", args: ["analyze", "--no-pub"] }];
+  }
+  if (JS_TARGETS.has(target9)) {
+    const scripts = packageScripts(repoPath);
+    const steps = [];
+    if (scripts.typecheck) {
+      steps.push({ kind: "typecheck", command: npmCommand(), args: ["run", "typecheck"] });
+    } else if (hasTsconfig(repoPath)) {
+      steps.push({ kind: "typecheck", command: "npx", args: ["--no-install", "tsc", "--noEmit"] });
+    }
+    if (steps.length === 0 && scripts.build) {
+      steps.push({ kind: "build", command: npmCommand(), args: ["run", "build"] });
+    }
+    return steps;
   }
-  let rawText;
+  return [];
+}
+function packageScripts(repoPath) {
   try {
-    rawText = await readFile3(path, "utf8");
+    const parsed = JSON.parse(readFileSync(join2(repoPath, "package.json"), "utf8"));
+    return parsed.scripts ?? {};
   } catch {
-    return { events: [], interventions: [] };
+    return {};
   }
-  await rm2(path, { force: true }).catch(() => {
-  });
-  let raw;
+}
+function hasTsconfig(repoPath) {
   try {
-    raw = JSON.parse(rawText);
+    readFileSync(join2(repoPath, "tsconfig.json"), "utf8");
+    return true;
   } catch {
-    return { events: [], interventions: [] };
+    return false;
   }
-  return sanitizeOpportunities(raw, manifest);
 }
-function sanitizeOpportunities(raw, manifest) {
-  const out = { events: [], interventions: [] };
-  if (typeof raw !== "object" || raw === null) return out;
-  const doc = raw;
-  const knownEvents = new Set(manifest.events.map((e) => normalizeCode(e.eventType)));
-  const knownInterventions = /* @__PURE__ */ new Set([
-    ...manifest.events.flatMap((e) => e.interventions ?? []).map((i) => normalizeCode(i.code)),
-    ...(manifest.interventions ?? []).map((i) => normalizeCode(i.code))
-  ]);
-  const seenEvents = /* @__PURE__ */ new Set();
-  for (const entry of asArray(doc.events)) {
-    const ev = coerceEvent(entry);
-    if (!ev) continue;
-    if (knownEvents.has(ev.code) || seenEvents.has(ev.code)) continue;
-    seenEvents.add(ev.code);
-    out.events.push(ev);
+function npmCommand() {
+  return process.platform === "win32" ? "npm.cmd" : "npm";
+}
+function runVerifyStep(cwd, step, timeoutMs = 3e5) {
+  return new Promise((resolve4) => {
+    const child = spawn(step.command, step.args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let output = "";
+    const capture = (chunk) => {
+      if (output.length < 2e4) {
+        output += String(chunk);
+      }
+    };
+    child.stdout.on("data", capture);
+    child.stderr.on("data", capture);
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+    }, timeoutMs);
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      resolve4({ ...step, ok: false, output: String(error) });
+    });
+    child.on("close", (exitCode) => {
+      clearTimeout(timer);
+      resolve4({ ...step, ok: exitCode === 0, output });
+    });
+  });
+}
+async function runVerifySteps(cwd, steps) {
+  const results = [];
+  for (const step of steps) {
+    results.push(await runVerifyStep(cwd, step));
   }
-  const seenInterventions = /* @__PURE__ */ new Set();
-  for (const entry of asArray(doc.interventions)) {
-    const iv = coerceIntervention(entry);
-    if (!iv) continue;
-    if (knownInterventions.has(iv.code) || seenInterventions.has(iv.code)) continue;
-    seenInterventions.add(iv.code);
-    out.interventions.push(iv);
+  return results;
+}
+function verifiedStatus(results) {
+  if (results.length === 0) {
+    return "applied";
   }
-  return out;
+  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";
 }
-var SUBMIT_TIMEOUT_MS = 3e4;
-async function submitAdditions(config, session, target9, repoFingerprint2, opportunities) {
-  const res = await fetch(`${config.apiBaseUrl}/wizard/universe/additions`, {
-    method: "POST",
-    signal: AbortSignal.timeout(SUBMIT_TIMEOUT_MS),
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${session.token}`
-    },
-    body: JSON.stringify({
-      target: target9,
-      repoFingerprint: repoFingerprint2,
-      events: opportunities.events,
-      interventions: opportunities.interventions
-    })
-  });
-  if (!res.ok) {
-    const body = await res.text().catch(() => "");
-    throw new Error(
-      `Submitting universe additions failed (${res.status})${body ? `: ${body.slice(0, 300)}` : ""}`
-    );
+function runVerificationStatus(results) {
+  if (results.length === 0) {
+    return "unavailable";
   }
-  return await res.json();
+  return results.every((result) => result.ok) ? "passed" : "failed";
 }
-async function submitSuggestions(config, session, target9, repoFingerprint2, opportunities) {
-  const res = await fetch(`${config.apiBaseUrl}/wizard/universe/suggestions`, {
-    method: "POST",
-    signal: AbortSignal.timeout(SUBMIT_TIMEOUT_MS),
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${session.token}`
+function verificationCommand(results) {
+  const last = results[results.length - 1];
+  return last ? [last.command, ...last.args].join(" ") : void 0;
+}
+
+// src/engine/integrate.ts
+var REVIEW_CHECKLIST = [
+  "- Events must fire after the confirmed outcome (post-await/success), never on intent or button tap.",
+  "- View-appearance events must be deduplicated against re-renders and navigation returns.",
+  "- Debounced flows must emit after the debounce commits, not per keystroke/tap.",
+  "- Denied/failed permission or authorization results must not be recorded as granted.",
+  "- Never persist a sent/once marker before the track call actually executed.",
+  "- Payloads must use only the generated wrapper fields \u2014 no extra fields, no personal identifiers."
+].join("\n");
+async function writeBindingsModule(worktree, target9, registered) {
+  const bindings = generateBindings(target9, registered);
+  await writeFile(join3(worktree.path, bindings.relativePath), bindings.content);
+  return bindings;
+}
+async function runSdkSetupPass(deps, bindings) {
+  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
     },
-    body: JSON.stringify({
-      target: target9,
-      repoFingerprint: repoFingerprint2,
-      events: opportunities.events,
-      interventions: opportunities.interventions
-    })
+    deps.models.edit,
+    (action) => deps.sink.emit({ phase: "binding", action })
+  );
+  return outcome.kind === "completed";
+}
+function clusterPrompt(cluster, registered, bindings) {
+  const byCode = new Map(registered.map((event) => [event.code, event]));
+  const briefs = cluster.events.map((placement) => {
+    const event = byCode.get(placement.eventCode);
+    const fields = Object.keys(event?.payloadSchema ?? {});
+    return [
+      `- ${placement.eventCode}: call the generated wrapper from ${bindings.relativePath}`,
+      `  anchor: ${placement.file}${placement.symbol ? ` (${placement.symbol})` : ""}`,
+      `  why: ${event?.reasoning ?? ""}`,
+      fields.length > 0 ? `  payload fields: ${fields.join(", ")}` : "  payload: none"
+    ].join("\n");
   });
-  if (res.status === 404) return null;
-  if (!res.ok) {
-    const body = await res.text().catch(() => "");
-    throw new Error(
-      `Submitting universe suggestions failed (${res.status})${body ? `: ${body.slice(0, 300)}` : ""}`
-    );
-  }
-  return await res.json();
+  return [
+    "Instrument EXACTLY these events by calling their generated wrapper functions at the anchors.",
+    "Use only the generated wrappers \u2014 never call the SDK's raw track() and never invent event names.",
+    "",
+    "Placement rules:",
+    REVIEW_CHECKLIST,
+    "",
+    "Events for this cluster:",
+    ...briefs,
+    "",
+    "Only edit the listed files (plus imports of the bindings module). Then stop."
+  ].join("\n");
 }
-async function fetchSuggestions(config, session, statuses) {
-  if (config.offline) return [];
-  try {
-    const statusQuery = statuses.map(encodeURIComponent).join(",");
-    const url = `${config.apiBaseUrl}/wizard/universe/suggestions${statusQuery ? `?status=${statusQuery}` : ""}`;
-    const res = await fetch(url, {
-      signal: AbortSignal.timeout(SUBMIT_TIMEOUT_MS),
-      headers: { Authorization: `Bearer ${session.token}` }
+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) {
+  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);
+    if (!cluster) {
+      break;
+    }
+    const index = clusters.findIndex((candidate) => candidate.id === cluster.id) + 1;
+    clusters = transitionCluster(clusters, cluster.id, "editing");
+    deps.saveClusters(clusters);
+    deps.sink.emit({
+      phase: "integrating",
+      cluster: { index, total },
+      file: cluster.files[0],
+      action: "placing events"
     });
-    if (!res.ok) return [];
-    const body = await res.json();
-    return Array.isArray(body) && body.every(isSuggestionRecord) ? body : [];
-  } catch {
-    return [];
+    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,
+      (action) => deps.sink.emit({ phase: "integrating", cluster: { index, total }, action })
+    );
+    if (edit.kind !== "completed") {
+      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}`);
+      deps.saveClusters(clusters);
+      for (const placement of cluster.events) {
+        eventStatuses.set(placement.eventCode, "failed");
+      }
+      continue;
+    }
+    let statuses = "applied";
+    if (steps.length > 0) {
+      deps.sink.emit({ phase: "verifying", cluster: { index, total }, action: "running verifier" });
+      const results = await runVerifySteps(deps.worktree.path, steps);
+      statuses = verifiedStatus(results);
+      if (results.some((result) => !result.ok) && cluster.attempts < MAX_CLUSTER_ATTEMPTS) {
+        deps.sink.emit({ phase: "verifying", cluster: { index, total }, action: "repairing verification failure" });
+        await deps.provider.invoke(
+          {
+            role: "edit",
+            systemPrompt: deps.playbookSystemPrompt,
+            userPrompt: [
+              "The verification command failed after your edits. Fix ONLY the failure below, then stop.",
+              "",
+              results.map((result) => result.output).join("\n").slice(0, 2e4)
+            ].join("\n"),
+            tools: [],
+            allowRepoWrite: true,
+            cwd: deps.worktree.path
+          },
+          deps.models.edit,
+          (action) => deps.sink.emit({ phase: "verifying", cluster: { index, total }, action })
+        );
+        const retried = await runVerifySteps(deps.worktree.path, steps);
+        statuses = verifiedStatus(retried);
+      }
+    }
+    clusters = transitionCluster(clusters, cluster.id, "verified");
+    deps.saveClusters(clusters);
+    const diff = await clusterDiff(cluster.files);
+    const review = await reviewCluster(deps, cluster, diff);
+    const finalStatus = review.ok ? statuses === "applied" ? "applied" : "reviewed" : statuses;
+    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);
+    }
   }
+  if (!clustersComplete(clusters)) {
+    throw new Error("cluster queue did not reach a terminal state");
+  }
+  return { clusters, eventStatuses };
 }
-function isSuggestionRecord(value) {
-  if (typeof value !== "object" || value === null) return false;
-  const record = value;
-  return typeof record.id === "string" && (record.kind === "event" || record.kind === "intervention") && typeof record.code === "string" && (record.status === "proposed" || record.status === "approved" || record.status === "rejected" || record.status === "integrated") && typeof record.payload === "object" && record.payload !== null;
+async function finalizeIntegration(deps) {
+  const steps = resolveVerifySteps(deps.worktree.path, deps.target);
+  deps.sink.emit({ phase: "verifying", action: "final verification pass" });
+  const results = await runVerifySteps(deps.worktree.path, steps);
+  return {
+    results,
+    status: runVerificationStatus(results),
+    command: verificationCommand(results)
+  };
 }
-async function markSuggestionIntegrated(config, session, id, target9, repoFingerprint2) {
-  if (config.offline) return false;
-  try {
-    const res = await fetch(
-      `${config.apiBaseUrl}/wizard/universe/suggestions/${encodeURIComponent(id)}/integrated`,
-      {
-        method: "POST",
-        signal: AbortSignal.timeout(SUBMIT_TIMEOUT_MS),
+
+// src/engine/runs.ts
+import { createHash as createHash2 } from "crypto";
+var RunsApiError = class extends Error {
+  constructor(message, status, code) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.name = "RunsApiError";
+  }
+  status;
+  code;
+};
+function itemIdempotencyKey(kind, code, extra = "") {
+  return createHash2("sha256").update(`${kind}
+${code}
+${extra}`).digest("hex").slice(0, 32);
+}
+var RunsClient = class {
+  constructor(config, session) {
+    this.config = config;
+    this.session = session;
+  }
+  config;
+  session;
+  async request(method, path, body) {
+    let response;
+    try {
+      response = await fetch(`${this.config.apiBaseUrl}${path}`, {
+        method,
         headers: {
           "Content-Type": "application/json",
-          Authorization: `Bearer ${session.token}`
+          Authorization: `Bearer ${this.session.token}`
         },
-        body: JSON.stringify({ target: target9, repoFingerprint: repoFingerprint2 })
-      }
+        body: body === void 0 ? void 0 : JSON.stringify(body)
+      });
+    } catch (error) {
+      throw new RunsApiError(error instanceof Error ? error.message : "request failed");
+    }
+    let payload;
+    const text = await response.text();
+    try {
+      payload = text.length > 0 ? JSON.parse(text) : {};
+    } catch {
+      payload = {};
+    }
+    if (!response.ok) {
+      const detail = payload;
+      throw new RunsApiError(
+        detail.message ?? `runs API ${method} ${path} failed`,
+        response.status,
+        detail.code
+      );
+    }
+    return payload;
+  }
+  createOrResumeRun(input) {
+    return this.request("POST", "/wizard/runs", { ...input });
+  }
+  getRun(runId) {
+    return this.request("GET", `/wizard/runs/${runId}`);
+  }
+  patchRun(runId, patch) {
+    return this.request("PATCH", `/wizard/runs/${runId}`, { ...patch });
+  }
+  writeItem(runId, kind, payload, idempotencyExtra = "") {
+    const code = typeof payload.code === "string" ? payload.code : JSON.stringify(payload);
+    return this.request("POST", `/wizard/runs/${runId}/items`, {
+      idempotencyKey: itemIdempotencyKey(kind, code, idempotencyExtra),
+      kind,
+      payload
+    });
+  }
+  completeRun(runId, completion) {
+    return this.request(
+      "POST",
+      `/wizard/runs/${runId}/complete`,
+      { ...completion }
     );
-    return res.status === 200;
-  } catch {
-    return false;
   }
+};
+
+// src/engine/selection.ts
+import { z } from "zod";
+
+// src/engine/prompts.ts
+var SURVEY_SYSTEM_PROMPT = [
+  "You are the read-only survey pass of the Whisperr integration wizard.",
+  "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.",
+  "2. Feature areas: name, root directory, and the 1-3 files where committed user actions happen.",
+  "3. The end-user identify() anchor: the login/signup success and session-restore call sites for the",
+  "   PAYING end user \u2014 never admin, staff, operator, or seller paths.",
+  "4. Existing analytics calls, if any.",
+  "5. Committed-action call sites worth instrumenting: file, function/symbol, and what the user just did.",
+  "Cite concrete file paths for every claim. Do not propose event names yet."
+].join("\n");
+function surveyUserPrompt(repoPath, onboardingContext) {
+  return [
+    `Survey the repository at ${repoPath}.`,
+    "",
+    onboardingContext ? "Business context from onboarding:\n" + onboardingContext : "",
+    "",
+    "Produce the survey report now."
+  ].join("\n");
 }
-function asArray(value) {
-  return Array.isArray(value) ? value : [];
+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.",
+  "",
+  "Rules \u2014 these are hard constraints:",
+  "- Only propose an event with a concrete call site: a real file and function where the committed",
+  "  user action happens. Never propose absence/timeout/derived concepts (daily_log_missed,",
+  "  streak_broken) \u2014 the server derives those later.",
+  "- Emit after confirmed outcomes, not intent: a purchase event fires on confirmed success, not on",
+  "  button tap; denied permissions are not grants.",
+  "- Importance is anchored in the business context: the activation moment, churn-risk and healthy",
+  "  signals, and how the product charges. A handful of load-bearing events beats wide coverage.",
+  "- An empty or small set is a valid outcome. There is no quota. Never invent events to look thorough.",
+  "- Codes are lowercase snake_case, named for what happened (checkout_completed, not do_checkout).",
+  "- payloadSchema lists the fields worth capturing with a short description of each \u2014 the important",
+  "  info only. NEVER include personal identifiers: no email, phone, names, addresses, birth dates,",
+  "  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."
+].join("\n");
+function selectionUserPrompt(surveyReport, onboardingContext, existingEventCodes, rejectedCodes) {
+  return [
+    "Survey report:",
+    surveyReport,
+    "",
+    onboardingContext ? "Business context from onboarding:\n" + onboardingContext : "",
+    existingEventCodes.length > 0 ? "Already registered for this app (do not re-propose; other projects may own them):\n- " + existingEventCodes.join("\n- ") : "",
+    rejectedCodes.length > 0 ? "Previously rejected by the user (do not re-propose):\n- " + rejectedCodes.join("\n- ") : "",
+    "",
+    "Propose the important events now."
+  ].filter((section) => section !== "").join("\n");
 }
-function asString(value) {
-  if (typeof value !== "string") return void 0;
-  const cleaned = value.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "").replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?/g, "").replace(/[\x00-\x1f\x7f]/g, " ").replace(/ {2,}/g, " ").trim();
-  return cleaned ? cleaned : void 0;
+function renderOnboardingContext(context) {
+  if (!context) {
+    return "";
+  }
+  const rendered = JSON.stringify(context, null, 1);
+  return rendered.length > 6e3 ? rendered.slice(0, 6e3) + "\n\u2026(truncated)" : rendered;
 }
-function asConfidence(value) {
-  if (typeof value !== "number" || Number.isNaN(value)) return void 0;
-  return Math.min(1, Math.max(0, value));
+
+// src/engine/selection.ts
+var PII_SEGMENTS = /* @__PURE__ */ new Set([
+  "email",
+  "phone",
+  "address",
+  "surname",
+  "dob",
+  "birthday",
+  "birthdate",
+  "ssn",
+  "passport",
+  "password",
+  "username"
+]);
+var PII_PAIRS = [
+  ["first", "name"],
+  ["last", "name"],
+  ["full", "name"],
+  ["user", "name"],
+  ["middle", "name"],
+  ["maiden", "name"],
+  ["birth", "date"],
+  ["date", "birth"],
+  ["national", "id"],
+  ["government", "id"],
+  ["device", "id"],
+  ["personal", "number"],
+  ["social", "security"],
+  ["tax", "id"],
+  ["drivers", "license"]
+];
+function isPIIField(name) {
+  const segments = name.split("_");
+  if (segments.some((segment) => PII_SEGMENTS.has(segment))) {
+    return true;
+  }
+  for (let index = 0; index + 1 < segments.length; index += 1) {
+    if (PII_PAIRS.some(([a, b]) => segments[index] === a && segments[index + 1] === b)) {
+      return true;
+    }
+  }
+  return false;
 }
-function asWeight(value) {
-  if (typeof value !== "number" || Number.isNaN(value)) return void 0;
-  if (value < 0 || value > 1) return void 0;
-  return value;
+function normalizeEventCode(value) {
+  const collapsed = value.toLowerCase().trim().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").replace(/_{2,}/g, "_");
+  return /^[a-z]/.test(collapsed) ? collapsed : "";
 }
-function coerceEvent(entry) {
-  if (typeof entry !== "object" || entry === null) return null;
-  const e = entry;
-  const code = normalizeCode(asString(e.code) ?? "");
-  if (!code) return null;
-  const properties = [];
-  for (const prop of asArray(e.properties)) {
-    if (typeof prop === "string") {
-      if (prop.trim()) properties.push({ name: prop.trim() });
-      continue;
+function validateProposedEvent(input, seen, rejected) {
+  const code = normalizeEventCode(input.code);
+  if (code === "") {
+    return { ok: false, reason: `event code ${JSON.stringify(input.code)} is not snake_case` };
+  }
+  if (seen.has(code)) {
+    return { ok: false, reason: `event ${code} was already proposed` };
+  }
+  if (rejected.has(code)) {
+    return { ok: false, reason: `event ${code} was rejected by the user \u2014 do not re-propose it` };
+  }
+  if (!input.name.trim() || !input.reasoning.trim() || !input.anchorFile.trim()) {
+    return { ok: false, reason: "name, reasoning, and anchorFile are required" };
+  }
+  const schema = {};
+  for (const [field, description] of Object.entries(input.payloadSchema ?? {})) {
+    const normalizedField = normalizeEventCode(field);
+    if (normalizedField === "" || !description.trim()) {
+      return { ok: false, reason: `payload field ${JSON.stringify(field)} needs a snake_case name and a description` };
     }
-    if (typeof prop !== "object" || prop === null) continue;
-    const pr = prop;
-    const name = asString(pr.name);
-    if (!name) continue;
-    const desc = asString(pr.description);
-    properties.push({
-      name,
-      ...desc ? { description: desc } : {},
-      ...pr.required === true ? { required: true } : {}
-    });
+    if (isPIIField(normalizedField)) {
+      return { ok: false, reason: `payload field ${normalizedField} is a personal identifier and is not allowed` };
+    }
+    schema[normalizedField] = description.trim();
   }
-  const links = [];
-  for (const link of asArray(e.links)) {
-    if (typeof link !== "object" || link === null) continue;
-    const l = link;
-    const interventionCode = normalizeCode(asString(l.interventionCode) ?? "");
-    if (!interventionCode) continue;
-    const weight = asWeight(l.weight);
-    links.push({ interventionCode, ...weight !== void 0 ? { weight } : {} });
+  if (Object.keys(schema).length > 20) {
+    return { ok: false, reason: "payload schema exceeds 20 fields" };
   }
-  const side = normalizeSide(asString(e.side));
   return {
-    code,
-    label: asString(e.label),
-    description: asString(e.description),
-    ...side ? { side } : {},
-    rationale: asString(e.rationale),
-    expectedEffect: asString(e.expectedEffect),
-    confidence: asConfidence(e.confidence),
-    ...properties.length ? { properties } : {},
-    ...links.length ? { links } : {}
+    ok: true,
+    event: {
+      code,
+      name: input.name.trim(),
+      reasoning: input.reasoning.trim(),
+      anchorFile: input.anchorFile.trim(),
+      anchorSymbol: input.anchorSymbol?.trim() || void 0,
+      payloadSchema: schema
+    }
   };
 }
-function coerceIntervention(entry) {
-  if (typeof entry !== "object" || entry === null) return null;
-  const i = entry;
-  const code = normalizeCode(asString(i.code) ?? "");
-  if (!code) return null;
-  const links = [];
-  for (const link of asArray(i.links)) {
-    if (typeof link !== "object" || link === null) continue;
-    const l = link;
-    const eventCode = normalizeCode(asString(l.eventCode) ?? "");
-    if (!eventCode) continue;
-    const weight = asWeight(l.weight);
-    links.push({ eventCode, ...weight !== void 0 ? { weight } : {} });
-  }
-  return {
-    code,
-    label: asString(i.label),
-    description: asString(i.description),
-    rationale: asString(i.rationale),
-    expectedEffect: asString(i.expectedEffect),
-    confidence: asConfidence(i.confidence),
-    ...links.length ? { links } : {}
-  };
+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
+    },
+    models.survey,
+    (action) => sink.emit({ phase: "surveying", action })
+  );
+  return { report: outcome.kind === "completed" ? outcome.text : "", outcome };
 }
-function normalizeSide(value) {
-  switch (value?.toLowerCase()) {
-    case "frontend":
-      return "frontend";
-    case "backend":
-      return "backend";
-    case "either":
-      return "either";
-    default:
-      return void 0;
+async function runSelection(provider, models, repoPath, bootstrap, surveyReport, rejectedCodes, sink) {
+  const proposed = [];
+  const seen = /* @__PURE__ */ new Set();
+  const rejected = new Set(rejectedCodes);
+  let summary = "";
+  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")
+    },
+    jsonSchema: {
+      type: "object",
+      properties: {
+        code: { type: "string", description: "lowercase snake_case event code" },
+        name: { type: "string", description: "short human-readable name" },
+        reasoning: { type: "string", description: "why this event matters for this business" },
+        anchorFile: { type: "string", description: "repository file where the committed action happens" },
+        anchorSymbol: { type: "string", description: "function/symbol at the anchor" },
+        payloadSchema: {
+          type: "object",
+          additionalProperties: { type: "string" },
+          description: "important payload fields: name -> short description; no personal identifiers"
+        }
+      },
+      required: ["code", "name", "reasoning", "anchorFile"]
+    },
+    handler: async (input) => {
+      const candidate = {
+        code: String(input.code ?? ""),
+        name: String(input.name ?? ""),
+        reasoning: String(input.reasoning ?? ""),
+        anchorFile: String(input.anchorFile ?? ""),
+        anchorSymbol: input.anchorSymbol === void 0 ? void 0 : String(input.anchorSymbol),
+        payloadSchema: input.payloadSchema ?? {}
+      };
+      const validated = validateProposedEvent(candidate, seen, rejected);
+      if (!validated.ok) {
+        return { ok: false, reason: validated.reason };
+      }
+      seen.add(validated.event.code);
+      proposed.push(validated.event);
+      sink.emit({
+        phase: "designing",
+        file: validated.event.anchorFile,
+        action: `proposed ${validated.event.code}`
+      });
+      return { ok: true, code: validated.event.code };
+    }
+  };
+  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") },
+    jsonSchema: {
+      type: "object",
+      properties: { summary: { type: "string", description: "one line on what was selected and why" } },
+      required: ["summary"]
+    },
+    handler: async (input) => {
+      summary = String(input.summary ?? "");
+      return { ok: true };
+    }
+  };
+  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),
+        bootstrap.snapshot.events.map((event) => event.code),
+        rejectedCodes
+      ),
+      tools: [proposeTool, finishTool],
+      allowRepoWrite: false,
+      cwd: repoPath
+    },
+    models.design,
+    (action) => sink.emit({ phase: "designing", action })
+  );
+  return {
+    outcome: outcome.kind,
+    proposed,
+    summary,
+    surveyReport,
+    sessionId: outcome.sessionId
+  };
+}
+async function registerApprovedEvents(runs, runId, approved, sink) {
+  const registered = [];
+  for (const event of approved) {
+    const result = await runs.writeItem(runId, "event", {
+      code: event.code,
+      name: event.name,
+      reasoning: event.reasoning,
+      ...Object.keys(event.payloadSchema).length > 0 ? { payloadSchema: event.payloadSchema } : {}
+    });
+    const item = result.item;
+    registered.push({ ...event, eventId: item?.id ?? result.id ?? "" });
+    sink.emit({ phase: "persisting", file: event.anchorFile, action: `registered ${event.code}` });
+  }
+  return registered;
+}
+function placementsFor(registered) {
+  return registered.map((event) => ({
+    eventId: event.eventId,
+    eventCode: event.code,
+    file: event.anchorFile,
+    symbol: event.anchorSymbol,
+    status: "planned"
+  }));
+}
+
+// src/engine/state.ts
+import { createHash as createHash3 } from "crypto";
+import { mkdirSync, readFileSync as readFileSync2, renameSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join as join4 } from "path";
+
+// src/engine/types.ts
+var ENGINE_PHASES = [
+  "authorizing",
+  "surveying",
+  "designing",
+  "persisting",
+  "binding",
+  "integrating",
+  "reviewing",
+  "verifying",
+  "reporting",
+  "completed"
+];
+
+// src/engine/state.ts
+function stateDirectory() {
+  const override = process.env.WHISPERR_WIZARD_STATE_DIR?.trim();
+  if (override) {
+    return override;
+  }
+  return join4(homedir(), ".whisperr", "wizard-runs");
+}
+function stateKey(apiBaseUrl, appId, repoFingerprint2) {
+  return createHash3("sha256").update(`${apiBaseUrl}
+${appId}
+${repoFingerprint2}`).digest("hex").slice(0, 24);
+}
+function statePath(apiBaseUrl, appId, repoFingerprint2) {
+  return join4(stateDirectory(), `${stateKey(apiBaseUrl, appId, repoFingerprint2)}.json`);
+}
+function saveRunState(state) {
+  const path = statePath(state.apiBaseUrl, state.appId, state.repoFingerprint);
+  mkdirSync(stateDirectory(), { recursive: true, mode: 448 });
+  const payload = JSON.stringify({ ...state, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2);
+  const temporary = `${path}.tmp`;
+  writeFileSync(temporary, payload, { mode: 384 });
+  renameSync(temporary, path);
+}
+function loadRunState(apiBaseUrl, appId, repoFingerprint2) {
+  const path = statePath(apiBaseUrl, appId, repoFingerprint2);
+  let raw;
+  try {
+    raw = readFileSync2(path, "utf8");
+  } catch {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  if (!isEngineRunState(parsed)) {
+    return void 0;
+  }
+  if (parsed.apiBaseUrl !== apiBaseUrl || parsed.appId !== appId || parsed.repoFingerprint !== repoFingerprint2) {
+    return void 0;
+  }
+  return parsed;
+}
+function isEngineRunState(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  return candidate.version === 1 && typeof candidate.apiBaseUrl === "string" && typeof candidate.appId === "string" && typeof candidate.repoFingerprint === "string" && typeof candidate.runId === "string" && typeof candidate.phase === "string" && ENGINE_PHASES.includes(candidate.phase) && typeof candidate.designComplete === "boolean" && Array.isArray(candidate.tombstonedCodes) && Array.isArray(candidate.clusters) && typeof candidate.providerSessions === "object" && candidate.providerSessions !== null;
+}
+
+// src/engine/worktree.ts
+import { spawn as spawn2 } from "child_process";
+import { mkdtemp, writeFile as writeFile2 } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join5 } from "path";
+var WorktreeError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "WorktreeError";
+  }
+  code;
+};
+function git(cwd, args) {
+  return new Promise((resolve4) => {
+    const child = spawn2("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", () => resolve4({ ok: false, stdout, stderr: "git is not available" }));
+    child.on("close", (exitCode) => resolve4({ ok: exitCode === 0, stdout, stderr }));
+  });
+}
+async function must(cwd, args) {
+  const result = await git(cwd, args);
+  if (!result.ok) {
+    throw new WorktreeError("git_failed", `git ${args.join(" ")}: ${result.stderr.trim()}`);
+  }
+  return result.stdout;
+}
+async function createWorktree(repoPath, force = false) {
+  const inside = await git(repoPath, ["rev-parse", "--is-inside-work-tree"]);
+  if (!inside.ok) {
+    throw new WorktreeError("not_a_repo", "the target directory is not a git repository");
+  }
+  const status = await must(repoPath, ["status", "--porcelain"]);
+  if (status.trim() !== "" && !force) {
+    throw new WorktreeError(
+      "dirty_repo",
+      "the repository has uncommitted changes \u2014 commit or stash them, or rerun with --force"
+    );
+  }
+  const baseRef = (await must(repoPath, ["rev-parse", "HEAD"])).trim();
+  const path = await mkdtemp(join5(tmpdir(), "whisperr-worktree-"));
+  await must(repoPath, ["worktree", "add", "--detach", "--force", path, "HEAD"]);
+  return { path, baseRef, repoPath };
+}
+async function worktreePatch(handle) {
+  await must(handle.path, ["add", "-A"]);
+  return must(handle.path, ["diff", "--cached", "--binary", handle.baseRef]);
+}
+async function applyPatchToRepo(handle, patch) {
+  if (patch.trim() === "") {
+    return;
+  }
+  await new Promise((resolve4, reject) => {
+    const child = spawn2("git", ["apply", "--whitespace=nowarn"], {
+      cwd: handle.repoPath,
+      stdio: ["pipe", "ignore", "pipe"]
+    });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", (error) => reject(new WorktreeError("git_failed", String(error))));
+    child.on("close", (exitCode) => {
+      if (exitCode === 0) {
+        resolve4();
+      } else {
+        reject(new WorktreeError("git_failed", `git apply failed: ${stderr.trim()}`));
+      }
+    });
+    child.stdin.end(patch);
+  });
+}
+async function savePartialPatch(handle, destination) {
+  const patch = await worktreePatch(handle);
+  if (patch.trim() === "") {
+    return void 0;
+  }
+  await writeFile2(destination, patch, { mode: 384 });
+  return destination;
+}
+async function removeWorktree(handle) {
+  await git(handle.repoPath, ["worktree", "remove", "--force", handle.path]);
+  await git(handle.repoPath, ["worktree", "prune"]);
+}
+
+// src/engine/orchestrator.ts
+async function runEngine(input) {
+  const runs = new RunsClient(input.config, input.session);
+  let bootstrap;
+  try {
+    bootstrap = await runs.createOrResumeRun({
+      repoFingerprint: input.repoFingerprint,
+      displayName: basename(input.repoPath),
+      target: input.target,
+      kind: input.projectKind
+    });
+  } catch (error) {
+    if (error instanceof RunsApiError && error.code === "wrong_universe_mode") {
+      return { kind: "wrong_mode" };
+    }
+    throw error;
+  }
+  const runId = bootstrap.run.id;
+  input.provider.onRunReady?.(runId);
+  const patchPhase = async (phase, message) => {
+    try {
+      await runs.patchRun(runId, { phase, ...message ? { message } : {} });
+    } catch {
+    }
+  };
+  const failRun = async (error) => {
+    try {
+      await runs.patchRun(runId, { status: "failed", error: error.slice(0, 500) });
+    } catch {
+    }
+  };
+  let state = loadRunState(input.config.apiBaseUrl, input.session.appId, input.repoFingerprint) ?? freshState(input, runId);
+  if (state.runId !== runId) {
+    state = freshState(input, runId);
+  }
+  const persist = () => saveRunState(state);
+  let registered;
+  if (!state.designComplete) {
+    await patchPhase("surveying");
+    const survey = await runSurvey(
+      input.provider,
+      input.models,
+      input.repoPath,
+      bootstrap,
+      input.sink,
+      state.providerSessions.survey
+    );
+    if (survey.outcome.kind !== "completed") {
+      await failRun(`survey ${survey.outcome.kind}`);
+      return { kind: "aborted", reason: `survey ${survey.outcome.kind}` };
+    }
+    state.providerSessions.survey = survey.outcome.sessionId;
+    persist();
+    await patchPhase("designing");
+    const selection = await runSelection(
+      input.provider,
+      input.models,
+      input.repoPath,
+      bootstrap,
+      survey.report,
+      state.tombstonedCodes,
+      input.sink
+    );
+    if (selection.outcome !== "completed" && selection.proposed.length === 0) {
+      await failRun(`selection ${selection.outcome}`);
+      return { kind: "aborted", reason: `selection ${selection.outcome}` };
+    }
+    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" };
+    }
+    const approvedCodes = new Set(approved.map((event) => event.code));
+    for (const event of selection.proposed) {
+      if (!approvedCodes.has(event.code) && !state.tombstonedCodes.includes(event.code)) {
+        state.tombstonedCodes.push(event.code);
+      }
+    }
+    persist();
+    await patchPhase("persisting", `registering ${approved.length} events`);
+    try {
+      registered = await registerApprovedEvents(runs, runId, approved, input.sink);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      await failRun(`event registration failed: ${reason}`);
+      persist();
+      return { kind: "aborted", reason: `event registration failed: ${reason}` };
+    }
+    state.designComplete = true;
+    state.clusters = deriveClusters(placementsFor(registered));
+    persist();
+  } else {
+    registered = rebuildRegistered(state, bootstrap);
+    input.sink.emit({ phase: "designing", action: `resumed with ${registered.length} registered events` });
+  }
+  if (registered.length === 0) {
+    await patchPhase("reporting", "no events registered for this project");
+    await completeRun(runs, runId, [], /* @__PURE__ */ new Map(), [], true, "unavailable", void 0);
+    return {
+      kind: "completed",
+      runId,
+      registered,
+      eventStatuses: /* @__PURE__ */ new Map(),
+      reportEvents: [],
+      changedFiles: [],
+      identifyWired: false,
+      applied: false,
+      summary: "No important events found for this project; nothing was instrumented."
+    };
+  }
+  await patchPhase("binding");
+  let worktree;
+  try {
+    worktree = await createWorktree(input.repoPath, input.force ?? false);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    await failRun(reason);
+    return { kind: "aborted", reason };
+  }
+  state.worktreePath = worktree.path;
+  persist();
+  try {
+    const bindings = await writeBindingsModule(worktree, input.target, registered);
+    const deps = {
+      provider: input.provider,
+      models: input.models,
+      worktree,
+      target: input.target,
+      playbookSystemPrompt: input.playbookSystemPrompt,
+      registered,
+      ingestion: bootstrap.ingestion,
+      sink: input.sink,
+      saveClusters: (clusters) => {
+        state.clusters = clusters;
+        persist();
+      }
+    };
+    const identifyWired = await runSdkSetupPass(deps, bindings);
+    await patchPhase("integrating");
+    const integration = await runClusterIntegration(
+      deps,
+      state.clusters,
+      async () => worktreePatch(worktree)
+    );
+    state.clusters = integration.clusters;
+    persist();
+    const finalVerify = await finalizeIntegration(deps);
+    const patch = await worktreePatch(worktree);
+    const changedFiles2 = patchFiles(patch);
+    await patchPhase("reporting");
+    const evidence = buildEvidence(registered, integration.eventStatuses, changedFiles2);
+    await completeRun(
+      runs,
+      runId,
+      evidence,
+      integration.eventStatuses,
+      changedFiles2,
+      identifyWired,
+      finalVerify.status,
+      finalVerify.command
+    );
+    const summaryLines = summarize(registered, integration.eventStatuses);
+    const applied = patch.trim() !== "" && await input.callbacks.confirmApply(patch, summaryLines);
+    if (applied) {
+      await applyPatchToRepo(worktree, patch);
+    }
+    const partialPatchPath = applied ? void 0 : await savePartialPatch(worktree, join6(input.repoPath, ".whisperr-wizard.patch"));
+    await removeWorktree(worktree);
+    state.worktreePath = void 0;
+    persist();
+    const hasFailures = [...integration.eventStatuses.values()].some(
+      (status) => status === "failed"
+    );
+    return {
+      kind: hasFailures ? "partial" : "completed",
+      runId,
+      registered,
+      eventStatuses: integration.eventStatuses,
+      reportEvents: buildReportEvents(registered, integration.eventStatuses),
+      changedFiles: changedFiles2,
+      identifyWired,
+      applied,
+      partialPatchPath: partialPatchPath ?? void 0,
+      summary: summaryLines.join("\n")
+    };
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    await failRun(reason);
+    const partialPatchPath = await savePartialPatch(
+      worktree,
+      join6(input.repoPath, ".whisperr-wizard.patch")
+    ).catch(() => void 0);
+    persist();
+    return {
+      kind: "partial",
+      runId,
+      registered,
+      eventStatuses: /* @__PURE__ */ new Map(),
+      reportEvents: buildReportEvents(registered, /* @__PURE__ */ new Map()),
+      changedFiles: [],
+      identifyWired: false,
+      applied: false,
+      partialPatchPath: partialPatchPath ?? void 0,
+      summary: `Integration stopped early: ${reason}. Registered events are saved; rerun to resume.`
+    };
+  }
+}
+function freshState(input, runId) {
+  return {
+    version: 1,
+    apiBaseUrl: input.config.apiBaseUrl,
+    appId: input.session.appId,
+    repoFingerprint: input.repoFingerprint,
+    runId,
+    phase: "authorizing",
+    providerSessions: {},
+    designComplete: false,
+    tombstonedCodes: [],
+    clusters: [],
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function rebuildRegistered(state, bootstrap) {
+  const byCode = new Map(bootstrap.snapshot.events.map((event) => [event.code, event]));
+  const registered = [];
+  for (const cluster of state.clusters) {
+    for (const placement of cluster.events) {
+      const event = byCode.get(placement.eventCode);
+      if (!event) {
+        continue;
+      }
+      registered.push({
+        code: event.code,
+        name: event.name,
+        reasoning: event.reasoning,
+        eventId: event.id,
+        anchorFile: placement.file,
+        anchorSymbol: placement.symbol,
+        payloadSchema: event.payloadSchema ?? {}
+      });
+    }
+  }
+  return registered;
+}
+function buildEvidence(registered, statuses, changedFiles2) {
+  const changed = new Set(changedFiles2);
+  return registered.map((event) => {
+    const status = statuses.get(event.code) ?? "planned";
+    const needsFile = status !== "planned" && status !== "unsupported" && status !== "failed";
+    const file = changed.has(event.anchorFile) ? event.anchorFile : changedFiles2[0];
+    return {
+      eventId: event.eventId,
+      eventCode: event.code,
+      ...needsFile && file ? { file } : {},
+      status
+    };
+  });
+}
+async function completeRun(runs, runId, evidence, _statuses, changedFiles2, identifyWired, verificationStatus, verificationCommand2) {
+  try {
+    await runs.completeRun(runId, {
+      changedFiles: changedFiles2,
+      identifyWired,
+      verificationStatus,
+      ...verificationCommand2 ? { verificationCommand: verificationCommand2 } : {},
+      events: evidence
+    });
+  } catch {
+  }
+}
+function buildReportEvents(registered, statuses) {
+  return registered.map((event) => {
+    const status = statuses.get(event.code);
+    const wired = status !== void 0 && status !== "failed" && status !== "unsupported" && status !== "planned";
+    return {
+      event_type: event.code,
+      status: wired ? "wired" : "skipped",
+      ...wired ? { file: event.anchorFile } : {},
+      ...wired ? {} : { reason: status ?? "not integrated" }
+    };
+  });
+}
+function summarize(registered, statuses) {
+  return registered.map((event) => {
+    const status = statuses.get(event.code) ?? "planned";
+    return `${event.code}: ${status} (${event.anchorFile})`;
+  });
+}
+function patchFiles(patch) {
+  const files = /* @__PURE__ */ new Set();
+  for (const line of patch.split("\n")) {
+    const match = /^diff --git a\/(.+?) b\//.exec(line);
+    if (match?.[1]) {
+      files.add(match[1]);
+    }
+  }
+  return [...files];
+}
+
+// src/engine/providers/claude.ts
+import { createSdkMcpServer, query as query2, tool } from "@anthropic-ai/claude-agent-sdk";
+
+// src/core/agent.ts
+import {
+  query
+} from "@anthropic-ai/claude-agent-sdk";
+
+// src/core/git.ts
+import { spawn as spawn3 } from "child_process";
+import { createHash as createHash4 } from "crypto";
+import { readFile as readFile2 } from "fs/promises";
+import { basename as basename2, join as join7 } from "path";
+async function takeCheckpoint(repoPath) {
+  const isRepo = (await run(repoPath, ["rev-parse", "--is-inside-work-tree"])).ok;
+  if (!isRepo) return { isRepo: false };
+  const branch = (await run(repoPath, ["rev-parse", "--abbrev-ref", "HEAD"])).stdout.trim();
+  const head = await run(repoPath, ["rev-parse", "HEAD"]);
+  return {
+    isRepo: true,
+    baseRef: head.ok ? head.stdout.trim() : void 0,
+    branch: branch || void 0
+  };
+}
+async function changedFiles(repoPath, checkpoint) {
+  if (!checkpoint.isRepo) return [];
+  const tracked = await run(repoPath, ["diff", "--name-only"]);
+  const untracked = await run(repoPath, [
+    "ls-files",
+    "--others",
+    "--exclude-standard"
+  ]);
+  const set = /* @__PURE__ */ new Set();
+  for (const f of `${tracked.stdout}
+${untracked.stdout}`.split("\n")) {
+    if (f.trim()) set.add(f.trim());
+  }
+  return [...set];
+}
+function revertHint(checkpoint) {
+  if (!checkpoint.isRepo || !checkpoint.baseRef) return void 0;
+  return `git restore . && git clean -fd   (back to ${checkpoint.baseRef.slice(0, 7)})`;
+}
+async function isWorkingTreeClean(repoPath) {
+  const status = await run(repoPath, ["status", "--porcelain"]);
+  return status.ok && status.stdout.trim() === "";
+}
+async function revertToCheckpoint(repoPath, checkpoint) {
+  if (!checkpoint.isRepo) return false;
+  if (checkpoint.baseRef) {
+    const reset = await run(repoPath, ["reset", "--hard", checkpoint.baseRef]);
+    const clean2 = await run(repoPath, ["clean", "-fd"]);
+    return reset.ok && clean2.ok;
+  }
+  const restore = await run(repoPath, ["restore", "."]);
+  const clean = await run(repoPath, ["clean", "-fd"]);
+  return restore.ok && clean.ok;
+}
+async function repoFingerprint(repoPath) {
+  const remote = await run(repoPath, ["remote", "get-url", "origin"]);
+  const seed = remote.ok && remote.stdout.trim() ? normalizeRemote(remote.stdout.trim()) : `dir:${basename2(repoPath)}`;
+  return createHash4("sha256").update(seed).digest("hex").slice(0, 16);
+}
+function normalizeRemote(url) {
+  return url.replace(/^git@([^:]+):/, "$1/").replace(/^https?:\/\//, "").replace(/\.git$/, "").replace(/\/+$/, "").toLowerCase();
+}
+async function scanWiredEvents(repoPath, files, eventTypes) {
+  const wired = /* @__PURE__ */ new Map();
+  const patterns = eventTypes.map((e) => ({
+    eventType: e,
+    trackRe: new RegExp(
+      `\\btrack\\s*\\(\\s*[\\s\\S]{0,160}?['"\`]${escapeRegExp(e)}['"\`]`
+    ),
+    literalRe: quotedLiteralRegExp(e)
+  }));
+  const contents = [];
+  for (const file of files) {
+    try {
+      contents.push({ file, content: await readFile2(join7(repoPath, file), "utf8") });
+    } catch {
+      continue;
+    }
+  }
+  for (const { file, content } of contents) {
+    for (const { eventType, trackRe } of patterns) {
+      if (!wired.has(eventType) && trackRe.test(content)) {
+        wired.set(eventType, file);
+      }
+    }
+  }
+  for (const { file, content } of contents) {
+    for (const { eventType, literalRe } of patterns) {
+      if (!wired.has(eventType) && literalRe.test(content)) {
+        wired.set(eventType, file);
+      }
+    }
   }
+  return wired;
+}
+function quotedLiteralRegExp(eventType) {
+  const leftBoundary = /^\w/.test(eventType) ? "\\b" : "";
+  const rightBoundary = /\w$/.test(eventType) ? "\\b" : "";
+  return new RegExp(`(['"\`])${leftBoundary}${escapeRegExp(eventType)}${rightBoundary}\\1`);
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function run(cwd, args) {
+  return new Promise((resolve4) => {
+    const child = spawn3("git", args, { cwd });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => stdout += d.toString());
+    child.stderr.on("data", (d) => stderr += d.toString());
+    child.on("close", (code) => resolve4({ ok: code === 0, stdout, stderr }));
+    child.on("error", () => resolve4({ ok: false, stdout, stderr }));
+  });
 }
 
 // src/core/playbooks/shared-prompt.ts
@@ -1761,64 +3039,60 @@ function renderEventsBrief(m) {
     if (e.description) lines.push(`  ${e.description}`);
     if (e.properties?.length) {
       lines.push("  properties to capture if available:");
-      for (const p2 of e.properties) {
-        const req = p2.required ? " (required)" : "";
-        const desc = p2.description ? ` \u2014 ${p2.description}` : "";
-        lines.push(`    \xB7 ${p2.name}${req}${desc}`);
+      for (const p3 of e.properties) {
+        const req = p3.required ? " (required)" : "";
+        const desc = p3.description ? ` \u2014 ${p3.description}` : "";
+        lines.push(`    \xB7 ${p3.name}${req}${desc}`);
       }
     }
   }
   return lines.join("\n");
 }
-function renderOpportunitiesBrief(m, opportunitiesFile) {
+function renderOpportunitiesBrief(m) {
   const eventCodes = m.events.map((e) => e.eventType);
   const interventionCodes = [
-    ...new Set(m.events.flatMap((e) => e.interventions ?? []).map((i) => i.code))
+    .../* @__PURE__ */ new Set([
+      ...m.events.flatMap((e) => e.interventions ?? []).map((i) => i.code),
+      ...(m.interventions ?? []).map((i) => i.code)
+    ])
   ];
   return [
-    "UNIVERSE OPPORTUNITIES (do this LAST, after your corrections):",
-    "While auditing you read this app's real lifecycle. Now sweep it",
-    "deliberately: walk each surface the plan should care about \u2014 signup and",
-    "auth, billing/payments (renewals, failures, upgrades, downgrades,",
-    "cancellation), the core engagement loop, support/feedback/refund flows,",
-    "sharing/invites, and any expiry or dormancy mechanics you saw \u2014 and for",
-    "each one ask: does a churn-relevant moment happen here that the plan does",
-    "NOT cover? Record those as PROPOSALS. Do NOT add track() calls for them.",
-    `Write a single JSON file at the repo root named ${opportunitiesFile}:`,
+    "Rules for `opportunities` \u2014 what this app's plan is MISSING:",
+    "You are reading this app's real lifecycle anyway. Sweep it deliberately:",
+    "walk each surface the plan should care about \u2014 signup and auth,",
+    "billing/payments (renewals, failures, upgrades, downgrades, cancellation),",
+    "the core engagement loop, support/feedback/refund flows, sharing/invites,",
+    "and any expiry or dormancy mechanics you see \u2014 and for each ask: does a",
+    "churn-relevant moment happen here that the plan does NOT cover?",
     "",
-    "{",
-    '  "events": [{',
-    '    "code": "snake_case_event", "label": "...", "description": "...",',
+    "Entry shapes:",
+    '  events: [{"code": "snake_case_event", "label": "...", "description": "...",',
     '    "side": "frontend|backend|either", "rationale": "what in the code shows this",',
     '    "expectedEffect": "one sentence: what improves if this is adopted",',
     '    "confidence": 0.0-1.0,',
     '    "properties": [{"name": "...", "description": "...", "required": false}],',
-    '    "links": [{"interventionCode": "existing_or_proposed", "weight": 0.0-1.0}]',
-    "  }],",
-    '  "interventions": [{',
-    '    "code": "snake_case_strategy", "label": "...", "description": "...",',
-    '    "rationale": "...", "confidence": 0.0-1.0,',
-    '    "expectedEffect": "one sentence: what improves if this is adopted",',
-    '    "links": [{"eventCode": "existing_or_proposed", "weight": 0.0-1.0}]',
-    "  }]",
-    "}",
+    '    "links": [{"interventionCode": "existing_or_proposed", "weight": 0.0-1.0}]}]',
+    '  interventions: [{"code": "snake_case_strategy", "label": "...", "description": "...",',
+    '    "rationale": "...", "confidence": 0.0-1.0, "expectedEffect": "...",',
+    '    "links": [{"eventCode": "existing_or_proposed", "weight": 0.0-1.0}]}]',
     "",
-    "Rules:",
     `- The plan already covers these events: ${eventCodes.join(", ") || "(none)"}.`,
     `  And these interventions: ${interventionCodes.join(", ") || "(none)"}.`,
     "  Propose ONLY what is genuinely missing \u2014 never re-propose or rename these.",
-    "- Every proposal needs concrete code evidence in its rationale (file/flow),",
-    "  not speculation. VERIFY before you write: re-open the file you are citing",
-    "  and confirm the flow exists as described \u2014 a false suggestion costs more",
-    "  trust than a missed one, so drop anything you cannot point at real code.",
+    "- These go straight into the customer's universe, and the events you propose",
+    "  get instrumented in this same run. That raises the bar on evidence, not the",
+    "  volume: every proposal needs concrete code backing in its rationale, with",
+    "  the file/flow named. VERIFY before you write it \u2014 re-open the file you are",
+    "  citing and confirm the flow exists as you describe. Drop anything you",
+    "  cannot point at real code; a false proposal costs more trust than a missed one.",
+    "- Say where you saw it in `rationale` precisely enough to wire from later \u2014",
+    "  it is the only placement note the wiring pass will have for these.",
     "- Be thorough, not shy: a feature-rich product typically yields 3-6 solid",
-    "  event proposals and 1-3 interventions. An empty file is only the right",
-    "  answer when the plan genuinely already covers the product's lifecycle \u2014",
-    "  never because you stopped looking early.",
-    "- Every proposal should include expectedEffect: one sentence explaining what adoption should improve.",
+    "  event proposals and 1-3 interventions. Empty is only right when the plan",
+    "  genuinely covers the product's lifecycle \u2014 never because you stopped early.",
+    "- Every proposal should include expectedEffect: one sentence on what adoption improves.",
     "- Link each proposed event to the intervention(s) it should feed (existing",
-    "  codes or ones you propose in the same file).",
-    "- This file is metadata for the wizard, not app code \u2014 write it and move on."
+    "  codes or ones you propose alongside it)."
   ].join("\n");
 }
 function coverageNote(coverage) {
@@ -2140,36 +3414,56 @@ function tokenizeShellSegment(segment) {
 
 // src/core/agent.ts
 async function runIntegrationAgent(opts) {
-  const { repoPath, config, session, playbook, manifest, progress, onPlanReady } = opts;
-  applyModelAuthEnv(config, session);
-  const systemPrompt9 = [BASE_WIZARD_PROMPT, playbook.systemPrompt].join("\n\n");
-  const started = Date.now();
+  const {
+    repoPath,
+    config,
+    session,
+    playbook,
+    manifest,
+    progress,
+    onPlanReady,
+    onOpportunitiesReady
+  } = opts;
+  applyModelAuthEnv(config, session);
+  const systemPrompt9 = [BASE_WIZARD_PROMPT, playbook.systemPrompt].join("\n\n");
+  const started = Date.now();
   let costUsd = 0;
   const summaries = [];
   let repoMap = "";
   let eventOutcomes = [];
   const phaseTimings = [];
   const BUDGET_FLOOR = 0.25;
+  let planning = { repoMap: "", plan: null, opportunities: emptyOpportunities() };
   if (config.budgetUsd - costUsd > BUDGET_FLOOR) {
     try {
-      const map = await runTimedPass("Mapping your codebase", {
-        prompt: renderRepoMapPrompt(repoPath),
+      const pass = await runTimedPass("Planning your integration", {
+        prompt: renderPlanningPrompt(repoPath, playbook, manifest),
         systemPrompt: systemPrompt9,
         repoPath,
         model: config.plannerModel,
         effort: "high",
-        maxTurns: 40,
-        budgetUsd: Math.min(config.budgetUsd - costUsd, config.budgetUsd * 0.15),
+        maxTurns: 60,
+        budgetUsd: Math.min(config.budgetUsd - costUsd, config.budgetUsd * 0.3),
         allowedTools: READ_ONLY_TOOLS,
         progress
       }, phaseTimings);
-      costUsd += map.costUsd;
-      repoMap = sliceRepoMap(map.summary);
+      costUsd += pass.costUsd;
+      planning = parsePlanningResult(pass.summary);
     } catch (err) {
-      debugNote(`repo map pass failed: ${err.message}`);
-      repoMap = "";
+      debugNote(`planning pass failed: ${err.message}`);
+    }
+  }
+  repoMap = planning.repoMap;
+  let scopedPlan = null;
+  if (planning.plan) {
+    scopedPlan = planForManifest(planning.plan, manifest);
+    const reviewedPlan = await onPlanReady?.(scopedPlan);
+    if (reviewedPlan !== void 0 && reviewedPlan !== null) {
+      scopedPlan = planForManifest(reviewedPlan, manifest);
     }
   }
+  let appliedOpportunityEvents = [];
+  const opportunitiesProposed = planning.opportunities.events.length + planning.opportunities.interventions.length;
   const corePrompt = [
     `Integrate the Whisperr ${playbook.target.displayName} SDK \u2014 CORE SETUP ONLY.`,
     `Project root: ${repoPath}`,
@@ -2212,6 +3506,13 @@ async function runIntegrationAgent(opts) {
   costUsd += core.costUsd;
   if (core.summary) summaries.push(`Core setup:
 ${core.summary}`);
+  if (onOpportunitiesReady && opportunitiesProposed > 0 && core.ok) {
+    try {
+      appliedOpportunityEvents = await onOpportunitiesReady(planning.opportunities);
+    } catch (err) {
+      debugNote(`universe additions failed: ${err.message}`);
+    }
+  }
   let eventsComplete = true;
   if (manifest.events.length > 0 && config.budgetUsd - costUsd <= BUDGET_FLOOR) {
     eventsComplete = false;
@@ -2224,20 +3525,7 @@ ${core.summary}`);
       "Events: skipped \u2014 the spend limit was reached during core setup. Re-run with a higher WHISPERR_WIZARD_BUDGET_USD to instrument events."
     );
   } else if (manifest.events.length > 0) {
-    const planPass = await runTimedPass("Planning event placements", {
-      prompt: renderEventPlanPrompt(repoPath, playbook, manifest, repoMap),
-      systemPrompt: systemPrompt9,
-      repoPath,
-      model: config.plannerModel,
-      effort: "high",
-      maxTurns: 40,
-      budgetUsd: config.budgetUsd - costUsd,
-      allowedTools: READ_ONLY_TOOLS,
-      progress
-    }, phaseTimings);
-    costUsd += planPass.costUsd;
-    const plan = parseEventPlan(planPass.summary);
-    if (!plan) {
+    if (!scopedPlan) {
       debugNote("event plan parse failed; falling back to direct event wiring");
       progress?.onActivity?.("Event plan was not parseable; falling back to direct wiring");
       const direct = await runDirectEventsPass({
@@ -2257,21 +3545,23 @@ ${core.summary}`);
       if (direct.pass.summary) summaries.push(`Events:
 ${direct.pass.summary}`);
     } else {
-      let scopedPlan = planForManifest(plan, manifest);
-      const reviewedPlan = await onPlanReady?.(scopedPlan);
-      if (reviewedPlan !== void 0 && reviewedPlan !== null) {
-        scopedPlan = planForManifest(reviewedPlan, manifest);
-      }
       const placeEntries = scopedPlan.filter((entry) => entry.decision === "place");
       const unsureEntries = scopedPlan.filter((entry) => entry.decision === "unsure");
       let wire;
-      if (placeEntries.length && config.budgetUsd - costUsd > BUDGET_FLOOR) {
+      const hasWorkToWire = placeEntries.length > 0 || appliedOpportunityEvents.length > 0;
+      if (hasWorkToWire && config.budgetUsd - costUsd > BUDGET_FLOOR) {
         wire = await runTimedPass("Instrumenting planned events", {
-          prompt: renderEventWirePrompt(repoPath, playbook, repoMap, placeEntries),
+          prompt: renderEventWirePrompt(
+            repoPath,
+            playbook,
+            repoMap,
+            placeEntries,
+            appliedOpportunityEvents
+          ),
           systemPrompt: systemPrompt9,
           repoPath,
           model: config.model,
-          effort: "high",
+          effort: "medium",
           maxTurns: config.maxTurns,
           budgetUsd: config.budgetUsd - costUsd,
           progress
@@ -2279,7 +3569,7 @@ ${direct.pass.summary}`);
         costUsd += wire.costUsd;
         if (wire.summary) summaries.push(`Events:
 ${wire.summary}`);
-      } else if (!placeEntries.length) {
+      } else if (!hasWorkToWire) {
         summaries.push("Events: no events had a confident placement in this surface.");
       }
       let wired = await scanManifestEvents(repoPath, manifest);
@@ -2303,7 +3593,7 @@ ${followUp.summary}`);
         wired = await scanManifestEvents(repoPath, manifest);
       }
       eventOutcomes = buildEventOutcomes(manifest, scopedPlan, wired);
-      eventsComplete = !planPass.maxedOut && !(wire?.maxedOut ?? false) && !(followUp?.maxedOut ?? false);
+      eventsComplete = !(wire?.maxedOut ?? false) && !(followUp?.maxedOut ?? false);
     }
   }
   if (core.ok && config.budgetUsd - costUsd > BUDGET_FLOOR) {
@@ -2313,7 +3603,7 @@ ${followUp.summary}`);
       `Project root: ${repoPath}`,
       "",
       ...renderRepoMapSection(repoMap),
-      "Run `git diff` and read the surrounding code to see exactly what you added.",
+      "Run `git diff` and read ONLY the code immediately around each change.",
       "For every identify() and track() call, verify \u2014 and FIX in place:",
       "1. Subject \u2014 keys to the END USER, never an admin/staff/operator/seller.",
       "   identify() sits on the SAME surface as account_created (same person).",
@@ -2327,21 +3617,19 @@ ${followUp.summary}`);
       "   / payment_source / amount / plan). Add the ones you missed.",
       "4. Coverage \u2014 every gateway/callback path that should emit an event does;",
       "   no recurring or secondary path left as a dead zone.",
-      "Change ONLY what is genuinely wrong or incomplete \u2014 do not churn correct",
-      "calls or re-explore the whole repo. Be surgical.",
-      "",
-      renderOpportunitiesBrief(manifest, OPPORTUNITIES_FILE),
+      "Work from the diff. Do NOT re-explore the repository, do NOT propose new",
+      "events, and change ONLY what is genuinely wrong or incomplete. Be surgical.",
       "",
       "End with a one-line, plain-text note of what you corrected (or 'No",
-      "corrections needed.'), plus one line on what you proposed, if anything."
+      "corrections needed.')."
     ].join("\n");
     const review = await runTimedPass("Reviewing & correcting placements", {
       prompt: reviewPrompt,
       systemPrompt: systemPrompt9,
       repoPath,
-      model: config.plannerModel,
+      model: config.strictReview ? config.plannerModel : config.model,
       effort: "medium",
-      maxTurns: 40,
+      maxTurns: config.strictReview ? 40 : 15,
       budgetUsd: config.budgetUsd - costUsd,
       progress
     }, phaseTimings);
@@ -2364,57 +3652,11 @@ ${review.summary}`);
     coreOk: core.ok,
     eventsComplete,
     eventOutcomes,
-    repoMap: repoMap || void 0
+    repoMap: repoMap || void 0,
+    opportunitiesProposed,
+    opportunitiesApplied: appliedOpportunityEvents.length
   };
 }
-async function runAdditionsInstrumentationPass(opts) {
-  const { repoPath, config, session, playbook, acceptedEvents, budgetUsd, repoMap, progress } = opts;
-  if (!acceptedEvents.length || budgetUsd <= 0) {
-    return { summary: "", costUsd: 0, ran: false };
-  }
-  applyModelAuthEnv(config, session);
-  const systemPrompt9 = [BASE_WIZARD_PROMPT, playbook.systemPrompt].join("\n\n");
-  const eventLines = [];
-  for (const e of acceptedEvents) {
-    eventLines.push("");
-    eventLines.push(`\u25A0 ${e.code}${e.label ? `  (${e.label})` : ""}`);
-    if (e.description) eventLines.push(`  ${e.description}`);
-    if (e.rationale) eventLines.push(`  where: ${e.rationale}`);
-    if (e.properties?.length) {
-      eventLines.push("  properties to capture if available:");
-      for (const prop of e.properties) {
-        eventLines.push(`    \xB7 ${prop.name}${prop.required ? " (required)" : ""}${prop.description ? ` \u2014 ${prop.description}` : ""}`);
-      }
-    }
-  }
-  progress?.onPhase?.("Instrumenting the newly added events");
-  const prompt = [
-    "You proposed these events as universe opportunities while reviewing this",
-    "repo, and the user just APPROVED adding them to the plan. Instrument them",
-    "now with track(), exactly like the plan's other events: place each at the",
-    "real call site (your own rationale tells you where you saw it), attach the",
-    "properties available in scope, and skip anything that turns out not to have",
-    "a clear trigger after all. The SDK is already installed and initialized.",
-    `Project root: ${repoPath}`,
-    "",
-    ...renderRepoMapSection(repoMap),
-    "----- APPROVED NEW EVENTS -----",
-    ...eventLines,
-    "",
-    "----- END -----"
-  ].join("\n");
-  const pass = await runPass({
-    prompt,
-    systemPrompt: systemPrompt9,
-    repoPath,
-    model: config.model,
-    effort: config.effort,
-    maxTurns: 25,
-    budgetUsd,
-    progress
-  });
-  return { summary: pass.summary, costUsd: pass.costUsd, ran: true };
-}
 async function runRepairPass(opts) {
   const {
     repoPath,
@@ -2458,11 +3700,64 @@ async function runRepairPass(opts) {
 }
 var READ_ONLY_TOOLS = ["Read", "Glob", "Grep"];
 var FULL_TOOLS = ["Read", "Edit", "Write", "Bash", "Glob", "Grep"];
+var PLANNING_JSON_FENCE = /```json\s*([\s\S]*?)```/;
+function scrubTerminalText(value) {
+  return value.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "").replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?/g, "").replace(/[\x00-\x1f\x7f]/g, " ").replace(/ {2,}/g, " ").trim();
+}
+function emptyOpportunities() {
+  return { events: [], interventions: [] };
+}
+function parsePlanningResult(text) {
+  const fenced = PLANNING_JSON_FENCE.exec(text);
+  const payload = parseJsonObject(fenced?.[1]) ?? parseJsonObject(sliceLastJsonObject(text));
+  const mapText = fenced ? text.slice(0, fenced.index) : text;
+  const repoMap = sliceRepoMap(stripMapMarkers(mapText));
+  if (!payload) {
+    return { repoMap, plan: parseEventPlan(text), opportunities: emptyOpportunities() };
+  }
+  return {
+    repoMap,
+    plan: Array.isArray(payload.plan) ? coerceEventPlan(payload.plan) : null,
+    opportunities: coerceOpportunities(payload.opportunities)
+  };
+}
+function parseJsonObject(raw) {
+  if (!raw?.trim()) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      const obj = parsed;
+      if ("plan" in obj || "opportunities" in obj) return obj;
+    }
+  } catch {
+  }
+  return null;
+}
+function sliceLastJsonObject(text) {
+  const start = text.lastIndexOf("{\n");
+  const from = start >= 0 ? start : text.indexOf("{");
+  if (from < 0) return null;
+  return sliceBalanced(text, from, "{", "}");
+}
+function stripMapMarkers(text) {
+  return text.replace(/^-+\s*REPO MAP\s*-+$/gim, "").replace(/^-+\s*END REPO MAP\s*-+$/gim, "").trim();
+}
+function coerceOpportunities(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return emptyOpportunities();
+  const doc = raw;
+  return {
+    events: Array.isArray(doc.events) ? doc.events : [],
+    interventions: Array.isArray(doc.interventions) ? doc.interventions : []
+  };
+}
 function parseEventPlan(text) {
   const parsed = parseFirstJsonArray(text);
   if (!Array.isArray(parsed)) return null;
+  return coerceEventPlan(parsed);
+}
+function coerceEventPlan(items) {
   const entries = [];
-  for (const item of parsed) {
+  for (const item of items) {
     if (!item || typeof item !== "object" || Array.isArray(item)) return null;
     const obj = item;
     const event = typeof obj.event === "string" ? obj.event.trim() : "";
@@ -2473,7 +3768,10 @@ function parseEventPlan(text) {
     const entry = {
       event,
       decision,
-      reason: typeof obj.reason === "string" ? obj.reason.trim() : ""
+      // Model-authored text that ends up in the customer's terminal and in
+      // the run report — scrub it like every other string we take from the
+      // model, so it cannot restyle or spoof the surrounding UI.
+      reason: typeof obj.reason === "string" ? scrubTerminalText(obj.reason) : ""
     };
     if (typeof obj.file === "string" && obj.file.trim()) {
       entry.file = obj.file.trim();
@@ -2491,7 +3789,7 @@ function parseEventPlan(text) {
 function parseFirstJsonArray(text) {
   const start = text.indexOf("[");
   if (start < 0) return null;
-  const json = sliceJsonArray(text, start);
+  const json = sliceBalanced(text, start, "[", "]");
   if (!json) return null;
   try {
     return JSON.parse(json);
@@ -2499,7 +3797,7 @@ function parseFirstJsonArray(text) {
     return null;
   }
 }
-function sliceJsonArray(text, start) {
+function sliceBalanced(text, start, open3, close) {
   let depth = 0;
   let inString = false;
   let escaped = false;
@@ -2517,31 +3815,15 @@ function sliceJsonArray(text, start) {
     }
     if (ch === '"') {
       inString = true;
-    } else if (ch === "[") {
+    } else if (ch === open3) {
       depth++;
-    } else if (ch === "]") {
+    } else if (ch === close) {
       depth--;
       if (depth === 0) return text.slice(start, i + 1);
     }
   }
   return null;
 }
-function renderRepoMapPrompt(repoPath) {
-  return [
-    "Map this repository for a Whisperr SDK integration. This is READ-ONLY.",
-    `Project root: ${repoPath}`,
-    "",
-    "Produce a concise structured repo map as final text with these exact sections:",
-    "- framework + entry points",
-    "- auth flows enumerated: END-USER vs admin/staff, with precise file paths",
-    "- billing/payment/webhook surfaces",
-    "- analytics/tracking wrapper if any",
-    "- state management",
-    "- directory guide: which dirs hold pages/controllers/services",
-    "",
-    "This map guides event placement. List file paths precisely. No prose beyond the map."
-  ].join("\n");
-}
 function sliceRepoMap(map) {
   return map.trim().slice(0, 8e3);
 }
@@ -2550,30 +3832,46 @@ function renderRepoMapSection(repoMap) {
   if (!map) return [];
   return ["----- REPO MAP -----", map, "----- END REPO MAP -----", ""];
 }
-function renderEventPlanPrompt(repoPath, playbook, manifest, repoMap) {
+function renderPlanningPrompt(repoPath, playbook, manifest) {
   return [
-    `Plan Whisperr ${playbook.target.displayName} event placements. This is READ-ONLY.`,
+    `Plan the Whisperr ${playbook.target.displayName} integration for this repo.`,
+    "This pass is READ-ONLY \u2014 do not edit anything. You are deciding what the",
+    "editing passes will do, so be precise about files and anchors.",
     `Project root: ${repoPath}`,
     "",
-    ...renderRepoMapSection(repoMap),
-    "Use the repo map and the events brief to decide where each event belongs.",
-    "Return ONLY a JSON code block containing an array with this shape:",
-    '[{"event":"event_name","decision":"place|skip|unsure","file":"path","anchor":"function/route/handler","properties":["prop"],"reason":"short reason"}]',
+    "Produce your answer in TWO parts, in this order.",
     "",
-    "Rules:",
+    "PART 1 \u2014 the repo map, as plain text under these exact sections:",
+    "- framework + entry points",
+    "- auth flows enumerated: END-USER vs admin/staff, with precise file paths",
+    "- billing/payment/webhook surfaces",
+    "- analytics/tracking wrapper if any",
+    "- state management",
+    "- directory guide: which dirs hold pages/controllers/services",
+    "List file paths precisely. No prose beyond the map.",
+    "",
+    "PART 2 \u2014 a single ```json fenced block, and nothing after it:",
+    "{",
+    '  "plan": [{"event":"event_name","decision":"place|skip|unsure","file":"path",',
+    '            "anchor":"function/route/handler","properties":["prop"],"reason":"short reason"}],',
+    '  "opportunities": {"events": [], "interventions": []}',
+    "}",
+    "",
+    "Rules for `plan` \u2014 one entry per event in the brief below:",
     "- decision=place only when there is a concrete end-user call site in this repo.",
     "- decision=skip when the event clearly lives on another surface or does not exist here.",
     "- decision=unsure when there is a plausible surface but the exact anchor is not proven.",
     "- For place decisions, include file and anchor precisely.",
     "- properties should list only properties likely available at that anchor.",
-    "- No prose beyond the JSON code block.",
+    "",
+    renderOpportunitiesBrief(manifest),
     "",
     "----- EVENTS -----",
     renderEventsBrief(manifest),
     "----- END EVENTS -----"
   ].join("\n");
 }
-function renderEventWirePrompt(repoPath, playbook, repoMap, entries) {
+function renderEventWirePrompt(repoPath, playbook, repoMap, entries, addedEvents = []) {
   return [
     `The Whisperr ${playbook.target.displayName} SDK is installed and initialized.`,
     "Wire only the planned event placements below with track().",
@@ -2586,9 +3884,39 @@ function renderEventWirePrompt(repoPath, playbook, repoMap, entries) {
     "",
     "----- EVENT WIRING PLAN -----",
     ...renderPlanEntryLines(entries),
-    "----- END EVENT WIRING PLAN -----"
+    "----- END EVENT WIRING PLAN -----",
+    // Events the planner proposed and the universe accepted this run. They have
+    // no plan entry (they weren't in the manifest when the plan was written), so
+    // the rationale carries the placement — the planner already saw the site.
+    ...addedEvents.length ? [
+      "",
+      "----- NEWLY ADDED EVENTS -----",
+      "You proposed these while planning and they are now part of this app's",
+      "universe. Wire them the same way \u2014 your own rationale says where you",
+      "saw each one. Skip any that turn out not to have a clear trigger.",
+      ...renderAddedEventLines(addedEvents),
+      "----- END NEWLY ADDED EVENTS -----"
+    ] : []
   ].join("\n");
 }
+function renderAddedEventLines(events) {
+  const lines = [];
+  for (const event of events) {
+    lines.push("");
+    lines.push(`\u25A0 ${event.code}${event.label ? `  (${event.label})` : ""}`);
+    if (event.description) lines.push(`  ${event.description}`);
+    if (event.rationale) lines.push(`  where: ${event.rationale}`);
+    if (event.properties?.length) {
+      lines.push("  properties to capture if available:");
+      for (const prop of event.properties) {
+        lines.push(
+          `    \xB7 ${prop.name}${prop.required ? " (required)" : ""}${prop.description ? ` \u2014 ${prop.description}` : ""}`
+        );
+      }
+    }
+  }
+  return lines;
+}
 function renderEventReconcilePrompt(repoPath, playbook, repoMap, entries) {
   return [
     `One targeted follow-up for Whisperr ${playbook.target.displayName} events.`,
@@ -2929,37 +4257,670 @@ function firstLine(text) {
   const line = text.split("\n").find((l) => l.trim()) ?? text;
   return short(line.trim(), 100);
 }
-function short(s, max = 60) {
-  return s.length > max ? `${s.slice(0, max - 1)}\u2026` : s;
+function short(s, max = 60) {
+  return s.length > max ? `${s.slice(0, max - 1)}\u2026` : s;
+}
+
+// src/engine/providers/claude.ts
+var READ_ONLY_TOOLS2 = ["Read", "Glob", "Grep"];
+var EDIT_TOOLS = ["Read", "Edit", "Write", "Bash", "Glob", "Grep"];
+function createClaudeProvider(config, session) {
+  return {
+    name: "claude",
+    async invoke(invocation, roleConfig, onProgress) {
+      applyModelAuthEnv(config, session);
+      const hostTools = invocation.tools.map(
+        (engineTool) => tool(engineTool.name, engineTool.description, engineTool.inputSchema, async (args) => {
+          const result = await engineTool.handler(args);
+          return { content: [{ type: "text", text: JSON.stringify(result) }] };
+        })
+      );
+      const allowedTools = [
+        ...invocation.allowRepoWrite ? EDIT_TOOLS : READ_ONLY_TOOLS2,
+        ...invocation.tools.map((engineTool) => `mcp__engine__${engineTool.name}`)
+      ];
+      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 response = query2({
+          prompt: invocation.userPrompt,
+          options: {
+            model: roleConfig.model,
+            cwd: invocation.cwd,
+            systemPrompt: invocation.systemPrompt,
+            thinking: { type: "adaptive" },
+            ...roleConfig.effort ? { effort: roleConfig.effort } : {},
+            tools: [...allowedTools],
+            ...hostTools.length > 0 ? { mcpServers: { engine: createSdkMcpServer({ name: "engine", tools: hostTools }) } } : {},
+            hooks: buildToolPolicyHooks(invocation.cwd),
+            canUseTool: createToolPermissionCallback(invocation.cwd),
+            maxTurns: roleConfig.maxTurns,
+            ...invocation.resumeSessionId ? { resume: invocation.resumeSessionId } : {},
+            settingSources: []
+          }
+        });
+        for await (const raw of response) {
+          if (raw.session_id) {
+            sessionId = raw.session_id;
+          }
+          if (raw.type === "assistant") {
+            turns += 1;
+            const block = raw.message?.content?.find(
+              (candidate) => candidate.type === "text" || candidate.type === "tool_use"
+            );
+            if (block?.type === "text" && block.text?.trim()) {
+              onProgress((block.text.trim().split("\n")[0] ?? "").slice(0, 120));
+            } else if (block?.type === "tool_use" && block.name) {
+              onProgress(`using ${block.name}`);
+            }
+            if (Date.now() > deadline) {
+              await response.interrupt?.();
+              return outcome("budget_exhausted");
+            }
+          } else if (raw.type === "result") {
+            costUsd = raw.total_cost_usd ?? 0;
+            const subtype = raw.subtype ?? "";
+            if (subtype === "success") {
+              return outcome("completed", raw.result ?? "");
+            }
+            if (subtype.includes("max_turns") || subtype.includes("max_budget")) {
+              return outcome("budget_exhausted");
+            }
+            const detail = raw.result ?? subtype;
+            if (classifyFailure(detail) === "context_overflow") {
+              return outcome("context_overflow");
+            }
+            return outcome("failed", "", detail || "model run failed");
+          }
+        }
+        return outcome("failed", "", "model stream ended without a result");
+      } catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        if (classifyFailure(detail) === "context_overflow") {
+          return outcome("context_overflow");
+        }
+        return outcome("failed", "", detail);
+      }
+    }
+  };
+}
+
+// src/engine/providers/openai.ts
+import { readdirSync, readFileSync as readFileSync3, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join8, resolve as resolve2, sep } from "path";
+function jailedPath(cwd, candidate) {
+  const resolved = resolve2(cwd, candidate);
+  if (resolved !== cwd && !resolved.startsWith(cwd + sep)) {
+    throw new Error(`path ${candidate} escapes the repository`);
+  }
+  return resolved;
+}
+function fileTools(cwd, allowWrite) {
+  const tools = [
+    {
+      name: "read_file",
+      description: "Read a repository file (UTF-8, truncated at 40000 chars).",
+      inputSchema: {},
+      jsonSchema: {
+        type: "object",
+        properties: { path: { type: "string" } },
+        required: ["path"]
+      },
+      handler: async (input) => {
+        const content = readFileSync3(jailedPath(cwd, String(input.path ?? "")), "utf8");
+        return { content: content.slice(0, 4e4) };
+      }
+    },
+    {
+      name: "list_dir",
+      description: "List entries of a repository directory.",
+      inputSchema: {},
+      jsonSchema: {
+        type: "object",
+        properties: { path: { type: "string" } },
+        required: ["path"]
+      },
+      handler: async (input) => {
+        const target9 = jailedPath(cwd, String(input.path ?? "."));
+        const entries = readdirSync(target9).map((entry) => {
+          const kind = statSync(join8(target9, entry)).isDirectory() ? "dir" : "file";
+          return `${kind}:${entry}`;
+        });
+        return { entries: entries.slice(0, 500) };
+      }
+    }
+  ];
+  if (allowWrite) {
+    tools.push(
+      {
+        name: "write_file",
+        description: "Create or overwrite a repository file with the given content.",
+        inputSchema: {},
+        jsonSchema: {
+          type: "object",
+          properties: { path: { type: "string" }, content: { type: "string" } },
+          required: ["path", "content"]
+        },
+        handler: async (input) => {
+          writeFileSync2(jailedPath(cwd, String(input.path ?? "")), String(input.content ?? ""));
+          return { ok: true };
+        }
+      },
+      {
+        name: "replace_in_file",
+        description: "Replace one exact occurrence of a string in a repository file.",
+        inputSchema: {},
+        jsonSchema: {
+          type: "object",
+          properties: {
+            path: { type: "string" },
+            oldText: { type: "string" },
+            newText: { type: "string" }
+          },
+          required: ["path", "oldText", "newText"]
+        },
+        handler: async (input) => {
+          const path = jailedPath(cwd, String(input.path ?? ""));
+          const content = readFileSync3(path, "utf8");
+          const oldText = String(input.oldText ?? "");
+          if (!content.includes(oldText)) {
+            return { ok: false, reason: "oldText not found" };
+          }
+          writeFileSync2(path, content.replace(oldText, String(input.newText ?? "")));
+          return { ok: true };
+        }
+      }
+    );
+  }
+  return tools;
+}
+function createOpenAIProvider(config, session) {
+  let runId;
+  let conversationId;
+  const gatewayFetch = async (path, body) => {
+    if (!runId) {
+      throw new Error("OpenAI provider used before the run was created");
+    }
+    const response = await fetch(
+      `${config.apiBaseUrl}/wizard/openai/runs/${encodeURIComponent(runId)}${path}`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${session.token}`
+        },
+        body: JSON.stringify(body)
+      }
+    );
+    const text = await response.text();
+    let payload;
+    try {
+      payload = text ? JSON.parse(text) : {};
+    } catch {
+      payload = {};
+    }
+    if (!response.ok) {
+      const detail = payload.message ?? text;
+      const error = new Error(detail || `gateway request failed (${response.status})`);
+      error.code = payload.code;
+      throw error;
+    }
+    return payload;
+  };
+  const ensureConversation = async (resumeId) => {
+    if (conversationId) {
+      return conversationId;
+    }
+    if (resumeId) {
+      conversationId = resumeId;
+      return resumeId;
+    }
+    try {
+      const created = await gatewayFetch("/v1/conversations", {});
+      conversationId = created.id;
+    } catch (error) {
+      if (error.code !== "conversation_already_bound") {
+        throw error;
+      }
+    }
+    if (!conversationId) {
+      throw new Error("wizard run already has a bound conversation; rerun with its resume state");
+    }
+    return conversationId;
+  };
+  return {
+    name: "openai-gateway",
+    onRunReady(readyRunId) {
+      runId = readyRunId;
+    },
+    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 toolsByName = new Map(allTools.map((tool2) => [tool2.name, tool2]));
+      const toolDefs = allTools.map((tool2) => ({
+        type: "function",
+        name: tool2.name,
+        description: tool2.description,
+        parameters: tool2.jsonSchema
+      }));
+      try {
+        const conversation = await ensureConversation(invocation.resumeSessionId);
+        const deadline = Date.now() + roleConfig.maxMs;
+        let input = [
+          { role: "user", content: invocation.userPrompt }
+        ];
+        for (let turn = 0; turn < roleConfig.maxTurns; turn += 1) {
+          turns = turn + 1;
+          if (Date.now() > deadline) {
+            return outcome("budget_exhausted");
+          }
+          const response = await gatewayFetch("/v1/responses", {
+            model: roleConfig.model,
+            instructions: invocation.systemPrompt,
+            conversation,
+            input,
+            tools: toolDefs,
+            ...roleConfig.effort ? { reasoning: { effort: roleConfig.effort } } : {}
+          });
+          const items = response.output ?? [];
+          const calls = items.filter(
+            (item) => item.type === "function_call"
+          );
+          if (calls.length === 0) {
+            const text = response.output_text ?? items.filter((item) => item.type === "message").map(
+              (item) => Array.isArray(item.content) ? item.content.map((block) => String(block.text ?? "")).join("") : ""
+            ).join("\n");
+            return outcome("completed", String(text ?? ""));
+          }
+          const results = [];
+          for (const call of calls) {
+            onProgress(`using ${call.name}`);
+            const tool2 = toolsByName.get(call.name);
+            let output;
+            if (!tool2) {
+              output = { ok: false, reason: `unknown tool ${call.name}` };
+            } else {
+              try {
+                output = await tool2.handler(JSON.parse(call.arguments || "{}"));
+              } catch (error) {
+                output = { ok: false, reason: error instanceof Error ? error.message : String(error) };
+              }
+            }
+            results.push({
+              type: "function_call_output",
+              call_id: call.call_id,
+              output: JSON.stringify(output)
+            });
+          }
+          input = results;
+        }
+        return outcome("budget_exhausted");
+      } catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        if (classifyFailure(detail) === "context_overflow") {
+          return outcome("context_overflow");
+        }
+        return outcome("failed", "", detail);
+      }
+    }
+  };
+}
+
+// src/engine/providers/router.ts
+function createRoutedProvider(routes, fallback) {
+  const providers = /* @__PURE__ */ new Set([fallback, ...Object.values(routes)]);
+  return {
+    name: "routed",
+    onRunReady(runId) {
+      for (const provider of providers) {
+        provider.onRunReady?.(runId);
+      }
+    },
+    invoke(invocation, config, onProgress) {
+      const provider = routes[invocation.role] ?? fallback;
+      return provider.invoke(invocation, config, onProgress);
+    }
+  };
+}
+
+// src/engine/cli.ts
+var MINUTE = 6e4;
+function engineModelConfig(config) {
+  const model = (role, fallback) => process.env[`WHISPERR_WIZARD_ENGINE_${role.toUpperCase()}_MODEL`]?.trim() || fallback;
+  return {
+    survey: { model: model("survey", "claude-sonnet-5"), 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 }
+  };
+}
+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;
+}
+async function tryEngineFlow(options) {
+  const { repoPath, fingerprint, config, session, playbook, theme: theme2 } = options;
+  const startedAt = Date.now();
+  const sink = createProgressSink({
+    json: false,
+    isTTY: Boolean(process.stdout.isTTY),
+    write: (line) => p.log.message(theme2.muted(line))
+  });
+  const result = await runEngine({
+    repoPath,
+    repoFingerprint: fingerprint,
+    config,
+    session,
+    provider: engineProvider(config, session),
+    models: engineModelConfig(config),
+    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),
+      confirmApply: async (patch, summaryLines) => {
+        p.note(summaryLines.join("\n"), "Integration result");
+        const lineCount = patch.split("\n").length;
+        const answer = await p.confirm({
+          message: `Apply these changes to your working tree? (${lineCount} patch lines)`,
+          initialValue: true
+        });
+        return answer === true;
+      }
+    }
+  });
+  if (result.kind === "wrong_mode") {
+    return { handled: false, exitCode: 0 };
+  }
+  if (result.kind === "aborted") {
+    p.cancel(result.reason);
+    return { handled: true, exitCode: 1 };
+  }
+  p.note(result.summary || "Nothing to integrate.", "Run summary");
+  if (result.partialPatchPath) {
+    p.log.warn(`Unapplied changes saved to ${result.partialPatchPath}`);
+  }
+  await postRunReport(config, session, {
+    target: playbook.target.id,
+    repo_fingerprint: fingerprint,
+    identify_wired: result.identifyWired,
+    verified: null,
+    cost_usd: 0,
+    duration_ms: Date.now() - startedAt,
+    summary: result.summary.slice(0, 2e3),
+    events: result.reportEvents,
+    exit_class: result.kind === "completed" ? "engine_completed" : "engine_partial"
+  });
+  if (result.applied && result.registered.length > 0) {
+    const spin = p.spinner();
+    spin.start("Waiting for the first event (deploy or run your app)");
+    const first = await pollFirstEvent(config, session, { timeoutMs: 9e4 });
+    spin.stop(
+      first.received ? theme2.bright(`Whisperr received ${first.eventType ?? "an event"} \u2713`) : theme2.muted("No event yet \u2014 it will show up once the instrumented build runs.")
+    );
+  }
+  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 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) {
+  return value.trim().toLowerCase().replace(/[ \-./]/g, "_").replace(/[^a-z0-9_]/g, "").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+}
+function sanitizeOpportunities(raw, manifest) {
+  const out = { events: [], interventions: [] };
+  if (typeof raw !== "object" || raw === null) return out;
+  const doc = raw;
+  const knownEvents = new Set(manifest.events.map((e) => normalizeCode(e.eventType)));
+  const knownInterventions = /* @__PURE__ */ new Set([
+    ...manifest.events.flatMap((e) => e.interventions ?? []).map((i) => normalizeCode(i.code)),
+    ...(manifest.interventions ?? []).map((i) => normalizeCode(i.code))
+  ]);
+  const seenEvents = /* @__PURE__ */ new Set();
+  for (const entry of asArray(doc.events)) {
+    const ev = coerceEvent(entry);
+    if (!ev) continue;
+    if (knownEvents.has(ev.code) || seenEvents.has(ev.code)) continue;
+    seenEvents.add(ev.code);
+    out.events.push(ev);
+  }
+  const seenInterventions = /* @__PURE__ */ new Set();
+  for (const entry of asArray(doc.interventions)) {
+    const iv = coerceIntervention(entry);
+    if (!iv) continue;
+    if (knownInterventions.has(iv.code) || seenInterventions.has(iv.code)) continue;
+    seenInterventions.add(iv.code);
+    out.interventions.push(iv);
+  }
+  return out;
+}
+var SUBMIT_TIMEOUT_MS = 3e4;
+async function submitAdditions(config, session, target9, repoFingerprint2, opportunities) {
+  const res = await fetch(`${config.apiBaseUrl}/wizard/universe/additions`, {
+    method: "POST",
+    signal: AbortSignal.timeout(SUBMIT_TIMEOUT_MS),
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${session.token}`
+    },
+    body: JSON.stringify({
+      target: target9,
+      repoFingerprint: repoFingerprint2,
+      events: opportunities.events,
+      interventions: opportunities.interventions
+    })
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(
+      `Submitting universe additions failed (${res.status})${body ? `: ${body.slice(0, 300)}` : ""}`
+    );
+  }
+  return await res.json();
+}
+async function submitSuggestions(config, session, target9, repoFingerprint2, opportunities) {
+  const res = await fetch(`${config.apiBaseUrl}/wizard/universe/suggestions`, {
+    method: "POST",
+    signal: AbortSignal.timeout(SUBMIT_TIMEOUT_MS),
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${session.token}`
+    },
+    body: JSON.stringify({
+      target: target9,
+      repoFingerprint: repoFingerprint2,
+      events: opportunities.events,
+      interventions: opportunities.interventions
+    })
+  });
+  if (res.status === 404) return null;
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(
+      `Submitting universe suggestions failed (${res.status})${body ? `: ${body.slice(0, 300)}` : ""}`
+    );
+  }
+  return await res.json();
+}
+async function fetchSuggestions(config, session, statuses) {
+  if (config.offline) return [];
+  try {
+    const statusQuery = statuses.map(encodeURIComponent).join(",");
+    const url = `${config.apiBaseUrl}/wizard/universe/suggestions${statusQuery ? `?status=${statusQuery}` : ""}`;
+    const res = await fetch(url, {
+      signal: AbortSignal.timeout(SUBMIT_TIMEOUT_MS),
+      headers: { Authorization: `Bearer ${session.token}` }
+    });
+    if (!res.ok) return [];
+    const body = await res.json();
+    return Array.isArray(body) && body.every(isSuggestionRecord) ? body : [];
+  } catch {
+    return [];
+  }
+}
+function isSuggestionRecord(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const record = value;
+  return typeof record.id === "string" && (record.kind === "event" || record.kind === "intervention") && typeof record.code === "string" && (record.status === "proposed" || record.status === "approved" || record.status === "rejected" || record.status === "integrated") && typeof record.payload === "object" && record.payload !== null;
+}
+async function markSuggestionIntegrated(config, session, id, target9, repoFingerprint2) {
+  if (config.offline) return false;
+  try {
+    const res = await fetch(
+      `${config.apiBaseUrl}/wizard/universe/suggestions/${encodeURIComponent(id)}/integrated`,
+      {
+        method: "POST",
+        signal: AbortSignal.timeout(SUBMIT_TIMEOUT_MS),
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${session.token}`
+        },
+        body: JSON.stringify({ target: target9, repoFingerprint: repoFingerprint2 })
+      }
+    );
+    return res.status === 200;
+  } catch {
+    return false;
+  }
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function asString(value) {
+  if (typeof value !== "string") return void 0;
+  const cleaned = value.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "").replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?/g, "").replace(/[\x00-\x1f\x7f]/g, " ").replace(/ {2,}/g, " ").trim();
+  return cleaned ? cleaned : void 0;
+}
+function asConfidence(value) {
+  if (typeof value !== "number" || Number.isNaN(value)) return void 0;
+  return Math.min(1, Math.max(0, value));
+}
+function asWeight(value) {
+  if (typeof value !== "number" || Number.isNaN(value)) return void 0;
+  if (value < 0 || value > 1) return void 0;
+  return value;
+}
+function coerceEvent(entry) {
+  if (typeof entry !== "object" || entry === null) return null;
+  const e = entry;
+  const code = normalizeCode(asString(e.code) ?? "");
+  if (!code) return null;
+  const properties = [];
+  for (const prop of asArray(e.properties)) {
+    if (typeof prop === "string") {
+      if (prop.trim()) properties.push({ name: prop.trim() });
+      continue;
+    }
+    if (typeof prop !== "object" || prop === null) continue;
+    const pr = prop;
+    const name = asString(pr.name);
+    if (!name) continue;
+    const desc = asString(pr.description);
+    properties.push({
+      name,
+      ...desc ? { description: desc } : {},
+      ...pr.required === true ? { required: true } : {}
+    });
+  }
+  const links = [];
+  for (const link of asArray(e.links)) {
+    if (typeof link !== "object" || link === null) continue;
+    const l = link;
+    const interventionCode = normalizeCode(asString(l.interventionCode) ?? "");
+    if (!interventionCode) continue;
+    const weight = asWeight(l.weight);
+    links.push({ interventionCode, ...weight !== void 0 ? { weight } : {} });
+  }
+  const side = normalizeSide(asString(e.side));
+  return {
+    code,
+    label: asString(e.label),
+    description: asString(e.description),
+    ...side ? { side } : {},
+    rationale: asString(e.rationale),
+    expectedEffect: asString(e.expectedEffect),
+    confidence: asConfidence(e.confidence),
+    ...properties.length ? { properties } : {},
+    ...links.length ? { links } : {}
+  };
+}
+function coerceIntervention(entry) {
+  if (typeof entry !== "object" || entry === null) return null;
+  const i = entry;
+  const code = normalizeCode(asString(i.code) ?? "");
+  if (!code) return null;
+  const links = [];
+  for (const link of asArray(i.links)) {
+    if (typeof link !== "object" || link === null) continue;
+    const l = link;
+    const eventCode = normalizeCode(asString(l.eventCode) ?? "");
+    if (!eventCode) continue;
+    const weight = asWeight(l.weight);
+    links.push({ eventCode, ...weight !== void 0 ? { weight } : {} });
+  }
+  return {
+    code,
+    label: asString(i.label),
+    description: asString(i.description),
+    rationale: asString(i.rationale),
+    expectedEffect: asString(i.expectedEffect),
+    confidence: asConfidence(i.confidence),
+    ...links.length ? { links } : {}
+  };
 }
-
-// src/core/verify.ts
-async function pollFirstEvent(config, session, opts = {}) {
-  if (config.offline) return { received: false };
-  const timeoutMs = opts.timeoutMs ?? 12e4;
-  const intervalMs = opts.intervalMs ?? 3e3;
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (opts.signal?.aborted) return { received: false };
-    try {
-      const res = await fetch(`${config.apiBaseUrl}/wizard/first-event`, {
-        headers: { authorization: `Bearer ${session.token}` }
-      });
-      if (res.ok) {
-        const body = await res.json();
-        if (body.received) {
-          return { received: true, eventType: body.event_type };
-        }
-      }
-    } catch {
-    }
-    await new Promise((r) => setTimeout(r, intervalMs));
+function normalizeSide(value) {
+  switch (value?.toLowerCase()) {
+    case "frontend":
+      return "frontend";
+    case "backend":
+      return "backend";
+    case "either":
+      return "either";
+    default:
+      return void 0;
   }
-  return { received: false };
 }
 
 // src/core/postflight.ts
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 function verdictToVerified(verdict) {
   if (verdict.toolMissing || verdict.timedOut) return null;
   return verdict.ok;
@@ -2971,8 +4932,8 @@ function runVerifyCommand(repoPath, command, opts = {}) {
     return Promise.resolve({ ran: false, ok: true, output: "" });
   }
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  return new Promise((resolve3) => {
-    const child = spawn2(command, { cwd: repoPath, shell: true, env: process.env });
+  return new Promise((resolve4) => {
+    const child = spawn4(command, { cwd: repoPath, shell: true, env: process.env });
     let out = "";
     const append = (d) => {
       out += d.toString();
@@ -2982,11 +4943,11 @@ function runVerifyCommand(repoPath, command, opts = {}) {
     child.stderr?.on("data", append);
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
-      resolve3({ ran: true, ok: false, command, output: tail2(out), timedOut: true });
+      resolve4({ ran: true, ok: false, command, output: tail2(out), timedOut: true });
     }, timeoutMs);
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve3({
+      resolve4({
         ran: true,
         ok: code === 0,
         command,
@@ -2998,7 +4959,7 @@ function runVerifyCommand(repoPath, command, opts = {}) {
     });
     child.on("error", () => {
       clearTimeout(timer);
-      resolve3({ ran: true, ok: false, command, output: tail2(out), toolMissing: true });
+      resolve4({ ran: true, ok: false, command, output: tail2(out), toolMissing: true });
     });
   });
 }
@@ -3007,51 +4968,24 @@ function tail2(s) {
   return t.length > MAX_OUTPUT ? `\u2026${t.slice(-MAX_OUTPUT)}` : t;
 }
 
-// src/core/report.ts
-function scrubSummary(text) {
-  return scrubTerminalControls(text).replace(/sk-ant-[A-Za-z0-9_-]+/g, "[redacted]").replace(/sk-[A-Za-z0-9]{16,}/g, "[redacted]").replace(/AKIA[0-9A-Z]{16}/g, "[redacted]").replace(/Bearer\s+[A-Za-z0-9._-]+/g, "[redacted]").replace(
-    /\b(ANTHROPIC_(?:AUTH_TOKEN|API_KEY))\s*=\s*["']?[^"'\s]+["']?/gi,
-    "$1=[redacted]"
-  );
-}
-async function postRunReport(config, session, report) {
-  if (config.offline) return { ok: true };
-  try {
-    const res = await fetch(`${config.apiBaseUrl}/wizard/report`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${session.token}`
-      },
-      body: JSON.stringify(report)
-    });
-    if (res.ok) return { ok: true };
-    return {
-      ok: false,
-      status: res.status,
-      detail: await responseDetail(res)
-    };
-  } catch (err) {
-    return { ok: false, detail: detailSlice(errorMessage(err)) };
-  }
-}
-async function responseDetail(res) {
-  try {
-    return detailSlice(await res.text());
-  } catch (err) {
-    return detailSlice(errorMessage(err));
+// src/core/version.ts
+import { readFileSync as readFileSync4 } from "fs";
+import { dirname as dirname3, join as join9, parse } from "path";
+import { fileURLToPath } from "url";
+var PACKAGE_NAME = "@whisperr/wizard";
+function packageVersion() {
+  let dir = dirname3(fileURLToPath(import.meta.url));
+  const { root } = parse(dir);
+  while (true) {
+    try {
+      const pkg = JSON.parse(readFileSync4(join9(dir, "package.json"), "utf8"));
+      if (pkg.name === PACKAGE_NAME && pkg.version) return pkg.version;
+    } catch {
+    }
+    if (dir === root) return "0.0.0";
+    dir = dirname3(dir);
   }
 }
-function errorMessage(err) {
-  return err instanceof Error ? err.message : String(err);
-}
-function detailSlice(detail) {
-  const sliced = detail.slice(0, 200).trim();
-  return sliced || void 0;
-}
-function scrubTerminalControls(value) {
-  return value.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "").replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?/g, "").replace(/[\x00-\x1f\x7f]/g, " ").replace(/ {2,}/g, " ").trim();
-}
 
 // src/core/gapreport.ts
 function buildGapReport(input) {
@@ -3182,12 +5116,12 @@ function banner() {
 
 // src/cli.ts
 async function run2(options) {
-  const repoPath = resolve2(options.path ?? process.cwd());
+  const repoPath = resolve3(options.path ?? process.cwd());
   const config = resolveConfig(options);
   console.log(banner());
-  p.intro(theme.signal("Let's wire Whisperr into your app."));
+  p2.intro(theme.signal("Let's wire Whisperr into your app."));
   if (config.offline) {
-    p.log.warn(
+    p2.log.warn(
       theme.warn("offline mode") + theme.muted(" \u2014 using a demo manifest, no account needed.")
     );
   }
@@ -3197,27 +5131,27 @@ async function run2(options) {
   );
   const chosen = await chooseTarget(detections);
   if (!chosen) {
-    p.cancel("No supported stack selected.");
+    p2.cancel("No supported stack selected.");
     return 1;
   }
   if (chosen.playbook.target.availability === "planned") {
-    p.note(
+    p2.note(
       `We can detect ${theme.bright(chosen.playbook.target.displayName)} but the Whisperr SDK for it isn't shipped yet.
 Flutter is live today; ${theme.bright(
         chosen.playbook.target.displayName
       )} is next on the roadmap.`,
       theme.warn("SDK coming soon")
     );
-    const cont = await p.confirm({
+    const cont = await p2.confirm({
       message: "Continue anyway and let the agent scaffold against the planned SDK?",
       initialValue: false
     });
-    if (p.isCancel(cont) || !cont) {
-      p.outro(theme.muted("No problem \u2014 come back when the SDK lands."));
+    if (p2.isCancel(cont) || !cont) {
+      p2.outro(theme.muted("No problem \u2014 come back when the SDK lands."));
       return 0;
     }
   } else {
-    p.log.success(
+    p2.log.success(
       `Detected ${theme.bright(chosen.playbook.target.displayName)} ` + theme.muted(`(${chosen.detection?.evidence.join(", ") ?? "selected"})`)
     );
   }
@@ -3225,43 +5159,56 @@ Flutter is live today; ${theme.bright(
   try {
     session = config.offline ? await authenticate(config) : await withBrowserAuth(config);
   } catch (err) {
-    p.cancel(theme.alert(err.message));
+    p2.cancel(theme.alert(err.message));
     return 1;
   }
   startSessionKeepalive(config, session);
   const fingerprint = await repoFingerprint(repoPath);
+  if (!config.offline) {
+    const engineOutcome = await tryEngineFlow({
+      repoPath,
+      fingerprint,
+      config,
+      session,
+      playbook: chosen.playbook,
+      theme
+    });
+    if (engineOutcome.handled) {
+      return engineOutcome.exitCode;
+    }
+  }
   const manifest = await withSpinner(
     "Loading your onboarding context",
     () => fetchManifest(config, session, chosen.playbook.target.id, fingerprint)
   );
   const approvedSuggestionsPromise = config.offline ? null : fetchSuggestions(config, session, ["approved"]);
-  p.note(
+  p2.note(
     summarizeManifest(manifest),
     theme.signal(`Plan for ${manifest.appName ?? manifest.appId}`)
   );
   const checkpoint = await takeCheckpoint(repoPath);
   if (!checkpoint.isRepo) {
     if (!options.force) {
-      p.cancel(
+      p2.cancel(
         theme.alert("Not a git repository.") + " The wizard edits your code and relies on git to undo safely.\n" + theme.muted("Run `git init` and commit first, or re-run with --force to proceed without a safety net.")
       );
       return 1;
     }
-    p.log.warn(
+    p2.log.warn(
       theme.warn("not a git repo") + theme.muted(" \u2014 proceeding with --force; there is no automatic undo.")
     );
   } else if (!await isWorkingTreeClean(repoPath)) {
     if (!options.force) {
-      p.cancel(
+      p2.cancel(
         theme.alert("Your working tree has uncommitted changes.") + " Commit or stash them first so the wizard's edits stay isolated and reversible.\n" + theme.muted("Or re-run with --force to proceed anyway.")
       );
       return 1;
     }
-    p.log.warn(
+    p2.log.warn(
       theme.warn("uncommitted changes present") + theme.muted(" \u2014 proceeding with --force; a revert would also drop your own changes.")
     );
   }
-  const spin = p.spinner();
+  const spin = p2.spinner();
   const useIntegrationSpinner = Boolean(process.stdout.isTTY);
   let phaseLabel = "Integrating";
   let lastLine = "";
@@ -3277,42 +5224,59 @@ Flutter is live today; ${theme.bright(
   if (useIntegrationSpinner) {
     spin.start(theme.bright(phaseLabel));
   } else {
-    p.log.step(theme.bright(phaseLabel));
+    p2.log.step(theme.bright(phaseLabel));
   }
   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,
-    ...process.stdout.isTTY && process.stdin.isTTY ? {
-      async onPlanReady(plan) {
-        if (useIntegrationSpinner) {
-          spin.stop(theme.success("Placement plan ready"));
-        }
-        p.note(renderPlacementPlan(plan), "Placement plan");
-        const placeEntries = plan.filter((entry) => entry.decision === "place");
-        let selectedEvents = placeEntries.map((entry) => entry.event);
-        if (placeEntries.length) {
-          const selection = await p.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 = p.isCancel(selection) ? [] : selection;
-        }
-        if (useIntegrationSpinner) {
-          spin.start(theme.bright("Continuing integration"));
-        }
-        return filterEventPlan(plan, selectedEvents);
+    // 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.
+    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);
+    },
+    async onOpportunitiesReady(raw) {
+      if (useIntegrationSpinner) spin.stop(theme.success("Planning done"));
+      const applied = await applyOpportunities({
+        config,
+        session,
+        playbook: chosen.playbook,
+        manifest,
+        fingerprint,
+        raw,
+        additions
+      });
+      if (useIntegrationSpinner) spin.start(theme.bright("Continuing integration"));
+      return applied;
+    },
     progress: {
       onPhase(label) {
         phaseLabel = label;
@@ -3321,7 +5285,7 @@ Flutter is live today; ${theme.bright(
         if (useIntegrationSpinner) {
           updateIntegrationMessage();
         } else {
-          p.log.step(theme.bright(label));
+          p2.log.step(theme.bright(label));
         }
       },
       onActivity(line) {
@@ -3332,31 +5296,95 @@ Flutter is live today; ${theme.bright(
       }
     }
   }).catch((err) => {
-    p.log.error(err.message);
+    p2.log.error(err.message);
     return null;
   });
   if (tick) clearInterval(tick);
+  let verified = null;
+  let reported = false;
+  const collectReportEvents = async () => {
+    if (!outcome) return [];
+    const eventOutcomeByType = new Map(
+      outcome.eventOutcomes.map((event) => [event.event, event])
+    );
+    const eventTypes = [
+      ...manifest.events.map((e) => e.eventType),
+      ...additions.applied.map((e) => e.code)
+    ];
+    let wired = /* @__PURE__ */ new Map();
+    try {
+      wired = await scanWiredEvents(
+        repoPath,
+        await changedFiles(repoPath, checkpoint),
+        eventTypes
+      );
+    } catch {
+    }
+    return eventTypes.map((eventType) => ({
+      event_type: eventType,
+      status: wired.has(eventType) ? "wired" : "skipped",
+      file: wired.get(eventType),
+      // The agent's own words on why it skipped — the field that answers "why
+      // didn't it wire X" without anyone opening the repo.
+      reason: wired.has(eventType) ? void 0 : eventOutcomeByType.get(eventType)?.reason
+    }));
+  };
+  const reportRun = async (exitClass) => {
+    if (reported) return [];
+    reported = true;
+    const reportEvents2 = await collectReportEvents();
+    const result = await postRunReport(config, session, {
+      target: chosen.playbook.target.id,
+      repo_fingerprint: fingerprint,
+      identify_wired: outcome?.coreOk ?? false,
+      verified,
+      cost_usd: outcome?.costUsd ?? 0,
+      duration_ms: outcome?.durationMs ?? Date.now() - startedAt,
+      summary: scrubSummary(outcome?.summary ?? "").slice(0, 4e3),
+      events: reportEvents2,
+      wizard_version: packageVersion(),
+      planner_model: config.plannerModel,
+      editor_model: config.model,
+      effort: config.effort,
+      exit_class: exitClass,
+      phase_timings: outcome?.phaseTimings ?? [],
+      opportunities_proposed: additions.proposed,
+      opportunities_applied: additions.applied.length
+    });
+    if (!result.ok) {
+      p2.log.warn(
+        theme.warn("Couldn't record this run's coverage on the server") + theme.muted(
+          ` (${formatReportFailure(result)}) \u2014 future runs may re-propose events already wired here.`
+        )
+      );
+    }
+    return reportEvents2;
+  };
   if (!outcome) {
     if (useIntegrationSpinner) {
       spin.stop(theme.alert("Integration stopped"));
     } else {
-      p.log.error(theme.alert("Integration stopped"));
+      p2.log.error(theme.alert("Integration stopped"));
     }
-    await maybeRevert(repoPath, checkpoint, "The run stopped before finishing.");
+    const reverted = await maybeRevert(
+      repoPath,
+      checkpoint,
+      "The run stopped before finishing."
+    );
+    await reportRun(reverted ? "reverted" : "agent_error");
     return 1;
   }
   const stopLabel = !outcome.coreOk ? theme.warn("Stopped early \u2014 partial setup is in your working tree") : outcome.eventsComplete ? theme.success("Integration complete") : theme.success("Core integration done") + theme.muted(" \u2014 some events left as follow-ups");
   if (useIntegrationSpinner) {
     spin.stop(stopLabel);
   } else if (!outcome.coreOk) {
-    p.log.warn(stopLabel);
+    p2.log.warn(stopLabel);
   } else {
-    p.log.success(stopLabel);
+    p2.log.success(stopLabel);
   }
-  const opportunities = await collectOpportunities(repoPath, manifest, checkpoint);
   let files = await changedFiles(repoPath, checkpoint);
   if (files.length) {
-    p.note(files.map((f) => theme.muted("\u2022 ") + f).join("\n"), "Files changed");
+    p2.note(files.map((f) => theme.muted("\u2022 ") + f).join("\n"), "Files changed");
   }
   logAgentSummary(outcome.summary);
   if (!outcome.coreOk) {
@@ -3366,14 +5394,15 @@ Flutter is live today; ${theme.bright(
       "The core setup didn't complete, so these changes may be incomplete."
     );
     if (reverted) {
-      p.outro(theme.muted("Reverted \u2014 nothing was left in your working tree."));
+      await reportRun("reverted");
+      p2.outro(theme.muted("Reverted \u2014 nothing was left in your working tree."));
       return 1;
     }
+    await reportRun("core_failed");
   }
-  let verified = null;
   if (chosen.playbook.verifyCommand && files.length) {
     const cmd = chosen.playbook.verifyCommand;
-    const vspin = p.spinner();
+    const vspin = p2.spinner();
     vspin.start(`Verifying the integration \u2014 ${theme.muted(cmd)}`);
     let verdict = await runVerifyCommand(repoPath, cmd);
     verified = verdictToVerified(verdict);
@@ -3393,7 +5422,7 @@ Flutter is live today; ${theme.bright(
         vspin.stop(
           theme.warn(`Verification failed \u2014 ${cmd}`) + theme.muted(" \u2014 attempting one repair pass")
         );
-        const repairSpin = p.spinner();
+        const repairSpin = p2.spinner();
         repairSpin.start(`Repairing verifier failures \u2014 ${theme.muted(cmd)}`);
         try {
           const repair = await runRepairPass({
@@ -3418,7 +5447,7 @@ ${repair.summary}`].filter(Boolean).join("\n\n");
           );
         }
         files = await changedFiles(repoPath, checkpoint);
-        const reverifySpin = p.spinner();
+        const reverifySpin = p2.spinner();
         reverifySpin.start(`Re-verifying the integration \u2014 ${theme.muted(cmd)}`);
         verdict = await runVerifyCommand(repoPath, cmd);
         verified = verdictToVerified(verdict);
@@ -3442,7 +5471,7 @@ ${repair.summary}`].filter(Boolean).join("\n\n");
       }
       if (!verdict.ok && !verdict.toolMissing && !verdict.timedOut) {
         if (verdict.output) {
-          p.note(verdict.output, theme.warn("Verifier output"));
+          p2.note(verdict.output, theme.warn("Verifier output"));
         }
         const reverted = await maybeRevert(
           repoPath,
@@ -3450,94 +5479,21 @@ ${repair.summary}`].filter(Boolean).join("\n\n");
           "The integration didn't pass its build/lint check, so the edits may be broken."
         );
         if (reverted) {
-          p.outro(theme.muted("Reverted \u2014 nothing was left in your working tree."));
+          await reportRun("reverted");
+          p2.outro(theme.muted("Reverted \u2014 nothing was left in your working tree."));
           return 1;
         }
+        await reportRun("verify_failed");
       }
     }
   }
-  const { acceptedEvents, instrumentationSnapshot } = await offerOpportunities({
-    repoPath,
-    config,
-    session,
-    playbook: chosen.playbook,
-    manifest,
-    opportunities,
-    fingerprint,
-    checkpoint,
-    remainingBudgetUsd: config.budgetUsd - outcome.costUsd,
-    repoMap: outcome.repoMap
-  });
-  if (instrumentationSnapshot && chosen.playbook.verifyCommand) {
-    const cmd = chosen.playbook.verifyCommand;
-    const preInstrumentationVerified = verified;
-    const vspin = p.spinner();
-    vspin.start(`Re-verifying after instrumenting the new events \u2014 ${theme.muted(cmd)}`);
-    const verdict = await runVerifyCommand(repoPath, cmd);
-    verified = verdictToVerified(verdict);
-    if (verdict.toolMissing) {
-      vspin.stop(
-        theme.warn("Couldn't re-verify automatically") + theme.muted(` \u2014 \`${cmd}\` isn't available here. Run it yourself before committing.`)
-      );
-    } else if (verdict.timedOut) {
-      vspin.stop(
-        theme.warn(`Re-verification timed out \u2014 \`${cmd}\``) + theme.muted(" \u2014 run it yourself before committing.")
-      );
-    } else if (verdict.ok) {
-      vspin.stop(theme.success("Verified \u2713") + theme.muted(` (${cmd})`));
-    } else {
-      vspin.stop(theme.alert(`Verification failed after instrumenting the new events \u2014 ${cmd}`));
-      if (verdict.output) {
-        p.note(verdict.output, theme.warn("Verifier output"));
-      }
-      const doRevert = await p.confirm({
-        message: "Instrumenting the new events didn't pass the build/lint check. Revert just those edits? (The events stay in your universe \u2014 wire them on a future run.)",
-        initialValue: true
-      });
-      if (!p.isCancel(doRevert) && doRevert) {
-        if (await restoreToSnapshot(repoPath, checkpoint, instrumentationSnapshot)) {
-          verified = preInstrumentationVerified;
-          p.log.success(theme.success("Reverted the instrumentation edits."));
-        } else {
-          p.log.warn(
-            theme.warn("Couldn't revert automatically \u2014 undo manually: ") + (revertHint(checkpoint) ?? "git reset --hard")
-          );
-        }
-      } else {
-        p.log.info(
-          theme.muted("Left in your working tree \u2014 fix the verifier errors before committing.")
-        );
-      }
-    }
-  }
-  const filesForScan = acceptedEvents.length ? await changedFiles(repoPath, checkpoint) : files;
-  const eventTypesToScan = [
-    ...manifest.events.map((e) => e.eventType),
-    ...acceptedEvents.map((e) => e.code)
-  ];
-  const wiredMap = await scanWiredEvents(repoPath, filesForScan, eventTypesToScan);
-  const reportEvents = eventTypesToScan.map((eventType) => ({
-    event_type: eventType,
-    status: wiredMap.has(eventType) ? "wired" : "skipped",
-    file: wiredMap.get(eventType)
-  }));
-  const reportResult = await postRunReport(config, session, {
-    target: chosen.playbook.target.id,
-    repo_fingerprint: fingerprint,
-    identify_wired: outcome.coreOk,
-    verified,
-    cost_usd: outcome.costUsd,
-    duration_ms: outcome.durationMs,
-    summary: scrubSummary(outcome.summary).slice(0, 4e3),
-    events: reportEvents
-  });
-  if (!reportResult.ok) {
-    p.log.warn(
-      theme.warn("Couldn't record this run's coverage on the server") + theme.muted(
-        ` (${formatReportFailure(reportResult)}) \u2014 future runs may re-propose events already wired here.`
-      )
-    );
-  }
+  const reportedEvents = await reportRun(
+    outcome.eventsComplete ? "completed" : "events_incomplete"
+  );
+  const reportEvents = reportedEvents.length ? reportedEvents : await collectReportEvents();
+  const wiredMap = new Map(
+    reportEvents.filter((event) => event.status === "wired").map((event) => [event.event_type, event.file ?? ""])
+  );
   try {
     const approvedSuggestions = await approvedSuggestionsPromise;
     if (approvedSuggestions?.length) {
@@ -3564,7 +5520,7 @@ ${repair.summary}`].filter(Boolean).join("\n\n");
         )
       )).filter(Boolean).length;
       if (marked > 0) {
-        p.log.info(
+        p2.log.info(
           theme.muted(
             `${marked} approved suggestion${marked === 1 ? "" : "s"} marked integrated.`
           )
@@ -3575,38 +5531,35 @@ ${repair.summary}`].filter(Boolean).join("\n\n");
   }
   const eventLines = renderEventOutcomeLines(outcome.eventOutcomes, wiredMap);
   if (eventLines) {
-    p.note(eventLines, "Events");
+    p2.note(eventLines, "Events");
   }
-  const eventOutcomeByType = new Map(
-    outcome.eventOutcomes.map((event) => [event.event, event])
-  );
   const gapReport = buildGapReport({
     manifest,
     events: reportEvents.map((event) => ({
       eventType: event.event_type,
       status: event.status,
-      reason: eventOutcomeByType.get(event.event_type)?.reason
+      reason: event.reason
     }))
   });
   if (gapReport.hasContent) {
-    p.note(
+    p2.note(
       renderGapReport(gapReport, theme),
       theme.signal("What you could be doing")
     );
   }
-  const eventDenominator = manifest.universeSummary?.wireableHere ?? eventTypesToScan.length;
+  const eventDenominator = manifest.universeSummary?.wireableHere ?? reportEvents.length;
   const eventStatsLabel = manifest.universeSummary ? "events wired here" : "events wired";
   const timingDetails = outcome.phaseTimings.map(({ phase, ms }) => `${shortPhaseLabel(phase)} ${formatDuration(ms)}`).join(" \xB7 ");
-  p.log.info(
+  p2.log.info(
     theme.muted(
       `${wiredMap.size}/${eventDenominator} ${eventStatsLabel} \xB7 ${files.length} file${files.length === 1 ? "" : "s"} changed \xB7 ` + (verified === true ? "verified \xB7 " : verified === false ? "unverified \xB7 " : "") + formatDuration(outcome.durationMs) + (timingDetails ? ` (${timingDetails})` : "")
     )
   );
   if (!config.offline) {
-    p.log.step(
+    p2.log.step(
       theme.bright("Run your app once") + theme.muted(" and trigger any tracked action \u2014 I'll watch for the first event.")
     );
-    const verifySpin = p.spinner();
+    const verifySpin = p2.spinner();
     verifySpin.start("Waiting for the first event from your app");
     const first = await pollFirstEvent(config, session, { timeoutMs: 12e4 });
     if (first.received) {
@@ -3630,31 +5583,27 @@ ${repair.summary}`].filter(Boolean).join("\n\n");
     `${theme.signal("3.")} Commit & deploy \u2014 Whisperr starts working on real users.`,
     undo ? theme.muted(`Undo everything: ${undo}`) : ""
   ].filter(Boolean).join("\n");
-  p.note(nextSteps, theme.bright("Next"));
-  p.outro(theme.signal("\u2301 ") + theme.bright("Whisperr is wired in."));
+  p2.note(nextSteps, theme.bright("Next"));
+  p2.outro(theme.signal("\u2301 ") + theme.bright("Whisperr is wired in."));
   return 0;
 }
-var NO_ADDITIONS = { acceptedEvents: [], instrumentationSnapshot: null };
-async function offerOpportunities(opts) {
-  const { manifest, config, session } = opts;
+async function applyOpportunities(opts) {
+  const { config, session, playbook, manifest, fingerprint, raw, additions } = opts;
+  const clean = sanitizeOpportunities(raw, manifest);
   const openSuggestions = await fetchSuggestions(config, session, ["proposed", "approved"]);
-  const openSuggestionKeys = new Set(
-    openSuggestions.map(
-      (suggestion) => `${suggestion.kind}:${normalizeCode(suggestion.code)}`
-    )
+  const openKeys = new Set(
+    openSuggestions.map((s) => `${s.kind}:${normalizeCode(s.code)}`)
   );
   const opportunities = {
-    events: opts.opportunities.events.filter(
-      (event) => !openSuggestionKeys.has(`event:${normalizeCode(event.code)}`)
-    ),
-    interventions: opts.opportunities.interventions.filter(
-      (intervention) => !openSuggestionKeys.has(`intervention:${normalizeCode(intervention.code)}`)
+    events: clean.events.filter((e) => !openKeys.has(`event:${normalizeCode(e.code)}`)),
+    interventions: clean.interventions.filter(
+      (i) => !openKeys.has(`intervention:${normalizeCode(i.code)}`)
     )
   };
-  const total = opportunities.events.length + opportunities.interventions.length;
-  if (total === 0) return NO_ADDITIONS;
+  additions.proposed = opportunities.events.length + opportunities.interventions.length;
+  if (additions.proposed === 0) return [];
   const describe = (kind, code, why) => `${theme.muted(`${kind}: `)}${theme.bright(code)}${why ? theme.muted(` \u2014 ${why}`) : ""}`;
-  p.note(
+  p2.note(
     [
       ...opportunities.events.map((e) => describe("event", e.code, e.rationale ?? e.description)),
       ...opportunities.interventions.map(
@@ -3664,111 +5613,30 @@ async function offerOpportunities(opts) {
     theme.signal("Opportunities found beyond your onboarding plan")
   );
   if (config.offline) {
-    p.log.info(theme.muted("Offline mode \u2014 proposals shown only, nothing submitted."));
-    return NO_ADDITIONS;
-  }
-  if (!process.stdout.isTTY || !process.stdin.isTTY) {
-    p.log.info(
-      theme.muted("Non-interactive run \u2014 proposals were not submitted. Re-run interactively to add them.")
-    );
-    return NO_ADDITIONS;
-  }
-  const selection = await p.multiselect({
-    message: "Send these to your dashboard for approval?",
-    options: [
-      ...opportunities.events.map((e) => ({
-        value: `e:${e.code}`,
-        label: `event \xB7 ${e.code}`,
-        hint: e.description ?? e.rationale
-      })),
-      ...opportunities.interventions.map((i) => ({
-        value: `i:${i.code}`,
-        label: `intervention \xB7 ${i.code}`,
-        hint: i.description ?? i.rationale
-      }))
-    ],
-    // Opt-in per item: nothing is pre-selected, so submitting a suggestion is
-    // an explicit choice rather than an opt-out the user has to notice and undo.
-    initialValues: [],
-    required: false
-  });
-  if (p.isCancel(selection) || selection.length === 0) {
-    p.log.info(theme.muted("Skipped \u2014 your universe is unchanged."));
-    return NO_ADDITIONS;
+    p2.log.info(theme.muted("Offline mode \u2014 proposals shown only, nothing submitted."));
+    return [];
   }
-  const chosenSet = new Set(selection);
-  const knownInterventionCodes = new Set(
-    manifest.events.flatMap((e) => e.interventions ?? []).map((i) => i.code)
-  );
-  const knownEventCodes = new Set(manifest.events.map((e) => e.eventType));
-  const pickedEvents = opportunities.events.filter((e) => chosenSet.has(`e:${e.code}`));
-  const pickedInterventions = opportunities.interventions.filter(
-    (i) => chosenSet.has(`i:${i.code}`)
-  );
-  const pickedInterventionCodes = new Set(pickedInterventions.map((i) => i.code));
-  const pickedEventCodes = new Set(pickedEvents.map((e) => e.code));
-  const submitted = {
-    events: pickedEvents.map((e) => ({
-      ...e,
-      links: e.links?.filter(
-        (l) => knownInterventionCodes.has(l.interventionCode) || pickedInterventionCodes.has(l.interventionCode)
-      )
-    })),
-    interventions: pickedInterventions.map((i) => ({
-      ...i,
-      links: i.links?.filter(
-        (l) => knownEventCodes.has(l.eventCode) || pickedEventCodes.has(l.eventCode)
-      )
-    }))
-  };
-  let stageResult;
-  try {
-    stageResult = await withSpinner(
-      "Sending suggestions for approval",
-      () => submitSuggestions(config, session, opts.playbook.target.id, opts.fingerprint, submitted)
-    );
-  } catch (err) {
-    p.log.warn(
-      theme.warn("Couldn't send the proposals") + theme.muted(` \u2014 ${err.message}. Nothing was submitted.`)
-    );
-    return NO_ADDITIONS;
-  }
-  if (stageResult) {
-    const lines2 = stageResult.outcomes.map((outcome) => {
-      const mark = outcome.status === "staged" ? theme.success("\u2713") : outcome.status === "duplicate" ? theme.muted("=") : theme.warn("\u2717");
-      const reason = outcome.reason ?? (outcome.duplicateOf && outcome.duplicateOf !== outcome.code ? `already queued as ${outcome.duplicateOf}` : void 0);
-      const detail = reason ? theme.muted(` (${reason})`) : "";
-      return `${mark} ${outcome.kind} ${theme.bright(outcome.code)}${detail}`;
-    });
-    lines2.push(
-      theme.muted(
-        `${stageResult.staged} staged \xB7 ${stageResult.duplicates} already queued \xB7 ${stageResult.invalid} rejected`
-      )
-    );
-    p.note(lines2.join("\n"), theme.signal("Suggestions submitted"));
-    const where = stageResult.approvalsUrl ? `approve at ${theme.bright(stageResult.approvalsUrl)}` : "approve them in your Whisperr dashboard";
-    p.log.info(
-      theme.muted(
-        `${stageResult.staged} proposal${stageResult.staged === 1 ? "" : "s"} sent \u2014 ${where}. The next wizard run wires whatever you approve.`
-      )
-    );
-    return NO_ADDITIONS;
+  if (config.proposeOnly) {
+    await stageOpportunities(config, session, playbook, fingerprint, opportunities);
+    return [];
   }
   let result;
   try {
     result = await withSpinner(
       "Adding to your universe",
-      () => submitAdditions(config, session, opts.playbook.target.id, opts.fingerprint, submitted)
+      () => submitAdditions(config, session, playbook.target.id, fingerprint, opportunities)
     );
   } catch (err) {
-    p.log.warn(
+    p2.log.warn(
       theme.warn("Couldn't add the proposals") + theme.muted(` \u2014 ${err.message}. Your universe is unchanged.`)
     );
-    return NO_ADDITIONS;
+    return [];
   }
   const lines = result.outcomes.map((o) => {
     const mark = o.status === "applied" ? theme.success("\u2713") : o.status === "duplicate" ? theme.muted("=") : theme.warn("\u2717");
-    const detail = o.status === "duplicate" ? theme.muted(` (already in your universe${o.duplicateOf && o.duplicateOf !== o.code ? ` as ${o.duplicateOf}` : ""})`) : o.status === "invalid" && o.reason ? theme.muted(` (${o.reason})`) : "";
+    const detail = o.status === "duplicate" ? theme.muted(
+      ` (already in your universe${o.duplicateOf && o.duplicateOf !== o.code ? ` as ${o.duplicateOf}` : ""})`
+    ) : o.status === "invalid" && o.reason ? theme.muted(` (${o.reason})`) : "";
     return `${mark} ${o.kind} ${theme.bright(o.code)}${detail}`;
   });
   lines.push(
@@ -3776,7 +5644,7 @@ async function offerOpportunities(opts) {
       `${result.applied} added \xB7 ${result.duplicates} already present \xB7 ${result.invalid} rejected`
     )
   );
-  if (submitted.interventions.length) {
+  if (opportunities.interventions.length) {
     lines.push(theme.muted("New interventions start paused \u2014 activate them in your dashboard."));
   }
   if (result.policyRegen?.status === "pending") {
@@ -3791,68 +5659,76 @@ async function offerOpportunities(opts) {
       )
     );
   }
-  p.note(lines.join("\n"), theme.signal("Universe updated"));
+  p2.note(lines.join("\n"), theme.signal("Universe updated"));
   if (result.policyRegen?.status === "failed") {
-    p.log.warn(
+    p2.log.warn(
       theme.warn("Live runtime NOT updated") + theme.muted(
         " \u2014 the additions were recorded, but the runtime policy wasn't regenerated" + (result.policyRegen.reason ? `: ${result.policyRegen.reason}` : "") + ". They won't drive live decisions until the policy regenerates."
       )
     );
   }
-  const appliedEventCodes = new Set(
+  const appliedCodes = new Set(
     result.outcomes.filter((o) => o.kind === "event" && o.status === "applied").map((o) => o.code)
   );
-  const acceptedEvents = pickedEvents.filter((e) => appliedEventCodes.has(e.code));
-  if (!acceptedEvents.length) return NO_ADDITIONS;
-  const prePass = await snapshotChanges(opts.repoPath, opts.checkpoint);
-  const spin = p.spinner();
-  spin.start(theme.bright("Instrumenting the newly added events"));
+  const applied = opportunities.events.filter((e) => appliedCodes.has(e.code));
+  additions.applied = applied;
+  return applied;
+}
+async function stageOpportunities(config, session, playbook, fingerprint, opportunities) {
+  let stageResult;
   try {
-    const pass = await runAdditionsInstrumentationPass({
-      repoPath: opts.repoPath,
-      config,
-      session,
-      playbook: opts.playbook,
-      acceptedEvents,
-      budgetUsd: opts.remainingBudgetUsd,
-      repoMap: opts.repoMap
-    });
-    if (pass.ran) {
-      spin.stop(theme.success("New events instrumented"));
-      logAgentSummary(pass.summary);
-    } else {
-      spin.stop(
-        theme.warn("Skipped instrumenting the new events") + theme.muted(
-          " \u2014 the spend limit was reached. They're in your universe; wire them on a future run."
-        )
-      );
-    }
+    stageResult = await withSpinner(
+      "Sending suggestions for approval",
+      () => submitSuggestions(config, session, playbook.target.id, fingerprint, opportunities)
+    );
   } catch (err) {
-    spin.stop(
-      theme.warn("Couldn't instrument the new events") + theme.muted(` \u2014 ${err.message}. They're in your universe; wire them on a future run.`)
+    p2.log.warn(
+      theme.warn("Couldn't send the proposals") + theme.muted(` \u2014 ${err.message}. Nothing was submitted.`)
+    );
+    return;
+  }
+  if (!stageResult) {
+    p2.log.warn(
+      theme.warn("This Whisperr backend has no approval queue") + theme.muted(" \u2014 nothing was submitted. Re-run without --propose-only to add them directly.")
     );
+    return;
   }
-  const edited = !snapshotsEqual(prePass, await snapshotChanges(opts.repoPath, opts.checkpoint));
-  return { acceptedEvents, instrumentationSnapshot: edited ? prePass : null };
+  const lines = stageResult.outcomes.map((outcome) => {
+    const mark = outcome.status === "staged" ? theme.success("\u2713") : outcome.status === "duplicate" ? theme.muted("=") : theme.warn("\u2717");
+    const reason = outcome.reason ?? (outcome.duplicateOf && outcome.duplicateOf !== outcome.code ? `already queued as ${outcome.duplicateOf}` : void 0);
+    return `${mark} ${outcome.kind} ${theme.bright(outcome.code)}${reason ? theme.muted(` (${reason})`) : ""}`;
+  });
+  lines.push(
+    theme.muted(
+      `${stageResult.staged} staged \xB7 ${stageResult.duplicates} already queued \xB7 ${stageResult.invalid} rejected`
+    )
+  );
+  p2.note(lines.join("\n"), theme.signal("Suggestions submitted"));
+  const where = stageResult.approvalsUrl ? `approve at ${theme.bright(stageResult.approvalsUrl)}` : "approve them in your Whisperr dashboard";
+  p2.log.info(
+    theme.muted(
+      `${stageResult.staged} proposal${stageResult.staged === 1 ? "" : "s"} sent \u2014 ${where}. The next wizard run wires whatever you approve.`
+    )
+  );
 }
 async function maybeRevert(repoPath, checkpoint, reason) {
   if (!checkpoint.isRepo) return false;
   const files = await changedFiles(repoPath, checkpoint);
   if (files.length === 0) return false;
-  const doRevert = await p.confirm({
+  const doRevert = await p2.confirm({
     message: `${reason} Revert all of the wizard's changes now?`,
     initialValue: true
   });
-  if (p.isCancel(doRevert) || !doRevert) {
+  if (p2.isCancel(doRevert) || !doRevert) {
     const hint = revertHint(checkpoint);
-    if (hint) p.log.info(theme.muted(`Left in your working tree. Undo anytime: ${hint}`));
+    if (hint) p2.log.info(theme.muted(`Left in your working tree. Undo anytime: ${hint}`));
     return false;
   }
   const ok = await revertToCheckpoint(repoPath, checkpoint);
   if (ok) {
-    p.log.success(theme.success("Reverted to your pre-wizard state."));
+    p2.log.success(theme.success("Reverted to your pre-wizard state."));
   } else {
-    p.log.warn(
+    p2.log.warn(
       theme.warn("Couldn't revert automatically \u2014 undo manually: ") + (revertHint(checkpoint) ?? "git reset --hard")
     );
   }
@@ -3883,11 +5759,11 @@ async function chooseTarget(detections) {
       hint: pb.target.availability === "available" ? void 0 : "coming soon"
     });
   }
-  const answer = await p.select({
+  const answer = await p2.select({
     message: detections.length ? "I found more than one possible stack \u2014 which should I integrate?" : "I couldn't auto-detect your stack. Which are you using?",
     options
   });
-  if (p.isCancel(answer)) return null;
+  if (p2.isCancel(answer)) return null;
   const playbook = playbookByTargetId(answer);
   if (!playbook) return null;
   return {
@@ -3896,11 +5772,11 @@ async function chooseTarget(detections) {
   };
 }
 async function withBrowserAuth(config) {
-  p.log.step(
+  p2.log.step(
     theme.bright("Authenticate") + theme.muted(" \u2014 opening your browser to approve this device\u2026")
   );
   const auth = await startDeviceAuth(config);
-  p.note(
+  p2.note(
     [
       theme.bright(`Your code: ${auth.userCode}`),
       `${theme.muted("Approval URL:")} ${auth.verificationUrl}`,
@@ -3914,7 +5790,7 @@ async function withBrowserAuth(config) {
     await open2(auth.verificationUrlComplete ?? auth.verificationUrl);
   } catch {
   }
-  const spin = p.spinner();
+  const spin = p2.spinner();
   spin.start("Waiting for you to approve in the browser");
   try {
     const session = await auth.poll();
@@ -3926,7 +5802,7 @@ async function withBrowserAuth(config) {
   }
 }
 async function withSpinner(label, fn) {
-  const spin = p.spinner();
+  const spin = p2.spinner();
   spin.start(label);
   try {
     const result = await fn();
@@ -3989,16 +5865,14 @@ function renderEventOutcomeLines(outcomes, wiredMap) {
 }
 function logAgentSummary(summary) {
   const cleaned = scrubSummary(summary).trim();
-  if (cleaned) p.log.message(cleaned);
+  if (cleaned) p2.log.message(cleaned);
 }
 function shortPhaseLabel(phase) {
   switch (phase) {
-    case "Mapping your codebase":
-      return "map";
+    case "Planning your integration":
+      return "plan";
     case "Installing the SDK & wiring identify()":
       return "core";
-    case "Planning event placements":
-      return "plan";
     case "Instrumenting planned events":
     case "Instrumenting your events":
       return "wire";
@@ -4031,12 +5905,7 @@ function formatReportFailure(result) {
 }
 
 // src/index.ts
-var modulePath = fileURLToPath(import.meta.url);
-function packageVersion() {
-  const packagePath = join4(dirname2(modulePath), "..", "package.json");
-  const pkg = JSON.parse(readFileSync(packagePath, "utf8"));
-  return pkg.version ?? "0.0.0";
-}
+var modulePath = fileURLToPath2(import.meta.url);
 function parseArgs(argv) {
   const args = [...argv];
   const opts = {};
@@ -4056,6 +5925,15 @@ function parseArgs(argv) {
       case "--force":
         opts.force = true;
         break;
+      case "--review-plan":
+        opts.reviewPlan = true;
+        break;
+      case "--propose-only":
+        opts.proposeOnly = true;
+        break;
+      case "--strict-review":
+        opts.strictReview = true;
+        break;
       case "--api":
         opts.apiBaseUrl = args[++i];
         break;
@@ -4082,6 +5960,10 @@ 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",
       "    --api <url>       Override the Whisperr API base URL",
       "    --model <id>      Override the coding-agent model",
       "    -h, --help        Show this help",