@whisperr/wizard 0.7.2 → 0.7.4

package/dist/index.js

@@ -5,13 +5,13 @@ 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";
 
 // src/core/config.ts
 var DEFAULT_API_BASE = "https://api.whisperr.net";
-var DEFAULT_MODEL = "claude-sonnet-5";
+var DEFAULT_MODEL = "claude-opus-5";
 var DEFAULT_PLANNER_MODEL = "claude-opus-5";
 var DEFAULT_EFFORT = "high";
 var EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
@@ -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
@@ -2063,11 +2106,14 @@ var SURVEY_SYSTEM_PROMPT = [
   "",
   "Report, in plain markdown:",
   "1. Stack: frameworks, package manager, app entry point file.",
-  "2. Feature areas: name, root directory, and the 1-3 files where committed user actions happen.",
+  "2. Feature areas: name, root directory, and every relevant file containing",
+  "   committed end-user actions or meaningful lifecycle transitions.",
   "3. The end-user identify() anchor: the login/signup success and session-restore call sites for the",
   "   PAYING end user \u2014 never admin, staff, operator, or seller paths.",
   "4. Existing analytics calls, if any.",
-  "5. Committed-action call sites worth instrumenting: file, function/symbol, and what the user just did.",
+  "5. Exhaustive inventory of integratable call sites: file, function/symbol,",
+  "   confirmed outcome or state transition, available non-PII payload fields,",
+  "   and whether similar paths exist elsewhere.",
   "Cite concrete file paths for every claim. Do not propose event names yet."
 ].join("\n");
 function surveyUserPrompt(repoPath, onboardingContext) {
@@ -2090,9 +2136,20 @@ var SELECTION_SYSTEM_PROMPT = [
   "  streak_broken) \u2014 the server derives those later.",
   "- Emit after confirmed outcomes, not intent: a purchase event fires on confirmed success, not on",
   "  button tap; denied permissions are not grants.",
-  "- Importance is anchored in the business context: the activation moment, churn-risk and healthy",
-  "  signals, and how the product charges. A handful of load-bearing events beats wide coverage.",
-  "- An empty or small set is a valid outcome. There is no quota. Never invent events to look thorough.",
+  "- Aim for comprehensive coverage of the product\u2019s observable end-user lifecycle.",
+  "  Inspect every meaningful feature area and propose every distinct, concretely",
+  "  integratable event that could contribute to activation, engagement, retention,",
+  "  monetization, or churn analysis.",
+  "- Prefer complete coverage over a short curated list. Include distinct successful",
+  "  outcomes, failures, cancellations, retries, state transitions, and meaningful",
+  "  feature usage when each has its own concrete call site and analytical value.",
+  "- Let the product\u2019s actual complexity determine the count. A feature-rich product",
+  "  may legitimately produce roughly 100\u2013200 events, while a smaller product may",
+  "  produce fewer. Do not stop after finding only the most obvious events, and do",
+  "  not invent events merely to reach a number.",
+  "- Before finishing, systematically revisit every surveyed feature area and confirm",
+  "  that all meaningful committed actions and lifecycle transitions have either",
+  "  been proposed or deliberately excluded with a reason.",
   "- Codes are lowercase snake_case, named for what happened (checkout_completed, not do_checkout).",
   "- payloadSchema lists the fields worth capturing with a short description of each \u2014 the important",
   "  info only. NEVER include personal identifiers: no email, phone, names, addresses, birth dates,",
@@ -2179,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);
@@ -2202,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
     }
@@ -2225,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);
@@ -2304,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],
@@ -2326,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}` });
   }
@@ -2347,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);
@@ -2449,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 = "";
@@ -2459,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) {
@@ -2470,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) {
@@ -2495,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"]
@@ -2507,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()}`));
       }
@@ -2515,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]);
@@ -2546,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 } : {} });
@@ -2559,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}`;
@@ -2617,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,
@@ -2664,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) => {
@@ -2838,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 };
@@ -2889,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();
@@ -2906,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;
     }
@@ -2936,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 }));
   });
 }
 
@@ -3182,8 +3334,8 @@ function coverageNote(coverage) {
 }
 
 // src/core/toolPolicy.ts
-import { isAbsolute, relative, resolve } from "path";
-var SECRET_MATERIAL_DENIAL = "blocked: secret material - reference the variable name in .env.example instead of reading the real file";
+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";
 var BASH_ALLOWLIST_DENIAL = "blocked: command is outside the Bash allowlist - use package install/add commands, mkdir, or git status/diff/log only";
@@ -3194,9 +3346,24 @@ function engineMcpToolName(toolName) {
 function trustedEngineMcpTools(tools) {
   return new Set(tools.map((tool2) => engineMcpToolName(tool2.name)));
 }
-var ENV_EXAMPLES = /* @__PURE__ */ new Set([".env.example", ".env.sample", ".env.template"]);
-var SECRET_DIRECTORIES = /* @__PURE__ */ new Set([".aws", ".ssh", ".gnupg"]);
-var SECRET_EXACT_FILES = /* @__PURE__ */ new Set([".netrc", ".npmrc", ".pypirc"]);
+var SECRET_DIRECTORIES = /* @__PURE__ */ new Set([
+  ".aws",
+  ".ssh",
+  ".gnupg",
+  ".azure",
+  ".docker",
+  ".kube",
+  ".secrets",
+  "secrets"
+]);
+var SECRET_EXACT_FILES = /* @__PURE__ */ new Set([
+  ".netrc",
+  ".npmrc",
+  ".pypirc",
+  "auth.json",
+  "google-services.json",
+  "googleservice-info.plist"
+]);
 var SENSITIVE_WRITE_DIRECTORIES = /* @__PURE__ */ new Set([".git", ".circleci", ".buildkite"]);
 var SENSITIVE_WRITE_EXACT_FILES = /* @__PURE__ */ new Set([
   ".gitlab-ci.yml",
@@ -3212,6 +3379,7 @@ var SECRET_SUFFIXES = [
   ".pfx",
   ".jks",
   ".keystore",
+  ".kdbx",
   ".tfvars"
 ];
 var JS_PACKAGE_MANAGERS = /* @__PURE__ */ new Set(["npm", "pnpm", "yarn", "bun"]);
@@ -3245,7 +3413,6 @@ function isSecretPathLike(value) {
   for (const rawPart of parts) {
     const part = stripOuterQuotes(rawPart.trim().toLowerCase());
     if (!part || part === "." || part === "**") continue;
-    if (ENV_EXAMPLES.has(part)) continue;
     if (SECRET_DIRECTORIES.has(part)) return true;
     if (SECRET_EXACT_FILES.has(part)) return true;
     if (part === ".env" || part === ".envrc" || part.startsWith(".env.") || part.startsWith(".env*")) {
@@ -3256,15 +3423,16 @@ function isSecretPathLike(value) {
     }
     if (part.includes("credentials")) return true;
     if (part.startsWith("secrets.")) return true;
+    if (part.startsWith("service-account") && part.endsWith(".json")) return true;
     if (SECRET_SUFFIXES.some((suffix) => part.endsWith(suffix))) return true;
   }
   return false;
 }
 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) {
@@ -3291,6 +3459,9 @@ function evaluateWrite(input, context) {
   if (!isPathInsideRepo(pathValue, context.repoPath)) {
     return { behavior: "deny", message: WRITE_OUTSIDE_REPO_DENIAL };
   }
+  if (isSecretPathLike(pathValue)) {
+    return { behavior: "deny", message: SECRET_MATERIAL_DENIAL };
+  }
   if (isSensitiveWritePath(pathValue, context.repoPath)) {
     return { behavior: "deny", message: SENSITIVE_WRITE_DENIAL };
   }
@@ -3384,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);
@@ -4349,6 +4520,10 @@ function short(s, max = 60) {
 // src/engine/providers/claude.ts
 var READ_ONLY_TOOLS2 = ["Read", "Glob", "Grep"];
 var EDIT_TOOLS = ["Read", "Edit", "Write", "Bash", "Glob", "Grep"];
+var FAST_MODE_MODELS = /* @__PURE__ */ new Set(["claude-opus-5", "claude-opus-4-8"]);
+function supportsClaudeFastMode(model) {
+  return FAST_MODE_MODELS.has(model);
+}
 function createClaudeProvider(config, session) {
   return {
     name: "claude",
@@ -4384,6 +4559,7 @@ function createClaudeProvider(config, session) {
             hooks: buildToolPolicyHooks(invocation.cwd, trustedTools),
             canUseTool: createToolPermissionCallback(invocation.cwd, trustedTools),
             maxTurns: roleConfig.maxTurns,
+            ...supportsClaudeFastMode(roleConfig.model) ? { settings: { fastMode: true } } : {},
             ...invocation.resumeSessionId ? { resume: invocation.resumeSessionId } : {},
             settingSources: []
           }
@@ -4435,15 +4611,27 @@ 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;
 }
+function guardedPath(cwd, toolName, candidate) {
+  const path = jailedPath(cwd, candidate);
+  const decision = evaluateToolUse(
+    toolName,
+    toolName === "Glob" ? { path: candidate, pattern: "*" } : { file_path: candidate },
+    { repoPath: cwd }
+  );
+  if (decision.behavior === "deny") {
+    throw new Error(decision.message);
+  }
+  return path;
+}
 function fileTools(cwd, allowWrite) {
   const tools = [
     {
@@ -4456,7 +4644,8 @@ function fileTools(cwd, allowWrite) {
         required: ["path"]
       },
       handler: async (input) => {
-        const content = readFileSync3(jailedPath(cwd, String(input.path ?? "")), "utf8");
+        const path = guardedPath(cwd, "Read", String(input.path ?? ""));
+        const content = readFileSync2(path, "utf8");
         return { content: content.slice(0, 4e4) };
       }
     },
@@ -4470,9 +4659,9 @@ function fileTools(cwd, allowWrite) {
         required: ["path"]
       },
       handler: async (input) => {
-        const target9 = jailedPath(cwd, String(input.path ?? "."));
-        const entries = readdirSync(target9).map((entry) => {
-          const kind = statSync(join8(target9, entry)).isDirectory() ? "dir" : "file";
+        const target9 = guardedPath(cwd, "Glob", String(input.path ?? "."));
+        const entries = readdirSync(target9).filter((entry) => !isSecretPathLike(entry)).map((entry) => {
+          const kind = statSync(join6(target9, entry)).isDirectory() ? "dir" : "file";
           return `${kind}:${entry}`;
         });
         return { entries: entries.slice(0, 500) };
@@ -4491,7 +4680,8 @@ function fileTools(cwd, allowWrite) {
           required: ["path", "content"]
         },
         handler: async (input) => {
-          writeFileSync2(jailedPath(cwd, String(input.path ?? "")), String(input.content ?? ""));
+          const path = guardedPath(cwd, "Write", String(input.path ?? ""));
+          writeFileSync(path, String(input.content ?? ""));
           return { ok: true };
         }
       },
@@ -4509,13 +4699,13 @@ function fileTools(cwd, allowWrite) {
           required: ["path", "oldText", "newText"]
         },
         handler: async (input) => {
-          const path = jailedPath(cwd, String(input.path ?? ""));
-          const content = readFileSync3(path, "utf8");
+          const path = guardedPath(cwd, "Edit", String(input.path ?? ""));
+          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 };
         }
       }
@@ -4579,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;
@@ -4662,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) {
@@ -4679,7 +4870,7 @@ var MINUTE = 6e4;
 function engineModelConfig(config) {
   const model = (role, fallback) => process.env[`WHISPERR_WIZARD_ENGINE_${role.toUpperCase()}_MODEL`]?.trim() || fallback;
   return {
-    survey: { model: model("survey", "claude-sonnet-5"), effort: "medium", maxTurns: 40, maxMs: 12 * MINUTE },
+    survey: { model: model("survey", config.model), effort: "medium", maxTurns: 40, maxMs: 12 * MINUTE },
     design: { model: model("design", config.plannerModel), effort: "high", maxTurns: 40, maxMs: 15 * MINUTE },
     edit: { model: model("edit", config.model), effort: config.effort, maxTurns: 50, maxMs: 15 * MINUTE },
     review: { model: model("review", config.model), effort: "medium", maxTurns: 15, maxMs: 8 * MINUTE }
@@ -4716,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") {
@@ -4775,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
@@ -5018,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) => {
@@ -5029,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,
@@ -5045,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 });
     });
   });
 }
@@ -5055,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);
   }
 }
 
@@ -5202,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."));