@whisperr/wizard 0.6.0 → 0.7.0

package/dist/index.js

@@ -5,8 +5,8 @@ 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
@@ -940,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
@@ -982,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);
 }
@@ -1181,10 +1181,1580 @@ function mockManifest(appId, config) {
         properties: [{ name: "reason", description: "stated cancel reason" }],
         interventions: [{ code: "win_back", label: "Win-back", weight: 1 }]
       }
-    ],
-    supportedTargets: ["flutter", "web-js", "nextjs", "react-native", "swift"]
+    ],
+    supportedTargets: ["flutter", "web-js", "nextjs", "react-native", "swift"]
+  };
+}
+
+// src/engine/cli.ts
+import * as p from "@clack/prompts";
+
+// 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));
+  }
+}
+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/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));
+  }
+  return { received: false };
+}
+
+// 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}`);
+    }
+  };
+}
+
+// src/engine/orchestrator.ts
+import { basename, join as join6 } from "path";
+
+// src/engine/clusters.ts
+import { createHash } from "crypto";
+import { dirname } from "path";
+var MIN_CLUSTER_EVENTS = 3;
+var MAX_CLUSTER_EVENTS = 8;
+function clusterIdFor(files) {
+  const digest = createHash("sha256").update([...files].sort().join("\n")).digest("hex");
+  return `cluster_${digest.slice(0, 12)}`;
+}
+function deriveClusters(placements) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const placement of placements) {
+    const existing = byFile.get(placement.file) ?? [];
+    existing.push(placement);
+    byFile.set(placement.file, existing);
+  }
+  const byDirectory = /* @__PURE__ */ new Map();
+  for (const [file, events] of byFile) {
+    const directory = dirname(file);
+    const bucket = byDirectory.get(directory) ?? { files: /* @__PURE__ */ new Set(), events: [] };
+    bucket.files.add(file);
+    bucket.events.push(...events);
+    byDirectory.set(directory, bucket);
+  }
+  const clusters = [];
+  const pending = [];
+  for (const directory of [...byDirectory.keys()].sort()) {
+    const bucket = byDirectory.get(directory);
+    if (bucket.events.length >= MIN_CLUSTER_EVENTS) {
+      pending.push(bucket);
+      continue;
+    }
+    const last = pending[pending.length - 1];
+    if (last && last.events.length + bucket.events.length <= MAX_CLUSTER_EVENTS) {
+      for (const file of bucket.files) last.files.add(file);
+      last.events.push(...bucket.events);
+    } else {
+      pending.push(bucket);
+    }
+  }
+  for (const bucket of pending) {
+    const events = [...bucket.events].sort((a, b) => a.eventCode.localeCompare(b.eventCode));
+    for (let start = 0; start < events.length; start += MAX_CLUSTER_EVENTS) {
+      const slice = events.slice(start, start + MAX_CLUSTER_EVENTS);
+      const files = [...new Set(slice.map((event) => event.file))].sort();
+      clusters.push({
+        id: clusterIdFor(files.length > 0 ? files : [`slice_${start}`]),
+        files,
+        events: slice,
+        status: "pending",
+        attempts: 0
+      });
+    }
+  }
+  return clusters;
+}
+var TERMINAL_STATUSES = ["reviewed", "failed_resumable", "blocked"];
+function nextPendingCluster(clusters) {
+  return clusters.find((cluster) => cluster.status === "pending" || cluster.status === "editing");
+}
+function clustersComplete(clusters) {
+  return clusters.every((cluster) => TERMINAL_STATUSES.includes(cluster.status));
+}
+function transitionCluster(clusters, clusterId, status, note3) {
+  return clusters.map((cluster) => {
+    if (cluster.id !== clusterId) {
+      return cluster;
+    }
+    const attempts = status === "editing" ? cluster.attempts + 1 : cluster.attempts;
+    return { ...cluster, status, attempts, note: note3 ?? cluster.note };
+  });
+}
+
+// src/engine/integrate.ts
+import { writeFile } from "fs/promises";
+import { join as join3 } from "path";
+
+// 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";
+}
+
+// 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;
+  }
+  return [];
+}
+function packageScripts(repoPath) {
+  try {
+    const parsed = JSON.parse(readFileSync(join2(repoPath, "package.json"), "utf8"));
+    return parsed.scripts ?? {};
+  } catch {
+    return {};
+  }
+}
+function hasTsconfig(repoPath) {
+  try {
+    readFileSync(join2(repoPath, "tsconfig.json"), "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+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));
+  }
+  return results;
+}
+function verifiedStatus(results) {
+  if (results.length === 0) {
+    return "applied";
+  }
+  if (results.some((result) => !result.ok)) {
+    return "applied";
+  }
+  if (results.some((result) => result.kind === "build")) {
+    return "build_verified";
+  }
+  if (results.some((result) => result.kind === "typecheck" || result.kind === "analyze")) {
+    return "type_verified";
+  }
+  return "syntax_verified";
+}
+function runVerificationStatus(results) {
+  if (results.length === 0) {
+    return "unavailable";
+  }
+  return results.every((result) => result.ok) ? "passed" : "failed";
+}
+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
+    },
+    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");
+  });
+  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 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"
+    });
+    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 };
+}
+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)
+  };
+}
+
+// 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 ${this.session.token}`
+        },
+        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 }
+    );
+  }
+};
+
+// 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");
+}
+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 renderOnboardingContext(context) {
+  if (!context) {
+    return "";
+  }
+  const rendered = JSON.stringify(context, null, 1);
+  return rendered.length > 6e3 ? rendered.slice(0, 6e3) + "\n\u2026(truncated)" : rendered;
+}
+
+// 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 normalizeEventCode(value) {
+  const collapsed = value.toLowerCase().trim().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").replace(/_{2,}/g, "_");
+  return /^[a-z]/.test(collapsed) ? collapsed : "";
+}
+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 (isPIIField(normalizedField)) {
+      return { ok: false, reason: `payload field ${normalizedField} is a personal identifier and is not allowed` };
+    }
+    schema[normalizedField] = description.trim();
+  }
+  if (Object.keys(schema).length > 20) {
+    return { ok: false, reason: "payload schema exceeds 20 fields" };
+  }
+  return {
+    ok: true,
+    event: {
+      code,
+      name: input.name.trim(),
+      reasoning: input.reasoning.trim(),
+      anchorFile: input.anchorFile.trim(),
+      anchorSymbol: input.anchorSymbol?.trim() || void 0,
+      payloadSchema: schema
+    }
+  };
+}
+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 };
+}
+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 {
@@ -1192,10 +2762,10 @@ import {
 } from "@anthropic-ai/claude-agent-sdk";
 
 // src/core/git.ts
-import { spawn } from "child_process";
-import { createHash } from "crypto";
+import { spawn as spawn3 } from "child_process";
+import { createHash as createHash4 } from "crypto";
 import { readFile as readFile2 } from "fs/promises";
-import { basename, join as join2 } from "path";
+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 };
@@ -1243,8 +2813,8 @@ async function revertToCheckpoint(repoPath, checkpoint) {
 }
 async function repoFingerprint(repoPath) {
   const remote = await run(repoPath, ["remote", "get-url", "origin"]);
-  const seed = remote.ok && remote.stdout.trim() ? normalizeRemote(remote.stdout.trim()) : `dir:${basename(repoPath)}`;
-  return createHash("sha256").update(seed).digest("hex").slice(0, 16);
+  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();
@@ -1261,7 +2831,7 @@ async function scanWiredEvents(repoPath, files, eventTypes) {
   const contents = [];
   for (const file of files) {
     try {
-      contents.push({ file, content: await readFile2(join2(repoPath, file), "utf8") });
+      contents.push({ file, content: await readFile2(join7(repoPath, file), "utf8") });
     } catch {
       continue;
     }
@@ -1291,14 +2861,14 @@ function escapeRegExp(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function run(cwd, args) {
-  return new Promise((resolve3) => {
-    const child = spawn("git", args, { cwd });
+  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) => resolve3({ ok: code === 0, stdout, stderr }));
-    child.on("error", () => resolve3({ ok: false, stdout, stderr }));
+    child.on("close", (code) => resolve4({ ok: code === 0, stdout, stderr }));
+    child.on("error", () => resolve4({ ok: false, stdout, stderr }));
   });
 }
 
@@ -1469,10 +3039,10 @@ 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}`);
       }
     }
   }
@@ -2691,6 +4261,446 @@ 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, "");
@@ -2909,33 +4919,8 @@ function normalizeSide(value) {
   }
 }
 
-// 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));
-  }
-  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;
@@ -2947,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();
@@ -2958,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,
@@ -2974,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 });
     });
   });
 }
@@ -2983,68 +4968,22 @@ 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));
-  }
-}
-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/version.ts
-import { readFileSync } from "fs";
-import { dirname as dirname2, join as join3, parse } from "path";
+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 = dirname2(fileURLToPath(import.meta.url));
+  let dir = dirname3(fileURLToPath(import.meta.url));
   const { root } = parse(dir);
   while (true) {
     try {
-      const pkg = JSON.parse(readFileSync(join3(dir, "package.json"), "utf8"));
+      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 = dirname2(dir);
+    dir = dirname3(dir);
   }
 }
 
@@ -3177,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.")
     );
   }
@@ -3192,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"})`)
     );
   }
@@ -3220,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 = "";
@@ -3272,7 +5224,7 @@ 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: [] };
@@ -3290,11 +5242,11 @@ Flutter is live today; ${theme.bright(
       if (useIntegrationSpinner) {
         spin.stop(theme.success("Placement plan ready"));
       }
-      p.note(renderPlacementPlan(plan), "Placement plan");
+      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 p.multiselect({
+        const selection = await p2.multiselect({
           message: "Wire these events?",
           options: placeEntries.map((entry) => ({
             value: entry.event,
@@ -3304,7 +5256,7 @@ Flutter is live today; ${theme.bright(
           initialValues: selectedEvents,
           required: false
         });
-        selectedEvents = p.isCancel(selection) ? [] : selection;
+        selectedEvents = p2.isCancel(selection) ? [] : selection;
       }
       if (useIntegrationSpinner) {
         spin.start(theme.bright("Continuing integration"));
@@ -3333,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) {
@@ -3344,7 +5296,7 @@ Flutter is live today; ${theme.bright(
       }
     }
   }).catch((err) => {
-    p.log.error(err.message);
+    p2.log.error(err.message);
     return null;
   });
   if (tick) clearInterval(tick);
@@ -3400,7 +5352,7 @@ Flutter is live today; ${theme.bright(
       opportunities_applied: additions.applied.length
     });
     if (!result.ok) {
-      p.log.warn(
+      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.`
         )
@@ -3412,7 +5364,7 @@ Flutter is live today; ${theme.bright(
     if (useIntegrationSpinner) {
       spin.stop(theme.alert("Integration stopped"));
     } else {
-      p.log.error(theme.alert("Integration stopped"));
+      p2.log.error(theme.alert("Integration stopped"));
     }
     const reverted = await maybeRevert(
       repoPath,
@@ -3426,13 +5378,13 @@ Flutter is live today; ${theme.bright(
   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);
   }
   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) {
@@ -3443,14 +5395,14 @@ Flutter is live today; ${theme.bright(
     );
     if (reverted) {
       await reportRun("reverted");
-      p.outro(theme.muted("Reverted \u2014 nothing was left in your working tree."));
+      p2.outro(theme.muted("Reverted \u2014 nothing was left in your working tree."));
       return 1;
     }
     await reportRun("core_failed");
   }
   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);
@@ -3470,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({
@@ -3495,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);
@@ -3519,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,
@@ -3528,7 +5480,7 @@ ${repair.summary}`].filter(Boolean).join("\n\n");
         );
         if (reverted) {
           await reportRun("reverted");
-          p.outro(theme.muted("Reverted \u2014 nothing was left in your working tree."));
+          p2.outro(theme.muted("Reverted \u2014 nothing was left in your working tree."));
           return 1;
         }
         await reportRun("verify_failed");
@@ -3568,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.`
           )
@@ -3579,7 +5531,7 @@ ${repair.summary}`].filter(Boolean).join("\n\n");
   }
   const eventLines = renderEventOutcomeLines(outcome.eventOutcomes, wiredMap);
   if (eventLines) {
-    p.note(eventLines, "Events");
+    p2.note(eventLines, "Events");
   }
   const gapReport = buildGapReport({
     manifest,
@@ -3590,7 +5542,7 @@ ${repair.summary}`].filter(Boolean).join("\n\n");
     }))
   });
   if (gapReport.hasContent) {
-    p.note(
+    p2.note(
       renderGapReport(gapReport, theme),
       theme.signal("What you could be doing")
     );
@@ -3598,16 +5550,16 @@ ${repair.summary}`].filter(Boolean).join("\n\n");
   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) {
@@ -3631,8 +5583,8 @@ ${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;
 }
 async function applyOpportunities(opts) {
@@ -3651,7 +5603,7 @@ async function applyOpportunities(opts) {
   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(
@@ -3661,7 +5613,7 @@ async function applyOpportunities(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."));
+    p2.log.info(theme.muted("Offline mode \u2014 proposals shown only, nothing submitted."));
     return [];
   }
   if (config.proposeOnly) {
@@ -3675,7 +5627,7 @@ async function applyOpportunities(opts) {
       () => 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 [];
@@ -3707,9 +5659,9 @@ async function applyOpportunities(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."
       )
@@ -3730,13 +5682,13 @@ async function stageOpportunities(config, session, playbook, fingerprint, opport
       () => submitSuggestions(config, session, playbook.target.id, fingerprint, opportunities)
     );
   } catch (err) {
-    p.log.warn(
+    p2.log.warn(
       theme.warn("Couldn't send the proposals") + theme.muted(` \u2014 ${err.message}. Nothing was submitted.`)
     );
     return;
   }
   if (!stageResult) {
-    p.log.warn(
+    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;
@@ -3751,9 +5703,9 @@ async function stageOpportunities(config, session, playbook, fingerprint, opport
       `${stageResult.staged} staged \xB7 ${stageResult.duplicates} already queued \xB7 ${stageResult.invalid} rejected`
     )
   );
-  p.note(lines.join("\n"), theme.signal("Suggestions submitted"));
+  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";
-  p.log.info(
+  p2.log.info(
     theme.muted(
       `${stageResult.staged} proposal${stageResult.staged === 1 ? "" : "s"} sent \u2014 ${where}. The next wizard run wires whatever you approve.`
     )
@@ -3763,20 +5715,20 @@ 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")
     );
   }
@@ -3807,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 {
@@ -3820,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}`,
@@ -3838,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();
@@ -3850,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();
@@ -3913,7 +5865,7 @@ 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) {