ccqa 1.2.0 → 1.3.0

package/dist/bin/ccqa.mjs

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
-import { n as spawnAB, t as sleepSync } from "../spawn-ab-Cr967J2N.mjs";
+import { a as formatAgentBrowserUnavailableMessage, i as assertAgentBrowserAvailable, n as spawnAB, o as pathWithAgentBrowserShim, r as AgentBrowserUnavailableError, s as resolveAgentBrowserBin$1, t as sleepSync } from "../spawn-ab-B9Il2TMd.mjs";
 import { HubApiError, createHubClient } from "../hub-client/index.mjs";
 import { createRequire } from "node:module";
 import { Command } from "commander";
-import { accessSync, createWriteStream, existsSync, readFileSync, rmSync, statSync } from "node:fs";
+import { accessSync, createWriteStream, existsSync, readFileSync, rmSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { access, chmod, cp, mkdir, mkdtemp, open, readFile, readdir, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
-import { basename, delimiter, dirname, isAbsolute, join, normalize, posix, relative, resolve, sep } from "node:path";
+import { basename, dirname, isAbsolute, join, normalize, posix, relative, resolve, sep } from "node:path";
 import { parse, stringify } from "yaml";
 import { ZodError, z } from "zod";
 import { execFile, spawn, spawnSync } from "node:child_process";
@@ -679,10 +679,10 @@ function bundledVitestConfigPath() {
 }
 //#endregion
 //#region src/runtime/spawn-vitest.ts
-const require$2 = createRequire(import.meta.url);
+const require$1 = createRequire(import.meta.url);
 function resolveVitestBin() {
-	const pkgPath = require$2.resolve("vitest/package.json");
-	const pkg = require$2(pkgPath);
+	const pkgPath = require$1.resolve("vitest/package.json");
+	const pkg = require$1(pkgPath);
 	const binRel = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.vitest;
 	if (!binRel) throw new Error(`vitest package.json has no bin entry (resolved at ${pkgPath})`);
 	return resolve(dirname(pkgPath), binRel);
@@ -3931,104 +3931,6 @@ async function warnStaleBlockArtifacts() {
 	for (const p of stale) hint(`stale block artifact detected: ${p} — v0.4 no longer uses these; delete it manually.`);
 }
 //#endregion
-//#region src/runtime/agent-browser-bin.ts
-const require$1 = createRequire(import.meta.url);
-function hasAgentBrowserShim(dir) {
-	try {
-		statSync(join(dir, "agent-browser"));
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
-* Walks up from `start` looking for a `node_modules/.bin/agent-browser` shim.
-* Returns the .bin directory containing the shim, or null if none is found.
-*/
-function findNodeModulesBin(start) {
-	let cur = start;
-	while (true) {
-		const candidate = join(cur, "node_modules", ".bin");
-		if (hasAgentBrowserShim(candidate)) return candidate;
-		const parent = dirname(cur);
-		if (parent === cur) return null;
-		cur = parent;
-	}
-}
-/**
-* Resolves the directory containing the `agent-browser` shim that npm/pnpm
-* exposes on PATH for the peer-installed package. Used by `ccqa trace` to
-* prepend this directory to PATH so the Claude subprocess can invoke
-* `agent-browser ...` without requiring a global install.
-*
-* Returns null if agent-browser cannot be located.
-*/
-function resolveAgentBrowserBinDir() {
-	const fromCwd = findNodeModulesBin(process.cwd());
-	if (fromCwd) return fromCwd;
-	const fromSelf = findNodeModulesBin(dirname(require$1.resolve("agent-browser/package.json")));
-	if (fromSelf) return fromSelf;
-	try {
-		const candidate = join(dirname(require$1.resolve("agent-browser/package.json")), "node_modules", ".bin");
-		if (hasAgentBrowserShim(candidate)) return candidate;
-	} catch {}
-	return null;
-}
-/**
-* Returns a PATH string with the agent-browser shim directory prepended,
-* so `agent-browser ...` resolves without a global install. Falls back to
-* the original PATH when the package can't be resolved.
-*/
-function pathWithAgentBrowserShim(currentPath) {
-	const path = currentPath ?? "";
-	const dir = resolveAgentBrowserBinDir();
-	if (!dir) return path;
-	if (path.split(delimiter).includes(dir)) return path;
-	return dir + delimiter + path;
-}
-/**
-* Confirms before launching Claude that an `agent-browser` shim is reachable
-* via PATH. We do this up front so a missing peer dependency fails fast with
-* a clear message, instead of Claude burning tokens probing the system with
-* `which`, `find`, `npm install`, etc.
-*
-* The `resolver` argument is for tests; production calls take no args.
-*/
-function assertAgentBrowserAvailable(resolver = resolveAgentBrowserBinDir) {
-	const dir = resolver();
-	if (!dir) throw new AgentBrowserUnavailableError();
-	const shim = join(dir, "agent-browser");
-	try {
-		const s = statSync(shim);
-		if (!s.isFile() && !s.isSymbolicLink()) throw new AgentBrowserUnavailableError();
-	} catch {
-		throw new AgentBrowserUnavailableError();
-	}
-	return dir;
-}
-var AgentBrowserUnavailableError = class extends Error {
-	constructor() {
-		super("agent-browser binary not found on PATH");
-		this.name = "AgentBrowserUnavailableError";
-	}
-};
-/** Human-readable explanation shown to the user when the guard fires. */
-function formatAgentBrowserUnavailableMessage() {
-	return [
-		"agent-browser is not installed or not on PATH.",
-		"",
-		"ccqa drives the browser via the peer-installed `agent-browser` package.",
-		"Install it in this project:",
-		"",
-		"  pnpm add -D agent-browser",
-		"  # or",
-		"  npm install -D agent-browser",
-		"",
-		"If it is already installed, make sure you are running ccqa from the",
-		"project root (or via your package runner, e.g. `pnpm exec ccqa ...`)."
-	].join("\n");
-}
-//#endregion
 //#region src/cli/preflight.ts
 /**
 * Shared startup steps for every command that drives a real `agent-browser`
@@ -4307,6 +4209,14 @@ function readOctal(buf, offset, fieldLen) {
 /** Default per-profile sessions root, relative to the project (`--cwd`). */
 const SESSIONS_SUBDIR = ".ccqa/sessions";
 /**
+* Key under which `bootstrap` embeds the verify URL inside the uploaded
+* storage-state JSON. The hub roundtrips it opaquely; `mergeStorageStates`
+* rebuilds a `{cookies, origins}` object, so the key never reaches
+* agent-browser (which would reject an unknown top-level field). `ccqa run`
+* reads it to health-check the restore before executing steps.
+*/
+const SESSION_VERIFY_URL_KEY = "__ccqaVerifyUrl";
+/**
 * Resolve a session name to its state file path:
 * `<cwd>/.ccqa/sessions/<profile>/<name>.json`. The name is a slug (validated
 * by SessionNameSchema), so it can't escape the sessions directory. Used by
@@ -4428,20 +4338,54 @@ function loadStateIntoSession(sessionName, statePath) {
 	};
 	return { ok: true };
 }
+/** Drop every trailing slash so `/a` and `/a/` compare equal. */
+function normalizePath(pathname) {
+	return pathname.replace(/\/+$/, "");
+}
+/**
+* Behaviour-based "signed in?" check with no product knowledge: after
+* restoring a session, opening `requestedUrl` must settle on the SAME origin
+* and WITHIN the requested path. An expired/absent auth redirects elsewhere —
+* a sign-in route on the same origin, or a different origin entirely — so a
+* final URL that left the requested origin+path means the restore failed.
+*
+* This replaces the old "is a password input visible?" heuristic, which had
+* false positives (multi-step / SSO / workspace-picker sign-in screens show no
+* password field) and false negatives (a signed-in page can host a
+* change-password form). Trailing slashes are insensitive; a malformed URL on
+* either side returns false.
+*
+* Limitation: if `requestedUrl` is just an origin root, any same-origin page
+* counts as "stayed" (`startsWith("")` is always true) — so callers should
+* pass a deep, already-signed-in page URL. And an app that renders a login
+* form IN PLACE at the same URL (no redirect) can't be caught this way; the
+* escape hatch for that is a future explicit positive signal (e.g. a
+* `--verify-text` the caller expects to see). See issue #109.
+*/
+function urlStayedAtTarget(requestedUrl, finalUrl) {
+	let requested;
+	let final;
+	try {
+		requested = new URL(requestedUrl);
+		final = new URL(finalUrl);
+	} catch {
+		return false;
+	}
+	if (requested.origin !== final.origin) return false;
+	return normalizePath(final.pathname).startsWith(normalizePath(requested.pathname));
+}
 /**
-* Prove a just-saved session actually restores to a signed-in page, in a fresh
-* throwaway agent-browser session, before it's trusted (e.g. uploaded to the
-* hub). Loads `statePath` into a clean session, navigates to `verifyUrl`, and
-* checks that a login form did NOT appear — the common failure mode where a
-* bootstrap was saved before the app finished signing in, so cookies restore
-* but the app still demands re-auth.
+* Prove a saved session actually restores to a signed-in page, in a fresh
+* throwaway agent-browser session. Loads `statePath` into a clean session,
+* opens `verifyUrl`, and checks the browser STAYED at that URL's origin+path
+* (see {@link urlStayedAtTarget}) — an expired/absent session redirects to a
+* sign-in route or another origin instead. Used both as a save-time gate in
+* `bootstrap` and as a pre-run health check in `ccqa run`.
 *
-* "Signed-in" is detected generically (no product strings): a password input
-* present means a login form is showing → not restored. This is a positive
-* gate on the save, not a runtime check. Best-effort: on infrastructure errors
-* (daemon won't start, navigation fails) it returns `restored: false` with the
-* error so the caller can surface it rather than silently trusting the save.
-* Always closes the throwaway session.
+* Best-effort: on infrastructure errors (daemon won't start, navigation
+* fails) it returns `restored: false` with the error so the caller can
+* surface it rather than silently trusting the session. Always closes the
+* throwaway session.
 */
 function verifySessionRestores(statePath, verifyUrl) {
 	const verifySession = `ccqa-session-verify-${process.pid}-${trackedTempDirs.size}`;
@@ -4477,17 +4421,17 @@ function verifySessionRestores(statePath, verifyUrl) {
 		const probe = spawnAB([
 			"--session",
 			verifySession,
-			"get",
-			"count",
-			"input[type=password]"
+			"eval",
+			"location.href"
 		]);
 		if (probe.status !== 0) return {
 			restored: false,
 			reason: (probe.stderr || probe.stdout || `probe exited ${probe.status}`).trim()
 		};
-		if ((Number.parseInt(probe.stdout.replace(/[^0-9]/g, ""), 10) || 0) >= 1) return {
+		const finalHref = unwrapEvalString(probe.stdout);
+		if (!urlStayedAtTarget(verifyUrl, finalHref)) return {
 			restored: false,
-			reason: "a sign-in form appeared — the app is not signed in after restore"
+			reason: `restore left the verify URL — landed on ${safeOriginPath(finalHref)}`
 		};
 		return { restored: true };
 	} finally {
@@ -4498,6 +4442,25 @@ function verifySessionRestores(statePath, verifyUrl) {
 		]);
 	}
 }
+/** Take the last non-empty line of `agent-browser eval` stdout and JSON-unquote it. */
+function unwrapEvalString(stdout) {
+	const lines = stdout.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+	const last = lines[lines.length - 1] ?? "";
+	try {
+		const parsed = JSON.parse(last);
+		if (typeof parsed === "string") return parsed;
+	} catch {}
+	return last.replace(/^"|"$/g, "");
+}
+/** `origin + pathname` of a URL, or the raw string if it doesn't parse. */
+function safeOriginPath(href) {
+	try {
+		const u = new URL(href);
+		return u.origin + u.pathname;
+	} catch {
+		return href;
+	}
+}
 //#endregion
 //#region src/prompts/prompt-names.ts
 /**
@@ -5632,21 +5595,33 @@ async function runDriftAuditOne(r, opts, cwd) {
 	return result.issues.length > 0 ? result.issues : null;
 }
 /**
+* Sessions whose restore has already been health-checked this process, keyed
+* `<profile>/<name>`. A run of many specs restores the same session repeatedly;
+* we only open a throwaway verify browser the first time.
+*/
+const verifiedSessions = /* @__PURE__ */ new Set();
+/**
 * Resolve `spec.session` names to a single state file to restore, fetching
 * each named session from the hub (`.ccqa/sessions/*.json` is no longer
 * read here). Every name must load as a valid agent-browser state (the spec
 * assumes it starts signed-in); a missing/malformed session fails with a
-* `ccqa session bootstrap` hint instead of running unauthenticated. Loaded
-* states are always merged (even a single one) and written to a fresh temp
-* file — callers must invoke the returned `cleanup()` once the run is done.
-*/
-async function resolveSessionState(names, hubCtx, profile) {
+* `ccqa session bootstrap` hint instead of running unauthenticated.
+*
+* If a session carries an embedded verify URL (bootstrap saved it), the
+* restore is health-checked before the run starts, so an expired/unusable
+* session fails fast with a re-bootstrap hint instead of every step failing
+* generically. Loaded states are always merged (even a single one) and written
+* to a fresh temp file — callers must invoke the returned `cleanup()` once the
+* run is done. `verify` is injectable for tests.
+*/
+async function resolveSessionState(names, hubCtx, profile, verify = verifySessionRestores) {
 	if (names.length === 0 || hubCtx === null) return {
 		ok: false,
 		error: `session '${names.join(", ")}' requires a hub connection`,
 		hint: "set --hub-url/--hub-token (or CCQA_HUB_URL/CCQA_HUB_TOKEN) to restore sessions from the hub"
 	};
 	const resolvedProfile = profile ?? "default";
+	const profileFlag = profile ? ` --profile ${profile}` : "";
 	const loaded = [];
 	const broken = [];
 	for (const name of names) {
@@ -5661,16 +5636,28 @@ async function resolveSessionState(names, hubCtx, profile) {
 			broken.push(name);
 			continue;
 		}
+		const embedded = state[SESSION_VERIFY_URL_KEY];
+		if (typeof embedded === "string") {
+			const memoKey = `${resolvedProfile}/${name}`;
+			if (!verifiedSessions.has(memoKey)) {
+				const tmp = await writeMergedTempState(mergeStorageStates([state]));
+				const check = verify(tmp, embedded);
+				await removeTempStateDir(tmp);
+				if (!check.restored) return {
+					ok: false,
+					error: `session '${name}' did not restore to a signed-in page — ${check.reason}`,
+					hint: `re-bootstrap it: ccqa session bootstrap ${name}${profileFlag}`
+				};
+				verifiedSessions.add(memoKey);
+			}
+		} else warn(`session '${name}' has no embedded verify URL (saved by an older ccqa) — skipping the pre-run restore check`);
 		loaded.push(state);
 	}
-	if (broken.length > 0) {
-		const profileFlag = profile ? ` --profile ${profile}` : "";
-		return {
-			ok: false,
-			error: `session not usable on the hub: ${broken.join(", ")}`,
-			hint: `create it with: ${broken.map((name) => `ccqa session bootstrap ${name}${profileFlag}`).join("  ·  ")}`
-		};
-	}
+	if (broken.length > 0) return {
+		ok: false,
+		error: `session not usable on the hub: ${broken.join(", ")}`,
+		hint: `create it with: ${broken.map((name) => `ccqa session bootstrap ${name}${profileFlag}`).join("  ·  ")}`
+	};
 	const statePath = await writeMergedTempState(mergeStorageStates(loaded));
 	return {
 		ok: true,
@@ -13083,7 +13070,7 @@ const initCommand = new Command("init").description("Create the .ccqa/ spec skel
 });
 //#endregion
 //#region src/cli/session.ts
-const AB = createRequire(import.meta.url).resolve("agent-browser/bin/agent-browser.js");
+const AB = resolveAgentBrowserBin$1();
 /**
 * Run agent-browser attached to the user's terminal (no timeout, inherited
 * stdio) so a human can complete an interactive login during `bootstrap`.
@@ -13150,6 +13137,7 @@ const bootstrapCommand = new Command("bootstrap").description("Open a headed bro
 			process.exit(1);
 		}
 		const state = await loadStorageState(tmpPath);
+		let payload = state;
 		if (opts.url) {
 			info("verifying the saved session restores to a signed-in page…");
 			const check = verifySessionRestores(tmpPath, opts.url);
@@ -13159,8 +13147,12 @@ const bootstrapCommand = new Command("bootstrap").description("Open a headed bro
 				process.exit(1);
 			}
 			info("restore verified — the session starts signed in.");
-		}
-		await hub.putSession(project, opts.profile ?? "default", name, state);
+			payload = {
+				...state,
+				[SESSION_VERIFY_URL_KEY]: opts.url
+			};
+		} else warn("no --url given — the session can't be verified now, and runs can't health-check it before executing steps; strongly consider re-running with --url <a signed-in page URL>.");
+		await hub.putSession(project, opts.profile ?? "default", name, payload);
 	} finally {
 		await rm(tmpDir, {
 			recursive: true,

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccqa",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "type": "module",
   "description": "Browser test recorder powered by Claude Code and agent-browser",
   "repository": {
@@ -28,7 +28,8 @@
     "dist/"
   ],
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.87",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.215",
+    "@anthropic-ai/sdk": "^0.112.3",
     "commander": "^14.0.3",
     "yaml": "^2.9.0",
     "zod": "^4.3.6"

package/dist/runtime/test-helpers.mjs

@@ -1,4 +1,4 @@
-import { i as FAILURE_STEP_ID, n as spawnAB, r as FAILURE_SOURCE, t as sleepSync } from "../spawn-ab-Cr967J2N.mjs";
+import { c as FAILURE_SOURCE, l as FAILURE_STEP_ID, n as spawnAB, t as sleepSync } from "../spawn-ab-B9Il2TMd.mjs";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 //#region src/runtime/test-helpers.ts

package/dist/spawn-ab-B9Il2TMd.mjs

@@ -0,0 +1,210 @@
+import { createRequire } from "node:module";
+import { statSync } from "node:fs";
+import { delimiter, dirname, join } from "node:path";
+import { spawnSync } from "node:child_process";
+//#region src/runtime/evidence-constants.ts
+/**
+* Shared constants for step-boundary evidence captured by abStepEvidence() /
+* captureFailureEvidence() and consumed by the run report. Kept under
+* `runtime/` so the test-helpers module — which generated test scripts import
+* via `ccqa/test-helpers` — can stay free of CLI-side imports while still
+* sharing the literal with run.ts.
+*/
+/** stepId reserved for the screenshot captured by fail() at the moment of an assertion failure. */
+const FAILURE_STEP_ID = "failure";
+/** source value paired with FAILURE_STEP_ID so the report can tell failure captures apart from step captures. */
+const FAILURE_SOURCE = "failed";
+//#endregion
+//#region src/runtime/agent-browser-bin.ts
+const require = createRequire(import.meta.url);
+function hasAgentBrowserShim(dir) {
+	try {
+		statSync(join(dir, "agent-browser"));
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Walks up from `start` looking for a `node_modules/.bin/agent-browser` shim.
+* Returns the .bin directory containing the shim, or null if none is found.
+*/
+function findNodeModulesBin(start) {
+	let cur = start;
+	while (true) {
+		const candidate = join(cur, "node_modules", ".bin");
+		if (hasAgentBrowserShim(candidate)) return candidate;
+		const parent = dirname(cur);
+		if (parent === cur) return null;
+		cur = parent;
+	}
+}
+/** The shim-directory walk shared by every resolution below (no env override). */
+function resolveShimDir() {
+	const fromCwd = findNodeModulesBin(process.cwd());
+	if (fromCwd) return fromCwd;
+	const fromSelf = findNodeModulesBin(dirname(require.resolve("agent-browser/package.json")));
+	if (fromSelf) return fromSelf;
+	try {
+		const candidate = join(dirname(require.resolve("agent-browser/package.json")), "node_modules", ".bin");
+		if (hasAgentBrowserShim(candidate)) return candidate;
+	} catch {}
+	return null;
+}
+/**
+* INVARIANT: every agent-browser invocation in one ccqa process — the host
+* side (`spawnAB`: state load, replay probes, …) and the Claude subprocess
+* (via the PATH prepended by `pathWithAgentBrowserShim`) — must resolve to
+* the SAME binary. agent-browser runs one daemon per binary, and a state
+* loaded into one daemon's session is invisible to a same-named session on
+* another daemon, so a split resolution silently loses session restores.
+* Both entry points below therefore share one resolution order:
+* `CCQA_AB_BIN` (explicit override, e.g. the e2e harness or a dev build
+* driving a consumer project's agent-browser) → the peer-installed shim
+* (consumer project first, then ccqa's own tree).
+*/
+/**
+* Resolves the executable `spawnAB` should invoke. Falls back to the package
+* JS entry (resolvable whenever the peer dependency is installed) when no
+* shim directory exists; throws only if agent-browser is missing entirely.
+*/
+function resolveAgentBrowserBin() {
+	const override = process.env["CCQA_AB_BIN"];
+	if (override) return override;
+	const shimDir = resolveShimDir();
+	if (shimDir) return join(shimDir, "agent-browser");
+	return require.resolve("agent-browser/bin/agent-browser.js");
+}
+/**
+* Resolves the directory containing the `agent-browser` shim that npm/pnpm
+* exposes on PATH for the peer-installed package. Used by `ccqa trace` /
+* `ccqa run` to prepend this directory to PATH so the Claude subprocess can
+* invoke `agent-browser ...` without requiring a global install.
+*
+* Returns null if agent-browser cannot be located.
+*/
+function resolveAgentBrowserBinDir() {
+	const override = process.env["CCQA_AB_BIN"];
+	if (override) return dirname(override);
+	return resolveShimDir();
+}
+/**
+* Returns a PATH string with the agent-browser shim directory prepended,
+* so `agent-browser ...` resolves without a global install. Falls back to
+* the original PATH when the package can't be resolved.
+*/
+function pathWithAgentBrowserShim(currentPath) {
+	const path = currentPath ?? "";
+	const dir = resolveAgentBrowserBinDir();
+	if (!dir) return path;
+	if (path.split(delimiter).includes(dir)) return path;
+	return dir + delimiter + path;
+}
+/**
+* Confirms before launching Claude that an `agent-browser` shim is reachable
+* via PATH. We do this up front so a missing peer dependency fails fast with
+* a clear message, instead of Claude burning tokens probing the system with
+* `which`, `find`, `npm install`, etc.
+*
+* The `resolver` argument is for tests; production calls take no args.
+*/
+function assertAgentBrowserAvailable(resolver = resolveAgentBrowserBinDir) {
+	const probe = process.env["CCQA_AB_BIN"] ?? (() => {
+		const dir = resolver();
+		return dir === null ? null : join(dir, "agent-browser");
+	})();
+	if (!probe) throw new AgentBrowserUnavailableError();
+	try {
+		const s = statSync(probe);
+		if (!s.isFile() && !s.isSymbolicLink()) throw new AgentBrowserUnavailableError();
+	} catch {
+		throw new AgentBrowserUnavailableError();
+	}
+	return dirname(probe);
+}
+var AgentBrowserUnavailableError = class extends Error {
+	constructor() {
+		super("agent-browser binary not found on PATH");
+		this.name = "AgentBrowserUnavailableError";
+	}
+};
+/** Human-readable explanation shown to the user when the guard fires. */
+function formatAgentBrowserUnavailableMessage() {
+	return [
+		"agent-browser is not installed or not on PATH.",
+		"",
+		"ccqa drives the browser via the peer-installed `agent-browser` package.",
+		"Install it in this project:",
+		"",
+		"  pnpm add -D agent-browser",
+		"  # or",
+		"  npm install -D agent-browser",
+		"",
+		"If it is already installed, make sure you are running ccqa from the",
+		"project root (or via your package runner, e.g. `pnpm exec ccqa ...`)."
+	].join("\n");
+}
+//#endregion
+//#region src/runtime/spawn-ab.ts
+const AB = resolveAgentBrowserBin();
+const EAGAIN_PATTERN = /Resource temporarily unavailable|os error 35/i;
+const EAGAIN_TOTAL_BUDGET_MS = 3e4;
+const EAGAIN_BACKOFF_MS = [
+	100,
+	200,
+	300,
+	500,
+	700,
+	1e3,
+	1500,
+	2e3,
+	2500,
+	3e3,
+	3e3,
+	3e3,
+	3e3,
+	3e3,
+	3e3
+];
+const PROCESS_HARD_TIMEOUT_MS = 35e3;
+function sleepSync(ms) {
+	const buf = new SharedArrayBuffer(4);
+	Atomics.wait(new Int32Array(buf), 0, 0, ms);
+}
+function spawnABOnce(args) {
+	const result = spawnSync(AB, args, {
+		stdio: "pipe",
+		timeout: PROCESS_HARD_TIMEOUT_MS
+	});
+	return {
+		status: result.status,
+		stdout: result.stdout?.toString() ?? "",
+		stderr: (result.stderr?.toString() ?? "") + (result.signal === "SIGTERM" ? "\n[ccqa] agent-browser killed after hard timeout" : "")
+	};
+}
+/**
+* Invoke `agent-browser` once and return its exit status/stdout/stderr,
+* retrying internally up to ~30s while the daemon's state file is in the
+* "Resource temporarily unavailable" race window. Used by both the test
+* runtime (`test-helpers.ts`) and the post-trace replay validation
+* (`replay-validate.ts`). Kept out of `test-helpers.ts` because that
+* module is also the public surface for generated test scripts — exposing
+* the raw spawner there would widen the contract for end users.
+*/
+function spawnAB(args) {
+	let result = spawnABOnce(args);
+	let elapsed = 0;
+	let attempt = 0;
+	while (result.status !== 0 && elapsed < EAGAIN_TOTAL_BUDGET_MS) {
+		const combined = `${result.stdout}\n${result.stderr}`;
+		if (!EAGAIN_PATTERN.test(combined)) return result;
+		const wait = EAGAIN_BACKOFF_MS[attempt] ?? 3e3;
+		sleepSync(wait);
+		elapsed += wait;
+		attempt++;
+		result = spawnABOnce(args);
+	}
+	return result;
+}
+//#endregion
+export { formatAgentBrowserUnavailableMessage as a, FAILURE_SOURCE as c, assertAgentBrowserAvailable as i, FAILURE_STEP_ID as l, spawnAB as n, pathWithAgentBrowserShim as o, AgentBrowserUnavailableError as r, resolveAgentBrowserBin as s, sleepSync as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccqa",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "type": "module",
   "description": "Browser test recorder powered by Claude Code and agent-browser",
   "repository": {
@@ -28,7 +28,8 @@
     "dist/"
   ],
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.87",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.215",
+    "@anthropic-ai/sdk": "^0.112.3",
     "commander": "^14.0.3",
     "yaml": "^2.9.0",
     "zod": "^4.3.6"

package/dist/spawn-ab-Cr967J2N.mjs

@@ -1,79 +0,0 @@
-import { createRequire } from "node:module";
-import { spawnSync } from "node:child_process";
-//#region src/runtime/evidence-constants.ts
-/**
-* Shared constants for step-boundary evidence captured by abStepEvidence() /
-* captureFailureEvidence() and consumed by the run report. Kept under
-* `runtime/` so the test-helpers module — which generated test scripts import
-* via `ccqa/test-helpers` — can stay free of CLI-side imports while still
-* sharing the literal with run.ts.
-*/
-/** stepId reserved for the screenshot captured by fail() at the moment of an assertion failure. */
-const FAILURE_STEP_ID = "failure";
-/** source value paired with FAILURE_STEP_ID so the report can tell failure captures apart from step captures. */
-const FAILURE_SOURCE = "failed";
-//#endregion
-//#region src/runtime/spawn-ab.ts
-const require = createRequire(import.meta.url);
-const AB = process.env["CCQA_AB_BIN"] ?? require.resolve("agent-browser/bin/agent-browser.js");
-const EAGAIN_PATTERN = /Resource temporarily unavailable|os error 35/i;
-const EAGAIN_TOTAL_BUDGET_MS = 3e4;
-const EAGAIN_BACKOFF_MS = [
-	100,
-	200,
-	300,
-	500,
-	700,
-	1e3,
-	1500,
-	2e3,
-	2500,
-	3e3,
-	3e3,
-	3e3,
-	3e3,
-	3e3,
-	3e3
-];
-const PROCESS_HARD_TIMEOUT_MS = 35e3;
-function sleepSync(ms) {
-	const buf = new SharedArrayBuffer(4);
-	Atomics.wait(new Int32Array(buf), 0, 0, ms);
-}
-function spawnABOnce(args) {
-	const result = spawnSync(AB, args, {
-		stdio: "pipe",
-		timeout: PROCESS_HARD_TIMEOUT_MS
-	});
-	return {
-		status: result.status,
-		stdout: result.stdout?.toString() ?? "",
-		stderr: (result.stderr?.toString() ?? "") + (result.signal === "SIGTERM" ? "\n[ccqa] agent-browser killed after hard timeout" : "")
-	};
-}
-/**
-* Invoke `agent-browser` once and return its exit status/stdout/stderr,
-* retrying internally up to ~30s while the daemon's state file is in the
-* "Resource temporarily unavailable" race window. Used by both the test
-* runtime (`test-helpers.ts`) and the post-trace replay validation
-* (`replay-validate.ts`). Kept out of `test-helpers.ts` because that
-* module is also the public surface for generated test scripts — exposing
-* the raw spawner there would widen the contract for end users.
-*/
-function spawnAB(args) {
-	let result = spawnABOnce(args);
-	let elapsed = 0;
-	let attempt = 0;
-	while (result.status !== 0 && elapsed < EAGAIN_TOTAL_BUDGET_MS) {
-		const combined = `${result.stdout}\n${result.stderr}`;
-		if (!EAGAIN_PATTERN.test(combined)) return result;
-		const wait = EAGAIN_BACKOFF_MS[attempt] ?? 3e3;
-		sleepSync(wait);
-		elapsed += wait;
-		attempt++;
-		result = spawnABOnce(args);
-	}
-	return result;
-}
-//#endregion
-export { FAILURE_STEP_ID as i, spawnAB as n, FAILURE_SOURCE as r, sleepSync as t };