@whisperr/wizard 0.1.15 → 0.2.1

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { readFileSync, realpathSync } from "fs";
-import { dirname, join as join3 } from "path";
+import { dirname as dirname2, join as join4 } from "path";
 import { fileURLToPath } from "url";
 
 // src/cli.ts
@@ -647,51 +647,135 @@ var phpPlaybook = {
 // src/core/playbooks/react-native.ts
 var target7 = {
   id: "react-native",
-  displayName: "React Native",
+  displayName: "React Native / Expo",
   language: "typescript",
-  availability: "planned"
+  availability: "available"
 };
 async function detect7(ctx) {
   if (!await ctx.exists("package.json")) return null;
   const pkgJson = await ctx.read("package.json");
-  let match = false;
+  let hasRN = false;
+  let hasExpo = false;
   try {
     const pkg = JSON.parse(pkgJson);
     const all = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
-    match = "react-native" in all || "expo" in all;
+    hasRN = "react-native" in all;
+    hasExpo = "expo" in all;
   } catch {
-    match = false;
   }
-  if (!match) return null;
-  const evidence = ["react-native / expo dependency"];
+  if (!hasRN && !hasExpo) return null;
+  const evidence = [];
+  if (hasExpo) evidence.push("expo dependency");
+  if (hasRN) evidence.push("react-native dependency");
   let confidence = 0.85;
   if (await ctx.exists("app.json")) {
     evidence.push("app.json");
     confidence += 0.1;
+  } else if (await ctx.exists("app.config.js") || await ctx.exists("app.config.ts")) {
+    evidence.push("app.config");
+    confidence += 0.1;
   }
   return { target: target7, confidence: Math.min(confidence, 1), evidence };
 }
 var systemPrompt7 = `
 ## SDK: Whisperr for React Native \u2014 package \`@whisperr/react-native\`
 
-1) Install \`@whisperr/react-native\` with the repo's package manager. If it has
-   native modules, run pod install for iOS (mention it; don't attempt to build).
+Pure TypeScript, ZERO native code and zero dependencies of its own: it works in
+Expo Go, bare React Native, and dev clients with no pod install, no config
+plugin, no prebuild. Do not add or modify anything under ios/ or android/ for
+the SDK itself.
+
+0) Expo or bare? Decide first \u2014 it changes storage install + key handling.
+   Expo = \`expo\` in package.json dependencies (usually with app.json /
+   app.config.* containing an "expo" key).
+
+1) Install with the repo's package manager (pick by lockfile: pnpm-lock.yaml \u2192
+   pnpm, yarn.lock \u2192 yarn, bun.lockb \u2192 bun, else npm):
+       <pm> add @whisperr/react-native
+
+2) Durable storage \u2014 IMPORTANT. The SDK's offline queue is MEMORY-ONLY unless
+   you inject an AsyncStorage-compatible adapter (\`getItem\`/\`setItem\`/
+   \`removeItem\`); the SDK never imports native modules itself. In priority
+   order:
+   - \`@react-native-async-storage/async-storage\` already a dependency \u2192 import
+     it and pass as \`storage\`.
+   - The app already uses \`react-native-mmkv\` \u2192 reuse its existing instance
+     with a 3-line adapter (do NOT add a new storage dep):
+       const storage = {
+         getItem: (k: string) => mmkv.getString(k) ?? null,
+         setItem: (k: string, v: string) => { mmkv.set(k, v); },
+         removeItem: (k: string) => { mmkv.delete(k); },
+       };
+   - Neither \u2192 add async-storage. Expo: run \`npx expo install
+     @react-native-async-storage/async-storage\` via bash (installs the
+     SDK-matched version; works in Expo Go \u2014 it ships in the Go client). Bare
+     RN: \`<pm> add @react-native-async-storage/async-storage\` and note
+     "run npx pod-install before the next iOS build" as a follow-up (it IS a
+     native module; do not run pod install yourself).
+   Never silently ship without storage \u2014 if you genuinely can't add it, say so
+   in the summary.
+
+3) Initialize ONCE via a module singleton, e.g. src/whisperr.ts (match the
+   repo's source layout \u2014 src/, lib/, app/lib/\u2026):
+       import AsyncStorage from '@react-native-async-storage/async-storage';
+       import { Whisperr } from '@whisperr/react-native';
 
-2) Initialize once at the app root (App.tsx / app/_layout.tsx for Expo Router):
-     import { Whisperr } from '@whisperr/react-native';
-     Whisperr.init({ apiKey: <key from manifest/env>, baseUrl: <manifest baseUrl> });
-
-3) identify() after auth resolves / on session restore; reset() on logout.
-   For channels: email/phone where known, and the push token (expo-notifications
-   or @react-native-firebase/messaging) if the app has push set up.
-
-4) track() in event handlers / business logic, never in render. event_type
-   verbatim from the manifest.
+       export const whisperr = Whisperr.init({
+         apiKey: process.env.EXPO_PUBLIC_WHISPERR_KEY!,
+         storage: AsyncStorage,
+         baseUrl: '<INGESTION_BASE_URL from manifest>', // omit if it's the SDK default
+       });
+   Import the module for its side effect from the app entry: Expo Router \u2192
+   app/_layout.tsx (root layout); bare / React Navigation \u2192 App.tsx (or
+   index.js). Prefer the singleton over <WhisperrProvider> \u2014 auth listeners,
+   API clients, and non-component code can import it directly. If the codebase
+   is strongly hook-oriented you may ADDITIONALLY wrap the root with
+   <WhisperrProvider client={whisperr}> and use useWhisperr() in components \u2014
+   but never create a second client.
+   Whisperr.init() is an idempotent singleton \u2014 safe under Fast Refresh and
+   React StrictMode.
+
+   Key handling (the key is a publishable ingestion key \u2014 shipping it in the
+   bundle is expected):
+   - Expo SDK 49+: put EXPO_PUBLIC_WHISPERR_KEY=<key> in .env (create or
+     append) and mirror it in .env.example; reference via
+     process.env.EXPO_PUBLIC_WHISPERR_KEY.
+   - Bare RN with react-native-config: add WHISPERR_KEY to .env and read
+     Config.WHISPERR_KEY.
+   - Otherwise: a small constants file with the literal key is acceptable.
+
+4) identify() right after the end-user is known \u2014 on login/signup success AND
+   on session restore at app startup:
+       whisperr.identify(user.id, {
+         traits: { /* manifest traits sourced from the user object */ },
+         email: user.email,           // shortcut \u2192 opted-in email channel
+         phone: user.phone,           // shortcut \u2192 sms channel
+         pushToken: expoPushToken,    // shortcut \u2192 push channel, if the app
+                                      // registers for push (expo-notifications
+                                      // or @react-native-firebase/messaging)
+       });
+   Call whisperr.reset() on logout (already-queued events keep their user).
+   ANONYMOUS EVENTS ARE FINE: track() before identify() buffers on-device and
+   attributes to the user retroactively on identify() \u2014 do NOT gate track()
+   calls behind auth state, and do NOT skip pre-login manifest events.
+
+5) track() in event handlers / business logic (onPress, mutation onSuccess,
+   store/saga/thunk actions) \u2014 never in render:
+       whisperr.track('event_type_from_manifest', { /* properties in scope */ });
+   Synchronous fire-and-forget: it returns void \u2014 do NOT await it. Batching,
+   retries, background flush are all internal. event_type verbatim snake_case
+   from the manifest \u2014 the SDK client-side drops invalid names.
 
-Notes:
-- Persisted offline queue is built in (AsyncStorage); fire-and-forget is fine.
-- Prefer an env/config mechanism (react-native-config, app.config) for the key
-  if one exists; otherwise a constants file is acceptable.
+Notes / gotchas:
+- Every call is sync void except flush(); the only sensible manual flush is
+  \`await whisperr.flush()\` right before something destroys the process.
+- The SDK auto-flushes on an interval, at 20 queued events, and when the app
+  backgrounds. Don't sprinkle flush() calls.
+- whisperr.screen(name) records a screen_viewed event \u2014 wire it to the
+  navigation container's state-change callback ONLY if the manifest includes a
+  screen/page-view style event; otherwise leave navigation alone.
+- Works on the New Architecture and in Expo Go by construction (no native
+  code). Never suggest expo prebuild / dev-client for this SDK.
 `.trim();
 var reactNativePlaybook = {
   target: target7,
@@ -703,9 +787,9 @@ var reactNativePlaybook = {
 // src/core/playbooks/swift.ts
 var target8 = {
   id: "swift",
-  displayName: "Swift (iOS)",
+  displayName: "Swift (iOS / Apple)",
   language: "swift",
-  availability: "planned"
+  availability: "available"
 };
 async function detect8(ctx) {
   const evidence = [];
@@ -727,40 +811,115 @@ async function detect8(ctx) {
     evidence.push("Podfile");
     confidence += 0.2;
   }
+  if (await ctx.exists("Project.swift")) {
+    evidence.push("Project.swift (Tuist)");
+    confidence += 0.4;
+  }
+  if (await ctx.exists("project.yml")) {
+    evidence.push("project.yml (XcodeGen)");
+    confidence += 0.3;
+  }
   if (confidence === 0) return null;
   return { target: target8, confidence: Math.min(confidence, 1), evidence };
 }
 var systemPrompt8 = `
-## SDK: Whisperr for Swift (iOS) \u2014 Swift Package \`Whisperr\`
-
-1) Add the Swift Package dependency (github.com/WhisperrAI/whisperr-swift). If the
-   project uses Package.swift, add it there; if it's an .xcodeproj/.xcworkspace,
-   you cannot edit the project graph reliably from the shell \u2014 instead leave a
-   clearly commented setup note and the exact import + init code, and report it
-   as a manual follow-up.
-
-2) Initialize once at launch in the App struct (SwiftUI) or
-   application(_:didFinishLaunchingWithOptions:) (UIKit):
-     import Whisperr
-     Whisperr.initialize(apiKey: "<key>", baseUrl: "<manifest baseUrl>")
-
-3) identify() after the user is known / on session restore:
-     Whisperr.shared.identify("<external user id>", traits: [...], email: ..., phone: ...)
-   reset() on logout. Push channel = APNs device token if the app registers for
-   remote notifications.
+## SDK: Whisperr for Swift \u2014 Swift Package \`Whisperr\` (github.com/WhisperrAI/whisperr-swift)
+
+Platforms: iOS 13+, macOS 12+, tvOS 13+, watchOS 6+. The client is a Swift
+ACTOR: every call is \`await\`ed, and identify()/track() are throwing. Getting
+the concurrency and JSONValue details below right is what makes the diff
+compile first try.
+
+1) Dependency \u2014 pick by how the project is defined:
+   - Package.swift: add to the package's dependencies
+         .package(url: "https://github.com/WhisperrAI/whisperr-swift.git", from: "0.1.0")
+     and \`"Whisperr"\` to the app target's dependencies array.
+   - Tuist (Project.swift) or XcodeGen (project.yml): these manifests are plain
+     text \u2014 add the SPM package + product there following the file's existing
+     style.
+   - Raw .xcodeproj / .xcworkspace only: do NOT hand-edit project.pbxproj to
+     add a package reference (fragile, breaks the project on a bad GUID).
+     Write ALL the integration code anyway (imports, init, identify, track),
+     add a short WHISPERR_SETUP.md with the one manual step \u2014 Xcode \u2192 File \u2192
+     Add Package Dependencies\u2026 \u2192 \`https://github.com/WhisperrAI/whisperr-swift\`
+     \u2192 add "Whisperr" to the app target \u2014 and report that as the single manual
+     follow-up in your summary.
+
+2) Initialize once at launch.
+   SwiftUI:
+       import Whisperr
+
+       @main
+       struct MyApp: App {
+           init() {
+               Task { await Whisperr.initialize(apiKey: "<INGESTION_API_KEY>") }
+           }
+           // ... existing body
+       }
+   UIKit: same Task { } inside application(_:didFinishLaunchingOptions:).
+   Only pass a base URL if the manifest's differs from the SDK default:
+       await Whisperr.initialize(apiKey: "...", baseURL: URL(string: "<INGESTION_BASE_URL>")!)
+   Note baseURL takes a URL, not a String. Prefer reading the key from
+   Info.plist / an .xcconfig if the project already uses that pattern;
+   otherwise a literal is acceptable (publishable ingestion key).
+
+3) identify() right after the end-user is known \u2014 login/signup success AND
+   session restore. All calls go through the async optional singleton
+   \`await Whisperr.shared\`; in synchronous contexts wrap in Task { }:
+       Task {
+           try? await Whisperr.shared?.identify(
+               user.id,                    // stable external id \u2014 never a device id
+               traits: ["plan": .string(user.plan)],
+               email: user.email,          // shortcut \u2192 opted-in email channel
+               phone: user.phone,          // shortcut \u2192 sms channel
+               pushToken: apnsTokenHex     // if the app registers for remote notifications
+           )
+       }
+   Logout:
+       Task { await Whisperr.shared?.reset() }   // flushes, then clears the user
+   For explicit channel consent/verification use WhisperrChannel:
+       channels: [.email("a@b.com", verified: true), .sms("+1555\u2026", optedIn: false)]
+
+4) track() in action handlers / view-model methods \u2014 never in a View body:
+       Task {
+           try? await Whisperr.shared?.track(
+               "event_type_from_manifest",
+               properties: ["amount_cents": .number(Double(amountCents)),
+                            "plan": .string(plan)]
+           )
+       }
+   Awaiting only ENQUEUES (delivery batches in the background) \u2014 \`try? await\`
+   inside Task { } is the correct fire-and-forget in UI code. In an already-
+   async throwing context, plain \`try await\` is fine. event_type verbatim
+   snake_case from the manifest.
+
+CRITICAL \u2014 JSONValue typing for properties/traits:
+   Values are \`JSONValue\`, not \`Any\`. LITERALS convert automatically \u2014
+   \`["plan": "pro", "amount": 42, "active": true]\` compiles as-is \u2014 but
+   VARIABLES must be wrapped: \`.string(user.plan)\`, \`.number(Double(count))\`,
+   \`.bool(flag)\`, \`.array(...)\`, \`.object(...)\`. Mixing literals and wrapped
+   variables in one dictionary is fine. Forgetting the wrapper is the #1
+   compile error \u2014 check every non-literal value you pass.
+
+CRITICAL \u2014 no anonymous buffering in this SDK:
+   track() THROWS WhisperrClientError.missingUserID until identify() has run in
+   this process (or when you pass \`userID:\` explicitly). Session restore must
+   therefore call identify() early at startup. Do not place track() on
+   pre-auth surfaces (onboarding, login screen) unless you pass
+   \`userID: "<id>"\` \u2014 if a manifest event genuinely happens before the user
+   exists, skip it and note it in the summary.
 
-4) track() in action handlers / view-model methods, not in view body:
-     Whisperr.shared.track("event_type_from_manifest", properties: [ ... ])
-   event_type verbatim (snake_case) from the manifest.
-
-Notes:
-- Prefer reading the key from Info.plist / an xcconfig if the project uses one.
-- Do not attempt to run xcodebuild; verification is the human's step here.
+Notes / gotchas:
+- \`Whisperr.shared\` is \`async\` and optional \u2014 the call shape is always
+  \`await Whisperr.shared?.method(...)\`. Never store it in a non-async global.
+- The queue persists via UserDefaults and survives restarts; retries, backoff,
+  and auth-pause semantics are built in. No manual flush() needed.
+- Do not run xcodebuild, swift build, or tests \u2014 the human verifies in Xcode.
 `.trim();
 var swiftPlaybook = {
   target: target8,
   detect: detect8,
-  packageRef: "Whisperr (Swift Package)",
+  packageRef: "whisperr-swift (Swift Package)",
   systemPrompt: systemPrompt8
 };
 
@@ -989,6 +1148,341 @@ function mockManifest(appId, config) {
 // src/core/agent.ts
 import { query } from "@anthropic-ai/claude-agent-sdk";
 
+// src/core/opportunities.ts
+import { readFile as readFile3, rm as rm2 } from "fs/promises";
+import { join as join3 } from "path";
+
+// src/core/git.ts
+import { spawn } from "child_process";
+import { createHash } from "crypto";
+import { mkdir, readFile as readFile2, rm, writeFile } from "fs/promises";
+import { basename, dirname, join as join2 } from "path";
+async function takeCheckpoint(repoPath) {
+  const isRepo = (await run(repoPath, ["rev-parse", "--is-inside-work-tree"])).ok;
+  if (!isRepo) return { isRepo: false };
+  const branch = (await run(repoPath, ["rev-parse", "--abbrev-ref", "HEAD"])).stdout.trim();
+  const head = await run(repoPath, ["rev-parse", "HEAD"]);
+  return {
+    isRepo: true,
+    baseRef: head.ok ? head.stdout.trim() : void 0,
+    branch: branch || void 0
+  };
+}
+async function changedFiles(repoPath, checkpoint) {
+  if (!checkpoint.isRepo) return [];
+  const tracked = await run(repoPath, ["diff", "--name-only"]);
+  const untracked = await run(repoPath, [
+    "ls-files",
+    "--others",
+    "--exclude-standard"
+  ]);
+  const set = /* @__PURE__ */ new Set();
+  for (const f of `${tracked.stdout}
+${untracked.stdout}`.split("\n")) {
+    if (f.trim()) set.add(f.trim());
+  }
+  return [...set];
+}
+function revertHint(checkpoint) {
+  if (!checkpoint.isRepo || !checkpoint.baseRef) return void 0;
+  return `git restore . && git clean -fd   (back to ${checkpoint.baseRef.slice(0, 7)})`;
+}
+async function wasTrackedAtCheckpoint(repoPath, checkpoint, file) {
+  if (!checkpoint.isRepo) return false;
+  if (checkpoint.baseRef) {
+    const res2 = await run(repoPath, [
+      "ls-tree",
+      "--name-only",
+      checkpoint.baseRef,
+      "--",
+      file
+    ]);
+    return res2.ok && res2.stdout.trim() !== "";
+  }
+  const res = await run(repoPath, ["ls-files", "--", file]);
+  return res.ok && res.stdout.trim() !== "";
+}
+async function isWorkingTreeClean(repoPath) {
+  const status = await run(repoPath, ["status", "--porcelain"]);
+  return status.ok && status.stdout.trim() === "";
+}
+async function revertToCheckpoint(repoPath, checkpoint) {
+  if (!checkpoint.isRepo) return false;
+  if (checkpoint.baseRef) {
+    const reset = await run(repoPath, ["reset", "--hard", checkpoint.baseRef]);
+    const clean2 = await run(repoPath, ["clean", "-fd"]);
+    return reset.ok && clean2.ok;
+  }
+  const restore = await run(repoPath, ["restore", "."]);
+  const clean = await run(repoPath, ["clean", "-fd"]);
+  return restore.ok && clean.ok;
+}
+async function snapshotChanges(repoPath, checkpoint) {
+  const snapshot = /* @__PURE__ */ new Map();
+  for (const file of await changedFiles(repoPath, checkpoint)) {
+    try {
+      snapshot.set(file, await readFile2(join2(repoPath, file)));
+    } catch {
+      snapshot.set(file, null);
+    }
+  }
+  return snapshot;
+}
+function snapshotsEqual(a, b) {
+  if (a.size !== b.size) return false;
+  for (const [file, content] of a) {
+    const other = b.get(file);
+    if (other === void 0) return false;
+    if (content === null || other === null) {
+      if (content !== other) return false;
+    } else if (!content.equals(other)) {
+      return false;
+    }
+  }
+  return true;
+}
+async function restoreToSnapshot(repoPath, checkpoint, snapshot) {
+  try {
+    const current = await changedFiles(repoPath, checkpoint);
+    for (const file of /* @__PURE__ */ new Set([...current, ...snapshot.keys()])) {
+      const recorded = snapshot.get(file);
+      const path = join2(repoPath, file);
+      if (recorded === void 0) {
+        if (checkpoint.baseRef) {
+          const co = await run(repoPath, ["checkout", checkpoint.baseRef, "--", file]);
+          if (co.ok) continue;
+        }
+        await rm(path, { force: true });
+      } else if (recorded === null) {
+        await rm(path, { force: true });
+      } else {
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, recorded);
+      }
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function repoFingerprint(repoPath) {
+  const remote = await run(repoPath, ["remote", "get-url", "origin"]);
+  const seed = remote.ok && remote.stdout.trim() ? normalizeRemote(remote.stdout.trim()) : `dir:${basename(repoPath)}`;
+  return createHash("sha256").update(seed).digest("hex").slice(0, 16);
+}
+function normalizeRemote(url) {
+  return url.replace(/^git@([^:]+):/, "$1/").replace(/^https?:\/\//, "").replace(/\.git$/, "").replace(/\/+$/, "").toLowerCase();
+}
+async function scanWiredEvents(repoPath, files, eventTypes) {
+  const wired = /* @__PURE__ */ new Map();
+  const patterns = eventTypes.map((e) => ({
+    eventType: e,
+    re: new RegExp(
+      `\\btrack\\s*\\(\\s*[\\s\\S]{0,160}?['"\`]${escapeRegExp(e)}['"\`]`
+    )
+  }));
+  for (const file of files) {
+    let content = "";
+    try {
+      content = await readFile2(join2(repoPath, file), "utf8");
+    } catch {
+      continue;
+    }
+    for (const { eventType, re } of patterns) {
+      if (!wired.has(eventType) && re.test(content)) {
+        wired.set(eventType, file);
+      }
+    }
+  }
+  return wired;
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function run(cwd, args) {
+  return new Promise((resolve2) => {
+    const child = spawn("git", args, { cwd });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => stdout += d.toString());
+    child.stderr.on("data", (d) => stderr += d.toString());
+    child.on("close", (code) => resolve2({ ok: code === 0, stdout, stderr }));
+    child.on("error", () => resolve2({ ok: false, stdout, stderr }));
+  });
+}
+
+// src/core/opportunities.ts
+var OPPORTUNITIES_FILE = "whisperr-opportunities.json";
+function normalizeCode(value) {
+  return value.trim().toLowerCase().replace(/[ \-./]/g, "_").replace(/[^a-z0-9_]/g, "").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+}
+async function collectOpportunities(repoPath, manifest, checkpoint) {
+  const path = join3(repoPath, OPPORTUNITIES_FILE);
+  if (await wasTrackedAtCheckpoint(repoPath, checkpoint, OPPORTUNITIES_FILE)) {
+    return { events: [], interventions: [] };
+  }
+  let rawText;
+  try {
+    rawText = await readFile3(path, "utf8");
+  } catch {
+    return { events: [], interventions: [] };
+  }
+  await rm2(path, { force: true }).catch(() => {
+  });
+  let raw;
+  try {
+    raw = JSON.parse(rawText);
+  } catch {
+    return { events: [], interventions: [] };
+  }
+  return sanitizeOpportunities(raw, manifest);
+}
+function sanitizeOpportunities(raw, manifest) {
+  const out = { events: [], interventions: [] };
+  if (typeof raw !== "object" || raw === null) return out;
+  const doc = raw;
+  const knownEvents = new Set(manifest.events.map((e) => normalizeCode(e.eventType)));
+  const knownInterventions = new Set(
+    manifest.events.flatMap((e) => e.interventions ?? []).map((i) => normalizeCode(i.code))
+  );
+  const seenEvents = /* @__PURE__ */ new Set();
+  for (const entry of asArray(doc.events)) {
+    const ev = coerceEvent(entry);
+    if (!ev) continue;
+    if (knownEvents.has(ev.code) || seenEvents.has(ev.code)) continue;
+    seenEvents.add(ev.code);
+    out.events.push(ev);
+  }
+  const seenInterventions = /* @__PURE__ */ new Set();
+  for (const entry of asArray(doc.interventions)) {
+    const iv = coerceIntervention(entry);
+    if (!iv) continue;
+    if (knownInterventions.has(iv.code) || seenInterventions.has(iv.code)) continue;
+    seenInterventions.add(iv.code);
+    out.interventions.push(iv);
+  }
+  return out;
+}
+var SUBMIT_TIMEOUT_MS = 3e4;
+async function submitAdditions(config, session, target9, repoFingerprint2, opportunities) {
+  const res = await fetch(`${config.apiBaseUrl}/wizard/universe/additions`, {
+    method: "POST",
+    signal: AbortSignal.timeout(SUBMIT_TIMEOUT_MS),
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${session.token}`
+    },
+    body: JSON.stringify({
+      target: target9,
+      repoFingerprint: repoFingerprint2,
+      events: opportunities.events,
+      interventions: opportunities.interventions
+    })
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(
+      `Submitting universe additions failed (${res.status})${body ? `: ${body.slice(0, 300)}` : ""}`
+    );
+  }
+  return await res.json();
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function asString(value) {
+  if (typeof value !== "string") return void 0;
+  const cleaned = value.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, "").replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?/g, "").replace(/[\x00-\x1f\x7f]/g, " ").replace(/ {2,}/g, " ").trim();
+  return cleaned ? cleaned : void 0;
+}
+function asConfidence(value) {
+  if (typeof value !== "number" || Number.isNaN(value)) return void 0;
+  return Math.min(1, Math.max(0, value));
+}
+function asWeight(value) {
+  if (typeof value !== "number" || Number.isNaN(value)) return void 0;
+  if (value < 0 || value > 1) return void 0;
+  return value;
+}
+function coerceEvent(entry) {
+  if (typeof entry !== "object" || entry === null) return null;
+  const e = entry;
+  const code = normalizeCode(asString(e.code) ?? "");
+  if (!code) return null;
+  const properties = [];
+  for (const prop of asArray(e.properties)) {
+    if (typeof prop === "string") {
+      if (prop.trim()) properties.push({ name: prop.trim() });
+      continue;
+    }
+    if (typeof prop !== "object" || prop === null) continue;
+    const pr = prop;
+    const name = asString(pr.name);
+    if (!name) continue;
+    const desc = asString(pr.description);
+    properties.push({
+      name,
+      ...desc ? { description: desc } : {},
+      ...pr.required === true ? { required: true } : {}
+    });
+  }
+  const links = [];
+  for (const link of asArray(e.links)) {
+    if (typeof link !== "object" || link === null) continue;
+    const l = link;
+    const interventionCode = normalizeCode(asString(l.interventionCode) ?? "");
+    if (!interventionCode) continue;
+    const weight = asWeight(l.weight);
+    links.push({ interventionCode, ...weight !== void 0 ? { weight } : {} });
+  }
+  const side = normalizeSide(asString(e.side));
+  return {
+    code,
+    label: asString(e.label),
+    description: asString(e.description),
+    ...side ? { side } : {},
+    rationale: asString(e.rationale),
+    confidence: asConfidence(e.confidence),
+    ...properties.length ? { properties } : {},
+    ...links.length ? { links } : {}
+  };
+}
+function coerceIntervention(entry) {
+  if (typeof entry !== "object" || entry === null) return null;
+  const i = entry;
+  const code = normalizeCode(asString(i.code) ?? "");
+  if (!code) return null;
+  const links = [];
+  for (const link of asArray(i.links)) {
+    if (typeof link !== "object" || link === null) continue;
+    const l = link;
+    const eventCode = normalizeCode(asString(l.eventCode) ?? "");
+    if (!eventCode) continue;
+    const weight = asWeight(l.weight);
+    links.push({ eventCode, ...weight !== void 0 ? { weight } : {} });
+  }
+  return {
+    code,
+    label: asString(i.label),
+    description: asString(i.description),
+    rationale: asString(i.rationale),
+    confidence: asConfidence(i.confidence),
+    ...links.length ? { links } : {}
+  };
+}
+function normalizeSide(value) {
+  switch (value?.toLowerCase()) {
+    case "frontend":
+      return "frontend";
+    case "backend":
+      return "backend";
+    case "either":
+      return "either";
+    default:
+      return void 0;
+  }
+}
+
 // src/core/playbooks/shared-prompt.ts
 var BASE_WIZARD_PROMPT = `
 You are the Whisperr Wizard \u2014 an expert integration agent running INSIDE a
@@ -1165,6 +1659,46 @@ function renderEventsBrief(m) {
   }
   return lines.join("\n");
 }
+function renderOpportunitiesBrief(m, opportunitiesFile) {
+  const eventCodes = m.events.map((e) => e.eventType);
+  const interventionCodes = [
+    ...new Set(m.events.flatMap((e) => e.interventions ?? []).map((i) => i.code))
+  ];
+  return [
+    "UNIVERSE OPPORTUNITIES (do this LAST, after your corrections):",
+    "While auditing you read this app's real lifecycle. If you found churn-",
+    "relevant moments the plan does NOT cover \u2014 e.g. a recurring-payment or",
+    "cancellation path with no event, a support/refund flow worth a retention",
+    "play \u2014 record them as PROPOSALS. Do NOT add track() calls for them.",
+    `Write a single JSON file at the repo root named ${opportunitiesFile}:`,
+    "",
+    "{",
+    '  "events": [{',
+    '    "code": "snake_case_event", "label": "...", "description": "...",',
+    '    "side": "frontend|backend|either", "rationale": "what in the code shows this",',
+    '    "confidence": 0.0-1.0,',
+    '    "properties": [{"name": "...", "description": "...", "required": false}],',
+    '    "links": [{"interventionCode": "existing_or_proposed", "weight": 0.0-1.0}]',
+    "  }],",
+    '  "interventions": [{',
+    '    "code": "snake_case_strategy", "label": "...", "description": "...",',
+    '    "rationale": "...", "confidence": 0.0-1.0,',
+    '    "links": [{"eventCode": "existing_or_proposed", "weight": 0.0-1.0}]',
+    "  }]",
+    "}",
+    "",
+    "Rules:",
+    `- The plan already covers these events: ${eventCodes.join(", ") || "(none)"}.`,
+    `  And these interventions: ${interventionCodes.join(", ") || "(none)"}.`,
+    "  Propose ONLY what is genuinely missing \u2014 never re-propose or rename these.",
+    "- Every proposal needs concrete code evidence in its rationale (file/flow),",
+    "  not speculation. 0-3 events and 0-2 interventions is the normal range;",
+    "  an empty file or no file at all is a perfectly good outcome.",
+    "- Link each proposed event to the intervention(s) it should feed (existing",
+    "  codes or ones you propose in the same file).",
+    "- This file is metadata for the wizard, not app code \u2014 write it and move on."
+  ].join("\n");
+}
 function coverageNote(coverage) {
   if (!coverage?.length) return "";
   const here = coverage.find((c) => c.sameSurface && c.status === "wired");
@@ -1289,8 +1823,12 @@ ${events.summary}`);
       "4. Coverage \u2014 every gateway/callback path that should emit an event does;",
       "   no recurring or secondary path left as a dead zone.",
       "Change ONLY what is genuinely wrong or incomplete \u2014 do not churn correct",
-      "calls or re-explore the whole repo. Be surgical. End with a one-line,",
-      "plain-text note of what you corrected, or 'No corrections needed.'."
+      "calls or re-explore the whole repo. Be surgical.",
+      "",
+      renderOpportunitiesBrief(manifest, OPPORTUNITIES_FILE),
+      "",
+      "End with a one-line, plain-text note of what you corrected (or 'No",
+      "corrections needed.'), plus one line on what you proposed, if anything."
     ].join("\n");
     const review = await runPass({
       prompt: reviewPrompt,
@@ -1314,6 +1852,53 @@ ${review.summary}`);
     eventsComplete
   };
 }
+async function runAdditionsInstrumentationPass(opts) {
+  const { repoPath, config, session, playbook, acceptedEvents, budgetUsd, progress } = opts;
+  if (!acceptedEvents.length || budgetUsd <= 0) {
+    return { summary: "", costUsd: 0, ran: false };
+  }
+  applyModelAuthEnv(config, session);
+  const systemPrompt9 = [BASE_WIZARD_PROMPT, playbook.systemPrompt].join("\n\n");
+  const eventLines = [];
+  for (const e of acceptedEvents) {
+    eventLines.push("");
+    eventLines.push(`\u25A0 ${e.code}${e.label ? `  (${e.label})` : ""}`);
+    if (e.description) eventLines.push(`  ${e.description}`);
+    if (e.rationale) eventLines.push(`  where: ${e.rationale}`);
+    if (e.properties?.length) {
+      eventLines.push("  properties to capture if available:");
+      for (const prop of e.properties) {
+        eventLines.push(`    \xB7 ${prop.name}${prop.required ? " (required)" : ""}${prop.description ? ` \u2014 ${prop.description}` : ""}`);
+      }
+    }
+  }
+  progress?.onPhase?.("Instrumenting the newly added events");
+  const prompt = [
+    "You proposed these events as universe opportunities while reviewing this",
+    "repo, and the user just APPROVED adding them to the plan. Instrument them",
+    "now with track(), exactly like the plan's other events: place each at the",
+    "real call site (your own rationale tells you where you saw it), attach the",
+    "properties available in scope, and skip anything that turns out not to have",
+    "a clear trigger after all. The SDK is already installed and initialized.",
+    `Project root: ${repoPath}`,
+    "",
+    "----- APPROVED NEW EVENTS -----",
+    ...eventLines,
+    "",
+    "----- END -----"
+  ].join("\n");
+  const pass = await runPass({
+    prompt,
+    systemPrompt: systemPrompt9,
+    repoPath,
+    model: config.model,
+    effort: config.effort,
+    maxTurns: 25,
+    budgetUsd,
+    progress
+  });
+  return { summary: pass.summary, costUsd: pass.costUsd, ran: true };
+}
 function isLimitStop(err) {
   const msg = err?.message ?? "";
   return /max(imum)?[\s_-]*(turn|budget)|budget.*exceeded|number of turns/i.test(msg);
@@ -1423,102 +2008,6 @@ function short(s, max = 60) {
   return s.length > max ? `${s.slice(0, max - 1)}\u2026` : s;
 }
 
-// src/core/git.ts
-import { spawn } from "child_process";
-import { createHash } from "crypto";
-import { readFile as readFile2 } from "fs/promises";
-import { basename, join as join2 } from "path";
-async function takeCheckpoint(repoPath) {
-  const isRepo = (await run(repoPath, ["rev-parse", "--is-inside-work-tree"])).ok;
-  if (!isRepo) return { isRepo: false };
-  const branch = (await run(repoPath, ["rev-parse", "--abbrev-ref", "HEAD"])).stdout.trim();
-  const head = await run(repoPath, ["rev-parse", "HEAD"]);
-  return {
-    isRepo: true,
-    baseRef: head.ok ? head.stdout.trim() : void 0,
-    branch: branch || void 0
-  };
-}
-async function changedFiles(repoPath, checkpoint) {
-  if (!checkpoint.isRepo) return [];
-  const tracked = await run(repoPath, ["diff", "--name-only"]);
-  const untracked = await run(repoPath, [
-    "ls-files",
-    "--others",
-    "--exclude-standard"
-  ]);
-  const set = /* @__PURE__ */ new Set();
-  for (const f of `${tracked.stdout}
-${untracked.stdout}`.split("\n")) {
-    if (f.trim()) set.add(f.trim());
-  }
-  return [...set];
-}
-function revertHint(checkpoint) {
-  if (!checkpoint.isRepo || !checkpoint.baseRef) return void 0;
-  return `git restore . && git clean -fd   (back to ${checkpoint.baseRef.slice(0, 7)})`;
-}
-async function isWorkingTreeClean(repoPath) {
-  const status = await run(repoPath, ["status", "--porcelain"]);
-  return status.ok && status.stdout.trim() === "";
-}
-async function revertToCheckpoint(repoPath, checkpoint) {
-  if (!checkpoint.isRepo) return false;
-  if (checkpoint.baseRef) {
-    const reset = await run(repoPath, ["reset", "--hard", checkpoint.baseRef]);
-    const clean2 = await run(repoPath, ["clean", "-fd"]);
-    return reset.ok && clean2.ok;
-  }
-  const restore = await run(repoPath, ["restore", "."]);
-  const clean = await run(repoPath, ["clean", "-fd"]);
-  return restore.ok && clean.ok;
-}
-async function repoFingerprint(repoPath) {
-  const remote = await run(repoPath, ["remote", "get-url", "origin"]);
-  const seed = remote.ok && remote.stdout.trim() ? normalizeRemote(remote.stdout.trim()) : `dir:${basename(repoPath)}`;
-  return createHash("sha256").update(seed).digest("hex").slice(0, 16);
-}
-function normalizeRemote(url) {
-  return url.replace(/^git@([^:]+):/, "$1/").replace(/^https?:\/\//, "").replace(/\.git$/, "").replace(/\/+$/, "").toLowerCase();
-}
-async function scanWiredEvents(repoPath, files, eventTypes) {
-  const wired = /* @__PURE__ */ new Map();
-  const patterns = eventTypes.map((e) => ({
-    eventType: e,
-    re: new RegExp(
-      `\\btrack\\s*\\(\\s*[\\s\\S]{0,160}?['"\`]${escapeRegExp(e)}['"\`]`
-    )
-  }));
-  for (const file of files) {
-    let content = "";
-    try {
-      content = await readFile2(join2(repoPath, file), "utf8");
-    } catch {
-      continue;
-    }
-    for (const { eventType, re } of patterns) {
-      if (!wired.has(eventType) && re.test(content)) {
-        wired.set(eventType, file);
-      }
-    }
-  }
-  return wired;
-}
-function escapeRegExp(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function run(cwd, args) {
-  return new Promise((resolve2) => {
-    const child = spawn("git", args, { cwd });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (d) => stdout += d.toString());
-    child.stderr.on("data", (d) => stderr += d.toString());
-    child.on("close", (code) => resolve2({ ok: code === 0, stdout, stderr }));
-    child.on("error", () => resolve2({ ok: false, stdout, stderr }));
-  });
-}
-
 // src/core/verify.ts
 async function pollFirstEvent(config, session, opts = {}) {
   if (config.offline) return { received: false };
@@ -1546,6 +2035,10 @@ async function pollFirstEvent(config, session, opts = {}) {
 
 // src/core/postflight.ts
 import { spawn as spawn2 } from "child_process";
+function verdictToVerified(verdict) {
+  if (verdict.toolMissing || verdict.timedOut) return null;
+  return verdict.ok;
+}
 var MAX_OUTPUT = 4e3;
 var DEFAULT_TIMEOUT_MS = 18e4;
 function runVerifyCommand(repoPath, command, opts = {}) {
@@ -1737,6 +2230,7 @@ Flutter is live today; ${theme.bright(
   }
   const stopLabel = !outcome.coreOk ? theme.warn("Stopped early \u2014 partial setup is in your working tree") : outcome.eventsComplete ? theme.success("Integration complete") : theme.success("Core integration done") + theme.muted(" \u2014 some events left as follow-ups");
   spin.stop(stopLabel);
+  const opportunities = await collectOpportunities(repoPath, manifest, checkpoint);
   const files = await changedFiles(repoPath, checkpoint);
   if (files.length) {
     p.note(files.map((f) => theme.muted("\u2022 ") + f).join("\n"), "Files changed");
@@ -1761,6 +2255,7 @@ Flutter is live today; ${theme.bright(
     const vspin = p.spinner();
     vspin.start(`Verifying the integration \u2014 ${theme.muted(cmd)}`);
     const verdict = await runVerifyCommand(repoPath, cmd);
+    verified = verdictToVerified(verdict);
     if (verdict.toolMissing) {
       vspin.stop(
         theme.warn("Couldn't verify automatically") + theme.muted(` \u2014 \`${cmd}\` isn't available here. Run it yourself before committing.`)
@@ -1770,10 +2265,8 @@ Flutter is live today; ${theme.bright(
         theme.warn(`Verification timed out \u2014 \`${cmd}\``) + theme.muted(" \u2014 run it yourself before committing.")
       );
     } else if (verdict.ok) {
-      verified = true;
       vspin.stop(theme.success("Verified \u2713") + theme.muted(` (${cmd})`));
     } else {
-      verified = false;
       vspin.stop(theme.alert(`Verification failed \u2014 ${cmd}`));
       if (verdict.output) {
         p.note(verdict.output, theme.warn("Verifier output"));
@@ -1789,15 +2282,69 @@ Flutter is live today; ${theme.bright(
       }
     }
   }
-  const wiredMap = await scanWiredEvents(
+  const { acceptedEvents, instrumentationSnapshot } = await offerOpportunities({
     repoPath,
-    files,
-    manifest.events.map((e) => e.eventType)
-  );
-  const reportEvents = manifest.events.map((e) => ({
-    event_type: e.eventType,
-    status: wiredMap.has(e.eventType) ? "wired" : "skipped",
-    file: wiredMap.get(e.eventType)
+    config,
+    session,
+    playbook: chosen.playbook,
+    manifest,
+    opportunities,
+    fingerprint,
+    checkpoint,
+    remainingBudgetUsd: config.budgetUsd - outcome.costUsd
+  });
+  if (instrumentationSnapshot && chosen.playbook.verifyCommand) {
+    const cmd = chosen.playbook.verifyCommand;
+    const preInstrumentationVerified = verified;
+    const vspin = p.spinner();
+    vspin.start(`Re-verifying after instrumenting the new events \u2014 ${theme.muted(cmd)}`);
+    const verdict = await runVerifyCommand(repoPath, cmd);
+    verified = verdictToVerified(verdict);
+    if (verdict.toolMissing) {
+      vspin.stop(
+        theme.warn("Couldn't re-verify automatically") + theme.muted(` \u2014 \`${cmd}\` isn't available here. Run it yourself before committing.`)
+      );
+    } else if (verdict.timedOut) {
+      vspin.stop(
+        theme.warn(`Re-verification timed out \u2014 \`${cmd}\``) + theme.muted(" \u2014 run it yourself before committing.")
+      );
+    } else if (verdict.ok) {
+      vspin.stop(theme.success("Verified \u2713") + theme.muted(` (${cmd})`));
+    } else {
+      vspin.stop(theme.alert(`Verification failed after instrumenting the new events \u2014 ${cmd}`));
+      if (verdict.output) {
+        p.note(verdict.output, theme.warn("Verifier output"));
+      }
+      const doRevert = await p.confirm({
+        message: "Instrumenting the new events didn't pass the build/lint check. Revert just those edits? (The events stay in your universe \u2014 wire them on a future run.)",
+        initialValue: true
+      });
+      if (!p.isCancel(doRevert) && doRevert) {
+        if (await restoreToSnapshot(repoPath, checkpoint, instrumentationSnapshot)) {
+          verified = preInstrumentationVerified;
+          p.log.success(theme.success("Reverted the instrumentation edits."));
+        } else {
+          p.log.warn(
+            theme.warn("Couldn't revert automatically \u2014 undo manually: ") + (revertHint(checkpoint) ?? "git reset --hard")
+          );
+        }
+      } else {
+        p.log.info(
+          theme.muted("Left in your working tree \u2014 fix the verifier errors before committing.")
+        );
+      }
+    }
+  }
+  const filesForScan = acceptedEvents.length ? await changedFiles(repoPath, checkpoint) : files;
+  const eventTypesToScan = [
+    ...manifest.events.map((e) => e.eventType),
+    ...acceptedEvents.map((e) => e.code)
+  ];
+  const wiredMap = await scanWiredEvents(repoPath, filesForScan, eventTypesToScan);
+  const reportEvents = eventTypesToScan.map((eventType) => ({
+    event_type: eventType,
+    status: wiredMap.has(eventType) ? "wired" : "skipped",
+    file: wiredMap.get(eventType)
   }));
   await postRunReport(config, session, {
     target: chosen.playbook.target.id,
@@ -1811,7 +2358,7 @@ Flutter is live today; ${theme.bright(
   });
   p.log.info(
     theme.muted(
-      `${wiredMap.size}/${manifest.events.length} events wired \xB7 ${files.length} file${files.length === 1 ? "" : "s"} changed \xB7 ` + (verified === true ? "verified \xB7 " : verified === false ? "unverified \xB7 " : "") + `${Math.round(outcome.durationMs / 1e3)}s`
+      `${wiredMap.size}/${eventTypesToScan.length} events wired \xB7 ${files.length} file${files.length === 1 ? "" : "s"} changed \xB7 ` + (verified === true ? "verified \xB7 " : verified === false ? "unverified \xB7 " : "") + `${Math.round(outcome.durationMs / 1e3)}s`
     )
   );
   if (!config.offline) {
@@ -1846,6 +2393,153 @@ Flutter is live today; ${theme.bright(
   p.outro(theme.signal("\u2301 ") + theme.bright("Whisperr is wired in."));
   return 0;
 }
+var NO_ADDITIONS = { acceptedEvents: [], instrumentationSnapshot: null };
+async function offerOpportunities(opts) {
+  const { opportunities, manifest, config, session } = opts;
+  const total = opportunities.events.length + opportunities.interventions.length;
+  if (total === 0) return NO_ADDITIONS;
+  const describe = (kind, code, why) => `${theme.muted(`${kind}: `)}${theme.bright(code)}${why ? theme.muted(` \u2014 ${why}`) : ""}`;
+  p.note(
+    [
+      ...opportunities.events.map((e) => describe("event", e.code, e.rationale ?? e.description)),
+      ...opportunities.interventions.map(
+        (i) => describe("intervention", i.code, i.rationale ?? i.description)
+      )
+    ].join("\n"),
+    theme.signal("Opportunities found beyond your onboarding plan")
+  );
+  if (config.offline) {
+    p.log.info(theme.muted("Offline mode \u2014 proposals shown only, nothing submitted."));
+    return NO_ADDITIONS;
+  }
+  if (!process.stdout.isTTY || !process.stdin.isTTY) {
+    p.log.info(
+      theme.muted("Non-interactive run \u2014 proposals were not submitted. Re-run interactively to add them.")
+    );
+    return NO_ADDITIONS;
+  }
+  const selection = await p.multiselect({
+    message: "Add these to your Whisperr universe? (new interventions start paused)",
+    options: [
+      ...opportunities.events.map((e) => ({
+        value: `e:${e.code}`,
+        label: `event \xB7 ${e.code}`,
+        hint: e.description ?? e.rationale
+      })),
+      ...opportunities.interventions.map((i) => ({
+        value: `i:${i.code}`,
+        label: `intervention \xB7 ${i.code}`,
+        hint: i.description ?? i.rationale
+      }))
+    ],
+    initialValues: [
+      ...opportunities.events.map((e) => `e:${e.code}`),
+      ...opportunities.interventions.map((i) => `i:${i.code}`)
+    ],
+    required: false
+  });
+  if (p.isCancel(selection) || selection.length === 0) {
+    p.log.info(theme.muted("Skipped \u2014 your universe is unchanged."));
+    return NO_ADDITIONS;
+  }
+  const chosenSet = new Set(selection);
+  const knownInterventionCodes = new Set(
+    manifest.events.flatMap((e) => e.interventions ?? []).map((i) => i.code)
+  );
+  const knownEventCodes = new Set(manifest.events.map((e) => e.eventType));
+  const pickedEvents = opportunities.events.filter((e) => chosenSet.has(`e:${e.code}`));
+  const pickedInterventions = opportunities.interventions.filter(
+    (i) => chosenSet.has(`i:${i.code}`)
+  );
+  const pickedInterventionCodes = new Set(pickedInterventions.map((i) => i.code));
+  const pickedEventCodes = new Set(pickedEvents.map((e) => e.code));
+  const submitted = {
+    events: pickedEvents.map((e) => ({
+      ...e,
+      links: e.links?.filter(
+        (l) => knownInterventionCodes.has(l.interventionCode) || pickedInterventionCodes.has(l.interventionCode)
+      )
+    })),
+    interventions: pickedInterventions.map((i) => ({
+      ...i,
+      links: i.links?.filter(
+        (l) => knownEventCodes.has(l.eventCode) || pickedEventCodes.has(l.eventCode)
+      )
+    }))
+  };
+  let result;
+  try {
+    result = await withSpinner(
+      "Adding to your universe",
+      () => submitAdditions(config, session, opts.playbook.target.id, opts.fingerprint, submitted)
+    );
+  } catch (err) {
+    p.log.warn(
+      theme.warn("Couldn't add the proposals") + theme.muted(` \u2014 ${err.message}. Your universe is unchanged.`)
+    );
+    return NO_ADDITIONS;
+  }
+  const lines = result.outcomes.map((o) => {
+    const mark = o.status === "applied" ? theme.success("\u2713") : o.status === "duplicate" ? theme.muted("=") : theme.warn("\u2717");
+    const detail = o.status === "duplicate" ? theme.muted(` (already in your universe${o.duplicateOf && o.duplicateOf !== o.code ? ` as ${o.duplicateOf}` : ""})`) : o.status === "invalid" && o.reason ? theme.muted(` (${o.reason})`) : "";
+    return `${mark} ${o.kind} ${theme.bright(o.code)}${detail}`;
+  });
+  lines.push(
+    theme.muted(
+      `${result.applied} added \xB7 ${result.duplicates} already present \xB7 ${result.invalid} rejected`
+    )
+  );
+  if (submitted.interventions.length) {
+    lines.push(theme.muted("New interventions start paused \u2014 activate them in your dashboard."));
+  }
+  if (result.policyRegen?.status === "pending") {
+    lines.push(
+      theme.muted("Runtime policy update queued \u2014 the additions go live once it completes.")
+    );
+  }
+  p.note(lines.join("\n"), theme.signal("Universe updated"));
+  if (result.policyRegen?.status === "failed") {
+    p.log.warn(
+      theme.warn("Live runtime NOT updated") + theme.muted(
+        " \u2014 the additions were recorded, but the runtime policy wasn't regenerated" + (result.policyRegen.reason ? `: ${result.policyRegen.reason}` : "") + ". They won't drive live decisions until the policy regenerates."
+      )
+    );
+  }
+  const appliedEventCodes = new Set(
+    result.outcomes.filter((o) => o.kind === "event" && o.status === "applied").map((o) => o.code)
+  );
+  const acceptedEvents = pickedEvents.filter((e) => appliedEventCodes.has(e.code));
+  if (!acceptedEvents.length) return NO_ADDITIONS;
+  const prePass = await snapshotChanges(opts.repoPath, opts.checkpoint);
+  const spin = p.spinner();
+  spin.start(theme.bright("Instrumenting the newly added events"));
+  try {
+    const pass = await runAdditionsInstrumentationPass({
+      repoPath: opts.repoPath,
+      config,
+      session,
+      playbook: opts.playbook,
+      acceptedEvents,
+      budgetUsd: opts.remainingBudgetUsd
+    });
+    if (pass.ran) {
+      spin.stop(theme.success("New events instrumented"));
+      if (pass.summary.trim()) p.log.message(pass.summary.trim());
+    } else {
+      spin.stop(
+        theme.warn("Skipped instrumenting the new events") + theme.muted(
+          " \u2014 the spend limit was reached. They're in your universe; wire them on a future run."
+        )
+      );
+    }
+  } catch (err) {
+    spin.stop(
+      theme.warn("Couldn't instrument the new events") + theme.muted(` \u2014 ${err.message}. They're in your universe; wire them on a future run.`)
+    );
+  }
+  const edited = !snapshotsEqual(prePass, await snapshotChanges(opts.repoPath, opts.checkpoint));
+  return { acceptedEvents, instrumentationSnapshot: edited ? prePass : null };
+}
 async function maybeRevert(repoPath, checkpoint, reason) {
   if (!checkpoint.isRepo) return false;
   const files = await changedFiles(repoPath, checkpoint);
@@ -1946,7 +2640,7 @@ function summarizeManifest(m) {
 // src/index.ts
 var modulePath = fileURLToPath(import.meta.url);
 function packageVersion() {
-  const packagePath = join3(dirname(modulePath), "..", "package.json");
+  const packagePath = join4(dirname2(modulePath), "..", "package.json");
   const pkg = JSON.parse(readFileSync(packagePath, "utf8"));
   return pkg.version ?? "0.0.0";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whisperr/wizard",
-  "version": "0.1.15",
+  "version": "0.2.1",
   "description": "Whisperr Wizard — one command to integrate the Whisperr SDK into your app. Authenticates with your onboarded account and uses an AI coding agent to wire up identify() and your business events automatically.",
   "repository": {
     "type": "git",