@whisperr/wizard 0.2.0 → 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
@@ -1148,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
@@ -1324,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");
@@ -1448,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,
@@ -1473,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);
@@ -1582,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 };
@@ -1705,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 = {}) {
@@ -1896,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");
@@ -1920,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.`)
@@ -1929,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"));
@@ -1948,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,
@@ -1970,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) {
@@ -2005,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);
@@ -2105,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.2.0",
+  "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",