@whisperr/wizard 0.7.3 → 0.7.4

package/dist/index.js

@@ -5,7 +5,7 @@ import { realpathSync } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/cli.ts
-import { resolve as resolve3 } from "path";
+import { resolve as resolve5 } from "path";
 import * as p2 from "@clack/prompts";
 import open2 from "open";
 
@@ -1308,84 +1308,8 @@ function createProgressSink(options) {
 }
 
 // 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";
+import { readFile as readFile2 } from "fs/promises";
+import { basename, resolve as resolve2, sep as sep2 } from "path";
 
 // src/engine/bindings.ts
 function bindingsTargetFor(target9) {
@@ -1582,6 +1506,89 @@ function generateDart(events) {
     bindInstruction: "Call WhisperrEvents.bind(track) once, immediately after the Whisperr SDK is initialized, forwarding to the SDK's track call."
   };
 }
+function bindingsClassName(target9) {
+  return bindingsTargetFor(target9) === "typescript" ? "WhisperrEvents" : "WhisperrEvents";
+}
+function eventWrapperName(code) {
+  return `${bindingsClassName("")}.${camelCase(code)}`;
+}
+
+// src/engine/clusters.ts
+import { createHash } from "crypto";
+import { dirname } from "path";
+var MIN_CLUSTER_EVENTS = 3;
+var MAX_CLUSTER_EVENTS = 8;
+function clusterIdFor(files) {
+  const digest = createHash("sha256").update([...files].sort().join("\n")).digest("hex");
+  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/budgets.ts
 var OVERFLOW_PATTERNS = [
@@ -1666,7 +1673,7 @@ function npmCommand() {
   return process.platform === "win32" ? "npm.cmd" : "npm";
 }
 function runVerifyStep(cwd, step, timeoutMs = 3e5) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve6) => {
     const child = spawn(step.command, step.args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
     let output = "";
     const capture = (chunk) => {
@@ -1681,11 +1688,11 @@ function runVerifyStep(cwd, step, timeoutMs = 3e5) {
     }, timeoutMs);
     child.on("error", (error) => {
       clearTimeout(timer);
-      resolve4({ ...step, ok: false, output: String(error) });
+      resolve6({ ...step, ok: false, output: String(error) });
     });
     child.on("close", (exitCode) => {
       clearTimeout(timer);
-      resolve4({ ...step, ok: exitCode === 0, output });
+      resolve6({ ...step, ok: exitCode === 0, output });
     });
   });
 }
@@ -1857,6 +1864,7 @@ async function runClusterIntegration(deps, initialClusters, clusterDiff) {
       for (const placement of cluster.events) {
         eventStatuses.set(placement.eventCode, "failed");
       }
+      await deps.discardChanges();
       continue;
     }
     let statuses = "applied";
@@ -1896,6 +1904,7 @@ async function runClusterIntegration(deps, initialClusters, clusterDiff) {
     for (const placement of cluster.events) {
       eventStatuses.set(placement.eventCode, finalStatus);
     }
+    await deps.onClusterIntegrated(cluster, finalStatus);
   }
   if (!clustersComplete(clusters)) {
     throw new Error("cluster queue did not reach a terminal state");
@@ -1977,6 +1986,9 @@ var RunsClient = class {
   patchRun(runId, patch) {
     return this.request("PATCH", `/wizard/runs/${runId}`, { ...patch });
   }
+  saveProgress(runId, progress) {
+    return this.patchRun(runId, { integrationEvidence: progress });
+  }
   writeItem(runId, kind, payload, idempotencyExtra = "") {
     const code = typeof payload.code === "string" ? payload.code : JSON.stringify(payload);
     return this.request("POST", `/wizard/runs/${runId}/items`, {
@@ -2029,7 +2041,13 @@ function normalizeRunBootstrap(payload) {
       target: stringValue(project.target),
       kind: stringValue(project.kind)
     },
-    run: { id: run3.id, status: stringValue(run3.status), phase: stringValue(run3.phase) },
+    run: {
+      id: run3.id,
+      status: stringValue(run3.status),
+      phase: stringValue(run3.phase),
+      ...stringValue(run3.modelConversationId) ? { modelConversationId: stringValue(run3.modelConversationId) } : {},
+      ...normalizeIntegrationProgress(run3.integrationEvidence) ? { integrationEvidence: normalizeIntegrationProgress(run3.integrationEvidence) } : {}
+    },
     resumed: value.resumed === true,
     universeMode: stringValue(value.universeMode),
     ...record(value.onboardingContext) ? { onboardingContext: record(value.onboardingContext) } : {},
@@ -2041,6 +2059,31 @@ function normalizeRunBootstrap(payload) {
     ingestion: { apiKey: ingestion.apiKey, baseUrl: ingestion.baseUrl }
   };
 }
+function normalizeIntegrationProgress(payload) {
+  const value = record(payload);
+  if (!value || !Array.isArray(value.changedFiles) || !Array.isArray(value.events)) {
+    return void 0;
+  }
+  const events = value.events.map((candidate) => {
+    const event = record(candidate);
+    if (!event || !stringValue(event.eventId) || !stringValue(event.eventCode)) {
+      return void 0;
+    }
+    return {
+      eventId: stringValue(event.eventId),
+      eventCode: stringValue(event.eventCode),
+      ...stringValue(event.file) ? { file: stringValue(event.file) } : {},
+      status: stringValue(event.status)
+    };
+  }).filter((event) => event !== void 0);
+  return {
+    changedFiles: value.changedFiles.filter((file) => typeof file === "string"),
+    identifyWired: value.identifyWired === true,
+    verificationStatus: stringValue(value.verificationStatus) || "pending",
+    ...stringValue(value.verificationCommand) ? { verificationCommand: stringValue(value.verificationCommand) } : {},
+    events
+  };
+}
 function record(value) {
   return typeof value === "object" && value !== null ? value : void 0;
 }
@@ -2049,7 +2092,7 @@ function stringValue(value) {
 }
 function isSnapshotEvent(value) {
   const event = record(value);
-  return !!event && typeof event.id === "string" && typeof event.code === "string" && typeof event.name === "string" && typeof event.reasoning === "string" && typeof event.projectId === "string" && !!record(event.payloadSchema);
+  return !!event && typeof event.id === "string" && typeof event.code === "string" && typeof event.name === "string" && typeof event.reasoning === "string" && typeof event.projectId === "string" && (event.anchorFile === void 0 || typeof event.anchorFile === "string") && (event.anchorSymbol === void 0 || typeof event.anchorSymbol === "string") && !!record(event.payloadSchema);
 }
 
 // src/engine/selection.ts
@@ -2193,9 +2236,14 @@ function validateProposedEvent(input, seen, rejected) {
   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()) {
+  const anchorFile = input.anchorFile.trim().replaceAll("\\", "/");
+  const anchorParts = anchorFile.split("/");
+  if (!input.name.trim() || !input.reasoning.trim() || !anchorFile) {
     return { ok: false, reason: "name, reasoning, and anchorFile are required" };
   }
+  if (anchorFile.startsWith("/") || /^[a-z]:/i.test(anchorFile) || anchorParts.some((part) => part === "" || part === "." || part === "..")) {
+    return { ok: false, reason: "anchorFile must be a safe repository-relative path" };
+  }
   const schema = {};
   for (const [field, description] of Object.entries(input.payloadSchema ?? {})) {
     const normalizedField = normalizeEventCode(field);
@@ -2216,7 +2264,7 @@ function validateProposedEvent(input, seen, rejected) {
       code,
       name: input.name.trim(),
       reasoning: input.reasoning.trim(),
-      anchorFile: input.anchorFile.trim(),
+      anchorFile,
       anchorSymbol: input.anchorSymbol?.trim() || void 0,
       payloadSchema: schema
     }
@@ -2239,7 +2287,7 @@ async function runSurvey(provider, models, repoPath, bootstrap, sink, resumeSess
   );
   return { report: outcome.kind === "completed" ? outcome.text : "", outcome };
 }
-async function runSelection(provider, models, repoPath, bootstrap, surveyReport, rejectedCodes, sink) {
+async function runSelection(provider, models, repoPath, bootstrap, surveyReport, rejectedCodes, sink, existingEventCodes = bootstrap.snapshot.events.map((event) => event.code)) {
   const proposed = [];
   const seen = /* @__PURE__ */ new Set();
   const rejected = new Set(rejectedCodes);
@@ -2318,7 +2366,7 @@ async function runSelection(provider, models, repoPath, bootstrap, surveyReport,
       userPrompt: selectionUserPrompt(
         surveyReport,
         renderOnboardingContext(bootstrap.onboardingContext),
-        bootstrap.snapshot.events.map((event) => event.code),
+        existingEventCodes,
         rejectedCodes
       ),
       tools: [proposeTool, finishTool],
@@ -2340,12 +2388,27 @@ async function runSelection(provider, models, repoPath, bootstrap, surveyReport,
 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 } : {}
-    });
+    let result;
+    try {
+      result = await runs.writeItem(runId, "event", {
+        code: event.code,
+        name: event.name,
+        reasoning: event.reasoning,
+        anchorFile: event.anchorFile,
+        ...event.anchorSymbol ? { anchorSymbol: event.anchorSymbol } : {},
+        ...Object.keys(event.payloadSchema).length > 0 ? { payloadSchema: event.payloadSchema } : {}
+      }, "placement-v2");
+    } catch (error) {
+      if (error instanceof RunsApiError && error.code === "wizard_project_conflict") {
+        sink.emit({
+          phase: "persisting",
+          file: event.anchorFile,
+          action: `skipped ${event.code} \u2014 already registered by another project`
+        });
+        continue;
+      }
+      throw error;
+    }
     registered.push({ ...event, eventId: result.id || result.item?.id || "" });
     sink.emit({ phase: "persisting", file: event.anchorFile, action: `registered ${event.code}` });
   }
@@ -2361,99 +2424,11 @@ function placementsFor(registered) {
   }));
 }
 
-// src/engine/state.ts
-import { createHash as createHash3 } from "crypto";
-import { mkdirSync, readFileSync as readFileSync2, renameSync, writeFileSync } from "fs";
-import { homedir, tmpdir } 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();
-  const preferred = override || join4(homedir(), ".whisperr", "wizard-runs");
-  if (canCreateStateDirectory(preferred)) {
-    return preferred;
-  }
-  const user = typeof process.getuid === "function" ? process.getuid() : "user";
-  const fallback = join4(tmpdir(), `whisperr-${user}`, "wizard-runs");
-  if (canCreateStateDirectory(fallback)) {
-    return fallback;
-  }
-  throw new Error("Whisperr Wizard could not create a directory for run state");
-}
-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 directory = stateDirectory();
-  const path = join4(directory, `${stateKey(state.apiBaseUrl, state.appId, state.repoFingerprint)}.json`);
-  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 canCreateStateDirectory(directory) {
-  try {
-    mkdirSync(directory, { recursive: true, mode: 448 });
-    return true;
-  } catch {
-    return false;
-  }
-}
-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 as tmpdir2 } from "os";
-import { join as join5 } from "path";
+import { cp, lstat, mkdir, mkdtemp, rm, writeFile as writeFile2 } from "fs/promises";
+import { tmpdir } from "os";
+import { dirname as dirname2, join as join4, relative, resolve, sep } from "path";
 var WorktreeError = class extends Error {
   constructor(code, message) {
     super(message);
@@ -2463,7 +2438,7 @@ var WorktreeError = class extends Error {
   code;
 };
 function git(cwd, args) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve6) => {
     const child = spawn2("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
@@ -2473,8 +2448,8 @@ function git(cwd, args) {
     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 }));
+    child.on("error", () => resolve6({ ok: false, stdout, stderr: "git is not available" }));
+    child.on("close", (exitCode) => resolve6({ ok: exitCode === 0, stdout, stderr }));
   });
 }
 async function must(cwd, args) {
@@ -2484,21 +2459,64 @@ async function must(cwd, args) {
   }
   return result.stdout;
 }
-async function createWorktree(repoPath, force = false) {
+function safeRepoFile(repoPath, file) {
+  const path = resolve(repoPath, file);
+  if (path === repoPath || !path.startsWith(repoPath + sep) || relative(repoPath, path).startsWith("..")) {
+    throw new WorktreeError("git_failed", `unsafe progress file path: ${file}`);
+  }
+  return path;
+}
+async function dirtyFiles(repoPath) {
+  const tracked = await must(repoPath, ["diff", "--name-only", "-z", "HEAD"]);
+  const untracked = await must(repoPath, ["ls-files", "--others", "--exclude-standard", "-z"]);
+  return [...new Set((tracked + untracked).split("\0").filter(Boolean))];
+}
+async function seedWorktree(repoPath, worktreePath, files) {
+  for (const file of files) {
+    const source = safeRepoFile(repoPath, file);
+    const destination = safeRepoFile(worktreePath, file);
+    try {
+      await lstat(source);
+      await mkdir(dirname2(destination), { recursive: true });
+      await cp(source, destination, { recursive: true, force: true });
+    } catch {
+      await rm(destination, { recursive: true, force: true });
+    }
+  }
+}
+async function createWorktree(repoPath, force = false, allowedDirtyFiles = []) {
   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) {
+  const dirty = await dirtyFiles(repoPath);
+  const allowed = new Set(allowedDirtyFiles);
+  const unexpected = dirty.filter((file) => !allowed.has(file));
+  if (unexpected.length > 0 && !force) {
     throw new WorktreeError(
       "dirty_repo",
-      "the repository has uncommitted changes \u2014 commit or stash them, or rerun with --force"
+      `the repository has unrelated uncommitted changes (${unexpected.slice(0, 3).join(", ")}) \u2014 commit or stash them, or rerun with --force`
     );
   }
-  const baseRef = (await must(repoPath, ["rev-parse", "HEAD"])).trim();
-  const path = await mkdtemp(join5(tmpdir2(), "whisperr-worktree-"));
+  let baseRef = (await must(repoPath, ["rev-parse", "HEAD"])).trim();
+  const path = await mkdtemp(join4(tmpdir(), "whisperr-worktree-"));
   await must(repoPath, ["worktree", "add", "--detach", "--force", path, "HEAD"]);
+  const seedFiles = force ? dirty : dirty.filter((file) => allowed.has(file));
+  if (seedFiles.length > 0) {
+    await seedWorktree(repoPath, path, seedFiles);
+    await must(path, ["add", "-A"]);
+    await must(path, [
+      "-c",
+      "user.name=Whisperr Wizard",
+      "-c",
+      "user.email=wizard@whisperr.net",
+      "commit",
+      "--no-gpg-sign",
+      "-m",
+      "Whisperr resume checkpoint"
+    ]);
+    baseRef = (await must(path, ["rev-parse", "HEAD"])).trim();
+  }
   return { path, baseRef, repoPath };
 }
 async function worktreePatch(handle) {
@@ -2509,7 +2527,7 @@ async function applyPatchToRepo(handle, patch) {
   if (patch.trim() === "") {
     return;
   }
-  await new Promise((resolve4, reject) => {
+  await new Promise((resolve6, reject) => {
     const child = spawn2("git", ["apply", "--whitespace=nowarn"], {
       cwd: handle.repoPath,
       stdio: ["pipe", "ignore", "pipe"]
@@ -2521,7 +2539,7 @@ async function applyPatchToRepo(handle, patch) {
     child.on("error", (error) => reject(new WorktreeError("git_failed", String(error))));
     child.on("close", (exitCode) => {
       if (exitCode === 0) {
-        resolve4();
+        resolve6();
       } else {
         reject(new WorktreeError("git_failed", `git apply failed: ${stderr.trim()}`));
       }
@@ -2529,13 +2547,27 @@ async function applyPatchToRepo(handle, patch) {
     child.stdin.end(patch);
   });
 }
-async function savePartialPatch(handle, destination) {
-  const patch = await worktreePatch(handle);
+async function commitWorktreeCheckpoint(handle) {
+  await must(handle.path, ["add", "-A"]);
+  const patch = await must(handle.path, ["diff", "--cached", "--binary", handle.baseRef]);
   if (patch.trim() === "") {
-    return void 0;
+    return;
   }
-  await writeFile2(destination, patch, { mode: 384 });
-  return destination;
+  await must(handle.path, [
+    "-c",
+    "user.name=Whisperr Wizard",
+    "-c",
+    "user.email=wizard@whisperr.net",
+    "commit",
+    "--no-gpg-sign",
+    "-m",
+    "Whisperr integration checkpoint"
+  ]);
+  handle.baseRef = (await must(handle.path, ["rev-parse", "HEAD"])).trim();
+}
+async function discardWorktreeChanges(handle) {
+  await must(handle.path, ["reset", "--hard", handle.baseRef]);
+  await must(handle.path, ["clean", "-fd"]);
 }
 async function removeWorktree(handle) {
   await git(handle.repoPath, ["worktree", "remove", "--force", handle.path]);
@@ -2560,7 +2592,7 @@ async function runEngine(input) {
     throw error;
   }
   const runId = bootstrap.run.id;
-  input.provider.onRunReady?.(runId);
+  input.provider.onRunReady?.(runId, bootstrap.run.modelConversationId);
   const patchPhase = async (phase, message) => {
     try {
       await runs.patchRun(runId, { phase, ...message ? { message } : {} });
@@ -2573,45 +2605,42 @@ async function runEngine(input) {
     } catch {
     }
   };
-  let state;
-  try {
-    state = loadRunState(input.config.apiBaseUrl, input.session.appId, input.repoFingerprint) ?? freshState(input, runId);
-    if (state.runId !== runId) {
-      state = freshState(input, runId);
-    }
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    await failRun(`state initialization failed: ${reason}`);
-    return { kind: "aborted", reason: `state initialization failed: ${reason}` };
-  }
-  const persist = () => saveRunState(state);
   let registered;
-  if (!state.designComplete) {
-    try {
+  try {
+    const projectEvents = bootstrap.snapshot.events.filter(
+      (event) => event.projectId === bootstrap.project.id
+    );
+    const placed = registeredFromSnapshot(projectEvents);
+    const missingPlacement = projectEvents.filter((event) => !event.anchorFile);
+    if (placed.length === 0 || missingPlacement.length > 0) {
+      input.sink.emit({
+        phase: "surveying",
+        action: projectEvents.length === 0 ? "no saved progress found; starting a fresh survey" : "saved events need placement recovery; verifying the repository"
+      });
       await patchPhase("surveying");
       const survey = await runSurvey(
         input.provider,
         input.models,
         input.repoPath,
         bootstrap,
-        input.sink,
-        state.providerSessions.survey
+        input.sink
       );
       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 recoverableCodes = new Set(missingPlacement.map((event) => event.code));
+      const existingCodes = bootstrap.snapshot.events.filter((event) => !recoverableCodes.has(event.code)).map((event) => event.code);
       const selection = await runSelection(
         input.provider,
         input.models,
         input.repoPath,
         bootstrap,
         survey.report,
-        state.tombstonedCodes,
-        input.sink
+        [],
+        input.sink,
+        existingCodes
       );
       if (!selection.finished) {
         const reason = selection.outcome === "completed" ? "selection did not call finish_selection" : `selection ${selection.outcome}`;
@@ -2631,44 +2660,114 @@ async function runEngine(input) {
         await failRun("no events accepted for instrumentation");
         return { kind: "aborted", reason: "no events accepted for instrumentation" };
       }
-      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`);
-      registered = await registerApprovedEvents(runs, runId, approved, input.sink);
-      state.designComplete = true;
-      state.clusters = deriveClusters(placementsFor(registered));
-      persist();
-    } catch (error) {
-      const reason = error instanceof Error ? error.message : String(error);
-      await failRun(`design failed: ${reason}`);
-      return { kind: "aborted", reason: `design failed: ${reason}` };
+      const newlyRegistered = await registerApprovedEvents(runs, runId, approved, input.sink);
+      registered = mergeRegistered(placed, newlyRegistered);
+      const unresolved = projectEvents.filter((event) => !registered.some((candidate) => candidate.code === event.code)).map((event) => event.code);
+      if (unresolved.length > 0) {
+        throw new Error(`could not recover placements for: ${unresolved.join(", ")}`);
+      }
+    } else {
+      registered = placed;
+      input.sink.emit({
+        phase: "integrating",
+        action: `found ${registered.length} saved events; verifying current files`
+      });
     }
-  } else {
-    registered = rebuildRegistered(state, bootstrap);
-    input.sink.emit({ phase: "designing", action: `resumed with ${registered.length} registered events` });
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    await failRun(`design failed: ${reason}`);
+    return { kind: "aborted", reason: `design failed: ${reason}` };
   }
   if (registered.length === 0) {
     await failRun("no events registered for this project");
     return { kind: "aborted", reason: "no events registered for this project" };
   }
+  const prior = bootstrap.run.integrationEvidence;
+  const changedFiles2 = new Set(prior?.changedFiles ?? []);
+  const eventStatuses = await reconcileProgress(input.repoPath, registered, prior, input.sink);
+  for (const event of registered) {
+    const status = eventStatuses.get(event.code) ?? "planned";
+    if (status !== "planned" && status !== "failed" && status !== "unsupported") {
+      changedFiles2.add(event.anchorFile);
+    }
+  }
+  let identifyWired = prior?.identifyWired === true && await setupLooksPresent(input.repoPath, changedFiles2);
+  const progress = () => ({
+    changedFiles: [...changedFiles2].sort(),
+    identifyWired,
+    verificationStatus: "pending",
+    events: buildEvidence(registered, eventStatuses)
+  });
+  const saveProgress = async () => {
+    await runs.saveProgress(runId, progress());
+  };
+  try {
+    await saveProgress();
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    await failRun(`progress initialization failed: ${reason}`);
+    return { kind: "aborted", reason: `progress initialization failed: ${reason}` };
+  }
   await patchPhase("binding");
   let worktree;
   try {
-    worktree = await createWorktree(input.repoPath, input.force ?? false);
+    worktree = await createWorktree(
+      input.repoPath,
+      input.force ?? false,
+      [...changedFiles2]
+    );
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
     await failRun(reason);
     return { kind: "aborted", reason };
   }
-  state.worktreePath = worktree.path;
-  persist();
+  const checkpoint = async () => {
+    const patch = await worktreePatch(worktree);
+    if (patch.trim() === "") {
+      return [];
+    }
+    const files = patchFiles(patch);
+    for (const file of files) {
+      changedFiles2.add(file);
+    }
+    await saveProgress();
+    await applyPatchToRepo(worktree, patch);
+    await commitWorktreeCheckpoint(worktree);
+    return files;
+  };
   try {
     const bindings = await writeBindingsModule(worktree, input.target, registered);
+    if (!identifyWired) {
+      const setupCompleted = await runSdkSetupPass({
+        provider: input.provider,
+        models: input.models,
+        worktree,
+        target: input.target,
+        playbookSystemPrompt: input.playbookSystemPrompt,
+        registered,
+        ingestion: bootstrap.ingestion,
+        sink: input.sink,
+        saveClusters: () => {
+        },
+        discardChanges: async () => discardWorktreeChanges(worktree),
+        onClusterIntegrated: async () => {
+        }
+      }, bindings);
+      if (!setupCompleted) {
+        throw new Error("SDK setup did not complete");
+      }
+      await checkpoint();
+      identifyWired = true;
+      await saveProgress();
+    } else {
+      await checkpoint();
+    }
+    const pending = registered.filter((event) => {
+      const status = eventStatuses.get(event.code) ?? "planned";
+      return status === "planned" || status === "failed";
+    });
+    const clusters = deriveClusters(placementsFor(pending));
     const deps = {
       provider: input.provider,
       models: input.models,
@@ -2678,140 +2777,179 @@ async function runEngine(input) {
       registered,
       ingestion: bootstrap.ingestion,
       sink: input.sink,
-      saveClusters: (clusters) => {
-        state.clusters = clusters;
-        persist();
+      saveClusters: () => {
+      },
+      discardChanges: async () => discardWorktreeChanges(worktree),
+      onClusterIntegrated: async (cluster, status) => {
+        const verified = /* @__PURE__ */ new Map();
+        for (const placement of cluster.events) {
+          const present = await fileContainsWrapper(
+            worktree.path,
+            placement.file,
+            placement.eventCode
+          );
+          verified.set(placement.eventCode, present ? status : "failed");
+        }
+        await checkpoint();
+        for (const placement of cluster.events) {
+          eventStatuses.set(
+            placement.eventCode,
+            verified.get(placement.eventCode) ?? "failed"
+          );
+          await saveProgress();
+          input.sink.emit({
+            phase: "integrating",
+            file: placement.file,
+            action: `saved ${placement.eventCode} progress`
+          });
+        }
       }
     };
-    const identifyWired = await runSdkSetupPass(deps, bindings);
     await patchPhase("integrating");
     const integration = await runClusterIntegration(
       deps,
-      state.clusters,
+      clusters,
       async () => worktreePatch(worktree)
     );
-    state.clusters = integration.clusters;
-    persist();
+    for (const [code, status] of integration.eventStatuses) {
+      if ((eventStatuses.get(code) ?? "planned") === "planned") {
+        eventStatuses.set(code, status);
+      }
+    }
+    await saveProgress();
+    const unfinished = registered.filter((event) => {
+      const status = eventStatuses.get(event.code) ?? "planned";
+      return status === "planned" || status === "failed";
+    });
+    if (unfinished.length > 0) {
+      throw new Error(
+        `${unfinished.length} event${unfinished.length === 1 ? "" : "s"} still need integration`
+      );
+    }
+    await patchPhase("verifying");
     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,
+    await runs.completeRun(runId, {
+      changedFiles: [...changedFiles2].sort(),
       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"
-    );
+      verificationStatus: finalVerify.status,
+      ...finalVerify.command ? { verificationCommand: finalVerify.command } : {},
+      events: buildEvidence(registered, eventStatuses)
+    });
+    await removeWorktree(worktree).catch(() => {
+    });
+    const summaryLines = summarize(registered, eventStatuses);
+    const hasFailures = [...eventStatuses.values()].some((status) => status === "failed");
     return {
       kind: hasFailures ? "partial" : "completed",
       runId,
       registered,
-      eventStatuses: integration.eventStatuses,
-      reportEvents: buildReportEvents(registered, integration.eventStatuses),
-      changedFiles: changedFiles2,
+      eventStatuses,
+      reportEvents: buildReportEvents(registered, eventStatuses),
+      changedFiles: [...changedFiles2].sort(),
       identifyWired,
-      applied,
-      partialPatchPath: partialPatchPath ?? void 0,
+      applied: changedFiles2.size > 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();
+    await removeWorktree(worktree).catch(() => {
+    });
     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.`
+      eventStatuses,
+      reportEvents: buildReportEvents(registered, eventStatuses),
+      changedFiles: [...changedFiles2].sort(),
+      identifyWired,
+      applied: changedFiles2.size > 0,
+      summary: `Integration stopped early: ${reason}. Saved event progress will be verified on rerun.`
     };
   }
 }
-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 registeredFromSnapshot(events) {
+  return events.filter((event) => Boolean(event.anchorFile)).map((event) => ({
+    code: event.code,
+    name: event.name,
+    reasoning: event.reasoning,
+    eventId: event.id,
+    anchorFile: event.anchorFile.replaceAll("\\", "/"),
+    ...event.anchorSymbol ? { anchorSymbol: event.anchorSymbol } : {},
+    payloadSchema: event.payloadSchema ?? {}
+  }));
 }
-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 ?? {}
+function mergeRegistered(existing, added) {
+  const merged = new Map(existing.map((event) => [event.code, event]));
+  for (const event of added) {
+    merged.set(event.code, event);
+  }
+  return [...merged.values()].sort((a, b) => a.code.localeCompare(b.code));
+}
+async function reconcileProgress(repoPath, registered, prior, sink) {
+  const priorById = new Map((prior?.events ?? []).map((event) => [event.eventId, event]));
+  const statuses = /* @__PURE__ */ new Map();
+  for (const event of registered) {
+    const saved = priorById.get(event.eventId);
+    if (saved?.status === "unsupported") {
+      statuses.set(event.code, "unsupported");
+      continue;
+    }
+    const present = await fileContainsWrapper(repoPath, event.anchorFile, event.code);
+    const savedIntegrated = saved && saved.status !== "planned" && saved.status !== "failed";
+    const status = present ? savedIntegrated ? saved.status : "applied" : "planned";
+    statuses.set(event.code, status);
+    if (saved && saved.status !== status) {
+      sink.emit({
+        phase: "verifying",
+        file: event.anchorFile,
+        action: present ? `recovered ${event.code} from the current code` : `${event.code} is missing and will be integrated again`
       });
     }
   }
-  return registered;
+  return statuses;
 }
-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 fileContainsWrapper(repoPath, file, eventCode) {
+  try {
+    const path = safeRepoPath(repoPath, file);
+    const content = await readFile2(path, "utf8");
+    return content.includes(eventWrapperName(eventCode));
+  } catch {
+    return false;
+  }
 }
-async function completeRun(runs, runId, evidence, _statuses, changedFiles2, identifyWired, verificationStatus, verificationCommand2) {
-  await runs.completeRun(runId, {
-    changedFiles: changedFiles2,
-    identifyWired,
-    verificationStatus,
-    ...verificationCommand2 ? { verificationCommand: verificationCommand2 } : {},
-    events: evidence
-  });
+async function setupLooksPresent(repoPath, changedFiles2) {
+  let bindingsFound = false;
+  let bindingCallFound = false;
+  for (const file of changedFiles2) {
+    try {
+      const content = await readFile2(safeRepoPath(repoPath, file), "utf8");
+      const generated = content.includes("Generated by @whisperr/wizard");
+      bindingsFound ||= generated;
+      if (!generated) {
+        bindingCallFound ||= content.includes("bindWhisperr(") || content.includes("WhisperrEvents.bind(");
+      }
+    } catch {
+    }
+  }
+  return bindingsFound && bindingCallFound;
+}
+function safeRepoPath(repoPath, file) {
+  const root = resolve2(repoPath);
+  const path = resolve2(root, file);
+  if (path === root || !path.startsWith(root + sep2)) {
+    throw new Error(`unsafe progress file path: ${file}`);
+  }
+  return path;
+}
+function buildEvidence(registered, statuses) {
+  return registered.map((event) => ({
+    eventId: event.eventId,
+    eventCode: event.code,
+    file: event.anchorFile,
+    status: statuses.get(event.code) ?? "planned"
+  }));
 }
 function buildReportEvents(registered, statuses) {
   return registered.map((event) => {
@@ -2852,9 +2990,9 @@ import {
 
 // src/core/git.ts
 import { spawn as spawn3 } from "child_process";
-import { createHash as createHash4 } from "crypto";
-import { readFile as readFile2 } from "fs/promises";
-import { basename as basename2, join as join7 } from "path";
+import { createHash as createHash3 } from "crypto";
+import { readFile as readFile3 } from "fs/promises";
+import { basename as basename2, join as join5 } from "path";
 async function takeCheckpoint(repoPath) {
   const isRepo = (await run(repoPath, ["rev-parse", "--is-inside-work-tree"])).ok;
   if (!isRepo) return { isRepo: false };
@@ -2903,7 +3041,7 @@ async function revertToCheckpoint(repoPath, checkpoint) {
 async function repoFingerprint(repoPath) {
   const remote = await run(repoPath, ["remote", "get-url", "origin"]);
   const seed = remote.ok && remote.stdout.trim() ? normalizeRemote(remote.stdout.trim()) : `dir:${basename2(repoPath)}`;
-  return createHash4("sha256").update(seed).digest("hex").slice(0, 16);
+  return createHash3("sha256").update(seed).digest("hex").slice(0, 16);
 }
 function normalizeRemote(url) {
   return url.replace(/^git@([^:]+):/, "$1/").replace(/^https?:\/\//, "").replace(/\.git$/, "").replace(/\/+$/, "").toLowerCase();
@@ -2920,7 +3058,7 @@ async function scanWiredEvents(repoPath, files, eventTypes) {
   const contents = [];
   for (const file of files) {
     try {
-      contents.push({ file, content: await readFile2(join7(repoPath, file), "utf8") });
+      contents.push({ file, content: await readFile3(join5(repoPath, file), "utf8") });
     } catch {
       continue;
     }
@@ -2950,14 +3088,14 @@ function escapeRegExp(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function run(cwd, args) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve6) => {
     const child = spawn3("git", args, { cwd });
     let stdout = "";
     let stderr = "";
     child.stdout.on("data", (d) => stdout += d.toString());
     child.stderr.on("data", (d) => stderr += d.toString());
-    child.on("close", (code) => resolve4({ ok: code === 0, stdout, stderr }));
-    child.on("error", () => resolve4({ ok: false, stdout, stderr }));
+    child.on("close", (code) => resolve6({ ok: code === 0, stdout, stderr }));
+    child.on("error", () => resolve6({ ok: false, stdout, stderr }));
   });
 }
 
@@ -3196,7 +3334,7 @@ function coverageNote(coverage) {
 }
 
 // src/core/toolPolicy.ts
-import { isAbsolute, relative, resolve } from "path";
+import { isAbsolute, relative as relative2, resolve as resolve3 } from "path";
 var SECRET_MATERIAL_DENIAL = "blocked: secret material must not be accessed";
 var WRITE_OUTSIDE_REPO_DENIAL = "blocked: writes must stay inside the target repository";
 var SENSITIVE_WRITE_DENIAL = "blocked: refusing to write CI/git configuration";
@@ -3292,9 +3430,9 @@ function isSecretPathLike(value) {
 }
 function isPathInsideRepo(pathValue, repoPath) {
   if (pathValue.includes("..")) return false;
-  const repoRoot = resolve(repoPath);
-  const candidate = isAbsolute(pathValue) ? resolve(pathValue) : resolve(repoRoot, pathValue);
-  const rel = relative(repoRoot, candidate);
+  const repoRoot = resolve3(repoPath);
+  const candidate = isAbsolute(pathValue) ? resolve3(pathValue) : resolve3(repoRoot, pathValue);
+  const rel = relative2(repoRoot, candidate);
   return rel === "" || !!rel && !rel.startsWith("..") && !isAbsolute(rel);
 }
 function evaluateReadLike(secretValues, repoPathValues, context) {
@@ -3417,9 +3555,9 @@ function normalizePathLike(value) {
   return stripOuterQuotes(value.trim()).replace(/\\/g, "/");
 }
 function repoRelativePath(pathValue, repoPath) {
-  const repoRoot = resolve(repoPath);
-  const candidate = isAbsolute(pathValue) ? resolve(pathValue) : resolve(repoRoot, pathValue);
-  return normalizePathLike(relative(repoRoot, candidate));
+  const repoRoot = resolve3(repoPath);
+  const candidate = isAbsolute(pathValue) ? resolve3(pathValue) : resolve3(repoRoot, pathValue);
+  return normalizePathLike(relative2(repoRoot, candidate));
 }
 function isSensitiveWritePath(pathValue, repoPath) {
   const parts = repoRelativePath(pathValue, repoPath).split("/").map((part) => stripOuterQuotes(part.trim().toLowerCase())).filter(Boolean);
@@ -4473,11 +4611,11 @@ function createClaudeProvider(config, session) {
 }
 
 // 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";
+import { readdirSync, readFileSync as readFileSync2, statSync, writeFileSync } from "fs";
+import { join as join6, resolve as resolve4, sep as sep3 } from "path";
 function jailedPath(cwd, candidate) {
-  const resolved = resolve2(cwd, candidate);
-  if (resolved !== cwd && !resolved.startsWith(cwd + sep)) {
+  const resolved = resolve4(cwd, candidate);
+  if (resolved !== cwd && !resolved.startsWith(cwd + sep3)) {
     throw new Error(`path ${candidate} escapes the repository`);
   }
   return resolved;
@@ -4507,7 +4645,7 @@ function fileTools(cwd, allowWrite) {
       },
       handler: async (input) => {
         const path = guardedPath(cwd, "Read", String(input.path ?? ""));
-        const content = readFileSync3(path, "utf8");
+        const content = readFileSync2(path, "utf8");
         return { content: content.slice(0, 4e4) };
       }
     },
@@ -4523,7 +4661,7 @@ function fileTools(cwd, allowWrite) {
       handler: async (input) => {
         const target9 = guardedPath(cwd, "Glob", String(input.path ?? "."));
         const entries = readdirSync(target9).filter((entry) => !isSecretPathLike(entry)).map((entry) => {
-          const kind = statSync(join8(target9, entry)).isDirectory() ? "dir" : "file";
+          const kind = statSync(join6(target9, entry)).isDirectory() ? "dir" : "file";
           return `${kind}:${entry}`;
         });
         return { entries: entries.slice(0, 500) };
@@ -4543,7 +4681,7 @@ function fileTools(cwd, allowWrite) {
         },
         handler: async (input) => {
           const path = guardedPath(cwd, "Write", String(input.path ?? ""));
-          writeFileSync2(path, String(input.content ?? ""));
+          writeFileSync(path, String(input.content ?? ""));
           return { ok: true };
         }
       },
@@ -4562,12 +4700,12 @@ function fileTools(cwd, allowWrite) {
         },
         handler: async (input) => {
           const path = guardedPath(cwd, "Edit", String(input.path ?? ""));
-          const content = readFileSync3(path, "utf8");
+          const content = readFileSync2(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 ?? "")));
+          writeFileSync(path, content.replace(oldText, String(input.newText ?? "")));
           return { ok: true };
         }
       }
@@ -4631,8 +4769,9 @@ function createOpenAIProvider(config, session) {
   };
   return {
     name: "openai-gateway",
-    onRunReady(readyRunId) {
+    onRunReady(readyRunId, resumeSessionId) {
       runId = readyRunId;
+      conversationId = resumeSessionId;
     },
     async invoke(invocation, roleConfig, onProgress) {
       let costUsd = 0;
@@ -4714,9 +4853,9 @@ function createRoutedProvider(routes, fallback) {
   const providers = /* @__PURE__ */ new Set([fallback, ...Object.values(routes)]);
   return {
     name: "routed",
-    onRunReady(runId) {
+    onRunReady(runId, resumeSessionId) {
       for (const provider of providers) {
-        provider.onRunReady?.(runId);
+        provider.onRunReady?.(runId, resumeSessionId);
       }
     },
     invoke(invocation, config, onProgress) {
@@ -4768,16 +4907,7 @@ async function tryEngineFlow(options) {
     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;
-      }
+      reviewEvents: async (proposed) => reviewEventsInTerminal(proposed, theme2)
     }
   });
   if (result.kind === "wrong_mode") {
@@ -4827,7 +4957,7 @@ async function reviewEventsInTerminal(proposed, theme2) {
   });
   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.",
+    message: "Register and integrate these events? Deselect any you don't want.",
     options: proposed.map((event) => ({ value: event.code, label: event.code, hint: event.name })),
     initialValues: proposed.map((event) => event.code),
     required: false
@@ -5070,7 +5200,7 @@ function runVerifyCommand(repoPath, command, opts = {}) {
     return Promise.resolve({ ran: false, ok: true, output: "" });
   }
   const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  return new Promise((resolve4) => {
+  return new Promise((resolve6) => {
     const child = spawn4(command, { cwd: repoPath, shell: true, env: process.env });
     let out = "";
     const append = (d) => {
@@ -5081,11 +5211,11 @@ function runVerifyCommand(repoPath, command, opts = {}) {
     child.stderr?.on("data", append);
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
-      resolve4({ ran: true, ok: false, command, output: tail2(out), timedOut: true });
+      resolve6({ ran: true, ok: false, command, output: tail2(out), timedOut: true });
     }, timeoutMs);
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve4({
+      resolve6({
         ran: true,
         ok: code === 0,
         command,
@@ -5097,7 +5227,7 @@ function runVerifyCommand(repoPath, command, opts = {}) {
     });
     child.on("error", () => {
       clearTimeout(timer);
-      resolve4({ ran: true, ok: false, command, output: tail2(out), toolMissing: true });
+      resolve6({ ran: true, ok: false, command, output: tail2(out), toolMissing: true });
     });
   });
 }
@@ -5107,21 +5237,21 @@ function tail2(s) {
 }
 
 // src/core/version.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { dirname as dirname3, join as join9, parse } from "path";
+import { readFileSync as readFileSync3 } from "fs";
+import { dirname as dirname4, join as join7, parse } from "path";
 import { fileURLToPath } from "url";
 var PACKAGE_NAME = "@whisperr/wizard";
 function packageVersion() {
-  let dir = dirname3(fileURLToPath(import.meta.url));
+  let dir = dirname4(fileURLToPath(import.meta.url));
   const { root } = parse(dir);
   while (true) {
     try {
-      const pkg = JSON.parse(readFileSync4(join9(dir, "package.json"), "utf8"));
+      const pkg = JSON.parse(readFileSync3(join7(dir, "package.json"), "utf8"));
       if (pkg.name === PACKAGE_NAME && pkg.version) return pkg.version;
     } catch {
     }
     if (dir === root) return "0.0.0";
-    dir = dirname3(dir);
+    dir = dirname4(dir);
   }
 }
 
@@ -5254,7 +5384,7 @@ function banner() {
 
 // src/cli.ts
 async function run2(options) {
-  const repoPath = resolve3(options.path ?? process.cwd());
+  const repoPath = resolve5(options.path ?? process.cwd());
   const config = resolveConfig(options);
   console.log(banner());
   p2.intro(theme.signal("Let's wire Whisperr into your app."));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whisperr/wizard",
-  "version": "0.7.3",
+  "version": "0.7.4",
   "description": "Whisperr Wizard \u2014 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",