ccqa 1.42.2 → 1.44.0

package/dist/bin/ccqa.mjs

@@ -4,7 +4,7 @@ import { t as EVIDENCE_DIR_ENV } from "../evidence-constants-C425F7ZG.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-Bm34WBui.mjs";
 import { createRequire } from "node:module";
 import { Command } from "commander";
-import { accessSync, appendFileSync, createWriteStream, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { accessSync, appendFileSync, createReadStream, createWriteStream, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { createCipheriv, createDecipheriv, createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import { access, appendFile, chmod, cp, mkdir, mkdtemp, open, readFile, readdir, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
@@ -872,6 +872,35 @@ async function runPool(items, concurrency, fn, opts = {}) {
 	return results;
 }
 //#endregion
+//#region src/claude/env-keys.ts
+/**
+* Variables that carry a credential the Claude Code process can use on its
+* own, with no login on the host: an API key, a gateway bearer token, or a
+* subscription token from `claude setup-token`.
+*/
+const CREDENTIAL_ENV_KEYS = [
+	"ANTHROPIC_API_KEY",
+	"ANTHROPIC_AUTH_TOKEN",
+	"CLAUDE_CODE_OAUTH_TOKEN"
+];
+/**
+* Standard Claude Code environment variables that select the API endpoint and
+* credentials. ccqa forwards whichever of these are set to the underlying
+* Claude Code process; it does not read or interpret their values.
+*
+* - `ANTHROPIC_BASE_URL`      — the API endpoint to send requests to.
+* - `ANTHROPIC_AUTH_TOKEN`    — sent as `Authorization: Bearer <token>`.
+* - `ANTHROPIC_API_KEY`       — API key, when used instead of a token.
+* - `ANTHROPIC_CUSTOM_HEADERS` — extra request headers.
+* - `CLAUDE_CODE_OAUTH_TOKEN` — long-lived subscription token from
+*   `claude setup-token`, the headless-CI counterpart of a login.
+*/
+const ENDPOINT_ENV_KEYS = [
+	"ANTHROPIC_BASE_URL",
+	"ANTHROPIC_CUSTOM_HEADERS",
+	...CREDENTIAL_ENV_KEYS
+];
+//#endregion
 //#region src/drift/auth.ts
 /**
 * Claude Code can also run against AWS Bedrock / Google Vertex AI, selected by
@@ -889,21 +918,20 @@ function cloudProviderEnabled() {
 }
 /**
 * Probe whether the host has any credential the Anthropic SDK can pick up:
-*   1. ANTHROPIC_API_KEY env var (CI / scripted use)
-*   2. CLAUDE_CODE_OAUTH_TOKEN env var (a long-lived subscription token from
-*      `claude setup-token`, the headless-CI counterpart of a login)
-*   3. CLAUDE_CODE_USE_BEDROCK / CLAUDE_CODE_USE_VERTEX (cloud-provider
-*      endpoints authenticated by the cloud SDK's credential chain)
-*   4. ~/.claude/.credentials.json (Claude Code login, file-based platforms)
-*   5. macOS Keychain item "Claude Code-credentials" (Claude Code login on
-*      darwin stores the OAuth credentials in the Keychain, not on disk)
+*   - one of CREDENTIAL_ENV_KEYS (API key, gateway bearer token, or the
+*     subscription token from `claude setup-token`)
+*   - CLAUDE_CODE_USE_BEDROCK / CLAUDE_CODE_USE_VERTEX (cloud-provider
+*     endpoints authenticated by the cloud SDK's credential chain)
+*   - ~/.claude/.credentials.json (Claude Code login, file-based platforms)
+*   - macOS Keychain item "Claude Code-credentials" (Claude Code login on
+*     darwin stores the OAuth credentials in the Keychain, not on disk)
 *
 * Claude-driven hooks are opt-in, so the caller only consults this after the
 * user has asked for analysis. We never throw — auth absence is a normal flow
 * that surfaces as "analysis skipped".
 */
 function driftAuthAvailable() {
-	for (const key of ["ANTHROPIC_API_KEY", "CLAUDE_CODE_OAUTH_TOKEN"]) {
+	for (const key of CREDENTIAL_ENV_KEYS) {
 		const value = process.env[key];
 		if (typeof value === "string" && value.length > 0) return { ok: true };
 	}
@@ -912,7 +940,7 @@ function driftAuthAvailable() {
 	if (process.platform === "darwin" && keychainHasClaudeCredentials()) return { ok: true };
 	return {
 		ok: false,
-		reason: "no ANTHROPIC_API_KEY / CLAUDE_CODE_OAUTH_TOKEN / Bedrock or Vertex env / claude login"
+		reason: `no ${CREDENTIAL_ENV_KEYS.join(" / ")} / Bedrock or Vertex env / claude login`
 	};
 }
 /**
@@ -1520,31 +1548,17 @@ function sum(costs) {
 }
 //#endregion
 //#region src/claude/invoke.ts
+/** The built-in tools an allow-list names: `Bash(*)` is `Bash`; `mcp__*` are not built-ins. */
+function builtinToolNames(allowedTools) {
+	const names = allowedTools.map((entry) => entry.replace(/\(.*\)$/, "")).filter((name) => !name.startsWith("mcp__"));
+	return [...new Set(names)];
+}
 function resolveModel(explicit) {
 	if (explicit) return explicit;
 	const envModel = process.env["CCQA_MODEL"];
 	return envModel && envModel.length > 0 ? envModel : void 0;
 }
 /**
-* Standard Claude Code environment variables that select the API endpoint and
-* credentials. ccqa forwards whichever of these are set to the underlying
-* Claude Code process; it does not read or interpret their values.
-*
-* - `ANTHROPIC_BASE_URL`      — the API endpoint to send requests to.
-* - `ANTHROPIC_AUTH_TOKEN`    — sent as `Authorization: Bearer <token>`.
-* - `ANTHROPIC_API_KEY`       — API key, when used instead of a token.
-* - `ANTHROPIC_CUSTOM_HEADERS` — extra request headers.
-* - `CLAUDE_CODE_OAUTH_TOKEN` — long-lived subscription token from
-*   `claude setup-token`, the headless-CI counterpart of a login.
-*/
-const ENDPOINT_ENV_KEYS = [
-	"ANTHROPIC_BASE_URL",
-	"ANTHROPIC_AUTH_TOKEN",
-	"ANTHROPIC_API_KEY",
-	"ANTHROPIC_CUSTOM_HEADERS",
-	"CLAUDE_CODE_OAUTH_TOKEN"
-];
-/**
 * When both credentials are present the OAuth token wins and the API key is
 * dropped. Left to the CLI the API key would win, which makes "switch a CI
 * job to the subscription token" require unwiring the key everywhere; with
@@ -1556,21 +1570,6 @@ function preferOauthToken(env) {
 	if (env["CLAUDE_CODE_OAUTH_TOKEN"]) delete env["ANTHROPIC_API_KEY"];
 }
 /**
-* Collects the endpoint/auth variables set in the current process environment
-* so they can be forwarded, verbatim, to every Claude Code invocation. Returns
-* only the keys that are actually set (non-empty), so unset variables never
-* override the SDK's own defaults. Credential precedence per preferOauthToken.
-*/
-function resolveEndpointEnv() {
-	const endpointEnv = {};
-	for (const key of ENDPOINT_ENV_KEYS) {
-		const value = process.env[key];
-		if (value && value.length > 0) endpointEnv[key] = value;
-	}
-	preferOauthToken(endpointEnv);
-	return endpointEnv;
-}
-/**
 * Drop endpoint variables that are present but empty, so an empty value never
 * reaches the Claude Code process as an override. "Set to nothing" is how a
 * caller that cannot omit the key says "use the default" — a CI job wiring
@@ -1591,18 +1590,14 @@ function withoutEmptyEndpointVars(env) {
 * resolved view: left to the CLI the API key would win, silently moving every
 * call from the subscription to metered billing when a CI job wires both
 * (which is exactly what happened before this function existed).
-*
-* Returns undefined when no endpoint variable is set and the caller passes no
-* env, so the SDK keeps its own default environment.
 */
 function buildInvocationEnv(env) {
-	const hasEndpointEnv = Object.keys(resolveEndpointEnv()).length > 0;
-	if (!env && !hasEndpointEnv) return void 0;
 	const merged = withoutEmptyEndpointVars({
 		...process.env,
 		...env
 	});
 	preferOauthToken(merged);
+	merged["CLAUDE_CODE_DISABLE_AUTO_MEMORY"] = "1";
 	return merged;
 }
 let nativeBinaryWarned = false;
@@ -1624,7 +1619,7 @@ function formatDuration$1(ms) {
 	return `${minutes} minute${minutes === 1 ? "" : "s"}`;
 }
 async function invokeClaudeStreaming(options, onEvent) {
-	const { prompt, systemPrompt, allowedTools, disableBuiltinTools = false, disableThinking = false, mcpServers, maxTurns, timeoutMs, env, model, cwd, onAbAction, onAbActionFailed, silenceBashLog = false, envScrubMap = [], relaxAbConstraints = false } = options;
+	const { prompt, systemPrompt, allowedTools, disableThinking = false, mcpServers, maxTurns, timeoutMs, env, model, cwd, onAbAction, onAbActionFailed, silenceBashLog = false, envScrubMap = [], relaxAbConstraints = false } = options;
 	const resolvedModel = resolveModel(model);
 	const mergedEnv = buildInvocationEnv(env);
 	const abortController = new AbortController();
@@ -1637,15 +1632,17 @@ async function invokeClaudeStreaming(options, onEvent) {
 	const sdkOptions = {
 		systemPrompt,
 		maxTurns,
-		allowedTools: allowedTools ?? ["Bash(*)"],
+		allowedTools,
+		tools: builtinToolNames(allowedTools),
+		strictMcpConfig: true,
+		settingSources: [],
 		permissionMode: "bypassPermissions",
 		allowDangerouslySkipPermissions: true,
 		abortController,
 		...resolvedModel ? { model: resolvedModel } : {},
 		...cwd ? { cwd } : {},
-		...mergedEnv ? { env: mergedEnv } : {},
+		env: mergedEnv,
 		...mcpServers ? { mcpServers } : {},
-		...disableBuiltinTools ? { tools: [] } : {},
 		...disableThinking ? { thinking: { type: "disabled" } } : {},
 		hooks: onAbAction || onAbActionFailed ? {
 			PreToolUse: [{ hooks: [async (input) => {
@@ -1774,8 +1771,9 @@ function extractInvocationCost(msg) {
 	const usage = m["usage"];
 	const modelUsage = m["modelUsage"];
 	const num = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
+	const models = modelUsage && typeof modelUsage === "object" ? Object.keys(modelUsage) : [];
 	return {
-		totalCostUsd: num(m["total_cost_usd"]),
+		totalCostUsd: pricedForClaude(models) ? num(m["total_cost_usd"]) : null,
 		durationMs: num(m["duration_ms"]),
 		durationApiMs: num(m["duration_api_ms"]),
 		numTurns: num(m["num_turns"]),
@@ -1783,9 +1781,16 @@ function extractInvocationCost(msg) {
 		cacheCreationInputTokens: num(usage?.["cache_creation_input_tokens"]),
 		cacheReadInputTokens: num(usage?.["cache_read_input_tokens"]),
 		outputTokens: num(usage?.["output_tokens"]),
-		models: modelUsage && typeof modelUsage === "object" ? Object.keys(modelUsage) : []
+		models
 	};
 }
+/**
+* The SDK prices an unknown model id at a default Claude rate rather than
+* returning null, so a self-hosted model would report dollars nobody is billed.
+*/
+function pricedForClaude(models) {
+	return models.every((id) => /claude/i.test(id));
+}
 const BLOCKED_AB_SUBCOMMANDS = new Set([
 	"eval",
 	"js",
@@ -5015,12 +5020,11 @@ const DraftNamingSchema = z.object({
 * Returns null only when the invocation reported nothing at all (a mock run,
 * an SDK error, or a command that never called a model).
 *
-* The price is one segment among several, not a precondition. An endpoint the
-* SDK has no pricing table for — any Anthropic-compatible gateway in front of
-* a third-party model — reports usage but no `total_cost_usd`, and dropping
-* the whole line there would hide real consumption behind silence. Tokens come
-* from the API response rather than a price list, so they survive that case
-* and become the signal to read.
+* The price is one segment among several, not a precondition. A model that is
+* not a Claude model has no price (`extractInvocationCost` drops the SDK's
+* estimate), and dropping the whole line there would hide real consumption
+* behind silence. Tokens come from the API response rather than a price list,
+* so they survive that case and become the signal to read.
 *
 * `compact: false` (default for CLI logs) keeps raw numbers and adds a
 * `model=...` segment. `compact: true` (HTML chip) thousand-separates fresh
@@ -11982,6 +11986,14 @@ async function resolveCoverageRoots(changed, cwd) {
 */
 const MAX_REPORT_RUNS = 20;
 /**
+* How many reads one source keeps in flight. The two sources run together, so
+* the hub sees twice this. All at once is what it cannot take: it serves one
+* process, a resolve walks the whole event stream, and a report carries its
+* screenshots inline — forty of those together is what took it down, rather
+* than any single one of them.
+*/
+const HUB_READ_CONCURRENCY = 4;
+/**
 * Read every spec's most recent measured reach from the hub. Never throws: a
 * source that cannot be read warns, and `degraded` flips when the failure
 * leaves absence ambiguous (the ledger itself, or the legacy sources while
@@ -12049,8 +12061,14 @@ async function collectStreamEdges(input, merge) {
 	const { hub, project } = input;
 	const latest = await hub.getCoverage(project);
 	ingestResolved(latest.resolved, merge);
-	const older = latest.runIds.filter((runId) => runId !== latest.resolved?.runId);
-	return (await Promise.allSettled(older.map(async (runId) => ingestResolved((await hub.getCoverage(project, { runId })).resolved, merge)))).filter((r) => r.status === "rejected").length;
+	return (await runPool(latest.runIds.filter((runId) => runId !== latest.resolved?.runId), HUB_READ_CONCURRENCY, async (runId) => {
+		try {
+			ingestResolved((await hub.getCoverage(project, { runId })).resolved, merge);
+			return true;
+		} catch {
+			return false;
+		}
+	})).filter((ok) => !ok).length;
 }
 function ingestResolved(resolved, merge) {
 	if (!resolved) return;
@@ -12082,7 +12100,7 @@ const ReportCoverageRowsSchema = z.object({ results: z.array(z.object({
 */
 async function collectReportEdges(input, merge) {
 	const { hub, project } = input;
-	const eligible = (await hub.listRuns({
+	return (await runPool((await hub.listRuns({
 		project,
 		kind: "run",
 		limit: MAX_REPORT_RUNS
@@ -12094,18 +12112,22 @@ async function collectReportEdges(input, merge) {
 			id: run.id,
 			measuredAt
 		}];
-	});
-	return (await Promise.allSettled(eligible.map(async ({ id, measuredAt }) => {
-		const parsed = ReportCoverageRowsSchema.safeParse(await hub.getReport(id));
-		if (!parsed.success) return;
-		for (const row of parsed.data.results) {
-			if (!row.coverage || row.coverage.files.length === 0) continue;
-			merge(`${row.feature}/${row.spec}`, {
-				files: row.coverage.files,
-				measuredAt
-			});
+	}), HUB_READ_CONCURRENCY, async ({ id, measuredAt }) => {
+		try {
+			const parsed = ReportCoverageRowsSchema.safeParse(await hub.getReport(id));
+			if (!parsed.success) return true;
+			for (const row of parsed.data.results) {
+				if (!row.coverage || row.coverage.files.length === 0) continue;
+				merge(`${row.feature}/${row.spec}`, {
+					files: row.coverage.files,
+					measuredAt
+				});
+			}
+			return true;
+		} catch {
+			return false;
 		}
-	}))).filter((r) => r.status === "rejected").length;
+	})).filter((ok) => !ok).length;
 }
 //#endregion
 //#region src/select/inventory.ts
@@ -12220,6 +12242,27 @@ function foldTouchIndex(current, entry, selection) {
 	}
 	return out;
 }
+//#endregion
+//#region src/coverage/resolve-stream.ts
+/**
+* One run's answer out of a project's stored event stream (ADR-0022).
+*
+* The stream interleaves many runs and two producers; this is the single
+* shared interpretation over it — the same gate, join and loss accounting the
+* run-local sink applies, executed at read time by whichever host asks (the
+* hub's API, or the CLI). Everything here is a pure fold over the stamps the
+* events carry: no clock is ever read, so the same stream resolves to the
+* same answer on any host, at any time.
+*/
+/**
+* How far past a run's last marker an application push still counts as its
+* audience (ms). The run-local sink keeps listening while a spec settles, so
+* the work a spec's last action triggered still lands; a stored stream has no
+* listener to wait, so the resolve re-creates that patience as a fixed bound.
+* Pushes past it were heard by nobody bound to this run — most likely they
+* belong to whatever run came next.
+*/
+const GRACE_MS = 3e4;
 z.object({
 	runId: z.string(),
 	hubRunId: z.string().optional(),
@@ -12257,88 +12300,109 @@ function formatResolvedSpec(spec) {
 	return `${spec.specId}: ${spec.files.length} file(s)${actors ? ` (${actors})` : ""}`;
 }
 /**
-* Interprets `runId`'s view of the stream.
+* `runId`'s view of the stream, built one event at a time.
 *
-* Two passes, because the resolver needs its context up front: the first
+* Two passes, because the resolver needs its context up front. The first
 * collects what the run's own markers establish — which ids it issued, which
 * identity tags were its to hand out, its universe, and when its first and
-* last marker arrived. The second replays the stream through the shared
-* resolver: this run's window markers as they came, and every application
-* push — as-is when its stamp falls inside the span the run's sink would
-* have been listening (first marker to last marker plus `GRACE_MS`),
-* stripped of its spec and actor attribution when it does not. A push
-* outside the span was another run's audience, so its attribution is not
-* this run's to claim — but the collector never re-sends what an earlier
-* run acked, so on an always-on hub the boot set and each process's health
-* figures arrived long before this run began, and only survive here.
-*/
-function resolveStream(events, runId) {
-	const issued = /* @__PURE__ */ new Set();
-	const specOrder = [];
-	const tagToKey = /* @__PURE__ */ new Map();
-	const browserFiles = /* @__PURE__ */ new Map();
-	let universe;
-	let hubRunId;
-	let firstMarkerAt;
-	let lastMarkerAt = 0;
-	for (const event of events) {
-		const body = event.body;
-		if (!("kind" in body) || body.runId !== runId) continue;
-		if (firstMarkerAt === void 0) firstMarkerAt = event.at;
-		lastMarkerAt = event.at;
-		switch (body.kind) {
-			case "spec-open":
-				if (!issued.has(body.specId)) {
-					issued.add(body.specId);
-					specOrder.push(body.specId);
+* last marker arrived; markers are a small part of a stream, so a caller can
+* hold them. The second replays the stream through the shared resolver: this
+* run's window markers as they came, and every application push — as-is when
+* its stamp falls inside the span the run's sink would have been listening
+* (first marker to last marker plus `GRACE_MS`), stripped of its spec and
+* actor attribution when it does not. A push outside the span was another
+* run's audience, so its attribution is not this run's to claim — but the
+* collector never re-sends what an earlier run acked, so on an always-on hub
+* the boot set and each process's health figures arrived long before this run
+* began, and only survive here.
+*
+* The constructor takes the markers and `accept` takes one event at a time, so
+* the second pass can be fed from a stream: it keeps nothing per push, which
+* is what lets a resolve outlive the point where the stream stops fitting in
+* memory.
+*/
+var StreamResolution = class {
+	runId;
+	resolver;
+	/** The ids this run opened, in that order — a `Set` iterates by insertion. */
+	specIds;
+	browserFiles = /* @__PURE__ */ new Map();
+	/**
+	* The stamps in which the run's sink would have been listening. Undefined
+	* when the markers held no event of this run — then no push is ever inside.
+	*/
+	span;
+	universe;
+	hubRunId;
+	asOf = 0;
+	lastSeq = 0;
+	pushesDuringRun = 0;
+	/** `markers` needs to hold every marker event of the stream; pushes are ignored here. */
+	constructor(markers, runId) {
+		this.runId = runId;
+		const specIds = /* @__PURE__ */ new Set();
+		const tagToKey = /* @__PURE__ */ new Map();
+		let firstAt;
+		let lastAt = 0;
+		for (const event of markers) {
+			const body = event.body;
+			if (!("kind" in body) || body.runId !== runId) continue;
+			if (firstAt === void 0) firstAt = event.at;
+			lastAt = event.at;
+			switch (body.kind) {
+				case "spec-open":
+					specIds.add(body.specId);
+					break;
+				case "window-open":
+					tagToKey.set(body.tag, body.key);
+					break;
+				case "universe":
+					this.universe = {
+						include: body.include,
+						files: body.files
+					};
+					break;
+				case "run-link":
+					this.hubRunId = body.hubRunId;
+					break;
+				case "browser": {
+					const files = this.browserFiles.get(body.specId) ?? /* @__PURE__ */ new Set();
+					for (const file of body.files) files.add(file);
+					this.browserFiles.set(body.specId, files);
+					break;
 				}
-				break;
-			case "window-open":
-				tagToKey.set(body.tag, body.key);
-				break;
-			case "universe":
-				universe = {
-					include: body.include,
-					files: body.files
-				};
-				break;
-			case "run-link":
-				hubRunId = body.hubRunId;
-				break;
-			case "browser": {
-				const files = browserFiles.get(body.specId) ?? /* @__PURE__ */ new Set();
-				for (const file of body.files) files.add(file);
-				browserFiles.set(body.specId, files);
-				break;
 			}
 		}
+		this.specIds = specIds;
+		this.span = firstAt === void 0 ? void 0 : {
+			from: firstAt,
+			until: lastAt + GRACE_MS
+		};
+		this.resolver = new CoverageResolver(specIds, tagToKey);
 	}
-	const resolver = new CoverageResolver(issued, tagToKey);
-	let asOf = 0;
-	let lastSeq = 0;
-	let pushesDuringRun = 0;
-	for (const event of events) {
-		if (event.seq > lastSeq) lastSeq = event.seq;
+	/** One event of the second pass. Every event of the stream, in stamp order. */
+	accept(event) {
+		if (event.seq > this.lastSeq) this.lastSeq = event.seq;
 		const body = event.body;
 		if ("kind" in body) {
-			if (body.runId !== runId) continue;
-			asOf = event.at;
-			if (body.kind === "window-open") resolver.apply({
+			if (body.runId !== this.runId) return;
+			this.asOf = event.at;
+			if (body.kind === "window-open") this.resolver.apply({
 				kind: "window-open",
 				at: event.at,
 				tag: body.tag,
 				key: body.key,
 				specId: body.specId
 			});
-			else if (body.kind === "window-close") resolver.apply({
+			else if (body.kind === "window-close") this.resolver.apply({
 				kind: "window-close",
 				at: event.at,
 				tag: body.tag
 			});
-			continue;
+			return;
 		}
-		if (firstMarkerAt === void 0 || event.at < firstMarkerAt || event.at > lastMarkerAt + 3e4) {
-			resolver.apply({
+		if (this.span === void 0 || event.at < this.span.from || event.at > this.span.until) {
+			this.resolver.apply({
 				kind: "push",
 				at: event.at,
 				push: {
@@ -12347,49 +12411,52 @@ function resolveStream(events, runId) {
 					actors: []
 				}
 			});
-			continue;
+			return;
 		}
-		asOf = event.at;
-		pushesDuringRun++;
-		resolver.apply({
+		this.asOf = event.at;
+		this.pushesDuringRun++;
+		this.resolver.apply({
 			kind: "push",
 			at: event.at,
 			push: body
 		});
 	}
-	const specs = specOrder.map((specId) => {
-		const actorEvents = {};
-		for (const [key, count] of resolver.actorEventsFor(specId)) actorEvents[key] = count;
+	/** The answer as of every event accepted so far. */
+	finish() {
+		const specs = [...this.specIds].map((specId) => {
+			const actorEvents = {};
+			for (const [key, count] of this.resolver.actorEventsFor(specId)) actorEvents[key] = count;
+			return {
+				specId,
+				files: [...new Set([...this.resolver.filesFor(specId) ?? [], ...this.browserFiles.get(specId) ?? []])].sort(),
+				actorEvents
+			};
+		});
+		const outsideWindowEvents = {};
+		for (const [key, count] of this.resolver.outsideWindowEvents()) outsideWindowEvents[key] = count;
 		return {
-			specId,
-			files: [...new Set([...resolver.filesFor(specId) ?? [], ...browserFiles.get(specId) ?? []])].sort(),
-			actorEvents
+			runId: this.runId,
+			...this.hubRunId !== void 0 ? { hubRunId: this.hubRunId } : {},
+			asOf: this.asOf,
+			lastSeq: this.lastSeq,
+			...this.universe !== void 0 ? { universe: this.universe } : {},
+			specs,
+			boot: [...this.resolver.boot()].sort(),
+			health: {
+				heardFromApplication: this.resolver.heardFromApplication(),
+				pushesDuringRun: this.pushesDuringRun,
+				attributedSpecs: this.resolver.attributedSpecs(),
+				rejectedPushes: this.resolver.rejectedPushes(),
+				uninstrumentedFiles: this.resolver.uninstrumentedFiles(),
+				uninstrumentedProcesses: this.resolver.uninstrumentedProcesses(),
+				droppedPushes: this.resolver.droppedPushes(),
+				unmappedActorEvents: this.resolver.unmappedActorEvents(),
+				outsideWindowEvents,
+				specsMeasured: specs.length
+			}
 		};
-	});
-	const outsideWindowEvents = {};
-	for (const [key, count] of resolver.outsideWindowEvents()) outsideWindowEvents[key] = count;
-	return {
-		runId,
-		...hubRunId !== void 0 ? { hubRunId } : {},
-		asOf,
-		lastSeq,
-		...universe !== void 0 ? { universe } : {},
-		specs,
-		boot: [...resolver.boot()].sort(),
-		health: {
-			heardFromApplication: resolver.heardFromApplication(),
-			pushesDuringRun,
-			attributedSpecs: resolver.attributedSpecs(),
-			rejectedPushes: resolver.rejectedPushes(),
-			uninstrumentedFiles: resolver.uninstrumentedFiles(),
-			uninstrumentedProcesses: resolver.uninstrumentedProcesses(),
-			droppedPushes: resolver.droppedPushes(),
-			unmappedActorEvents: resolver.unmappedActorEvents(),
-			outsideWindowEvents,
-			specsMeasured: specs.length
-		}
-	};
-}
+	}
+};
 /**
 * Every run that opened a spec in this stream, most recently heard-from
 * first — recency by the arrival position of each run's latest spec-open,
@@ -13529,7 +13596,6 @@ async function runLiveExecutor(input) {
 				prompt: buildStepVerdictPrompt(step, transcript),
 				model: input.model,
 				allowedTools: [],
-				disableBuiltinTools: true,
 				disableThinking: true,
 				maxTurns: 1,
 				timeoutMs: VERDICT_TIMEOUT_MS
@@ -14704,7 +14770,7 @@ async function cleanupActions$1(actions, model) {
 	try {
 		const { result, isError } = await invokeClaudeStreaming({
 			prompt: buildCleanupPrompt(actions),
-			disableBuiltinTools: true,
+			allowedTools: [],
 			maxTurns: 1,
 			model
 		}, () => {});
@@ -16633,7 +16699,6 @@ async function updateAgentPrompt(args) {
 			prompt: userPrompt,
 			systemPrompt,
 			allowedTools: [],
-			disableBuiltinTools: true,
 			disableThinking: true,
 			...model ? { model } : {}
 		}, () => {});
@@ -23430,7 +23495,9 @@ function createAppendCoverageEventHandler(config) {
 }
 /**
 * GET /api/v1/coverage/events?project=&sinceSeq= — the stream after `sinceSeq`
-* (exclusive, so a consumer passes back the `lastSeq` it saw), decrypted.
+* (exclusive), decrypted, at most `MAX_EVENTS_PER_READ` of them. A consumer
+* passes back the `seq` of the last event it received; `lastSeq` is the
+* stream's head, which `truncated` says the body stopped short of.
 * Hub bearer token only (the server's central check): what the append-only
 * credential wrote, it must not be able to read back.
 */
@@ -23439,33 +23506,51 @@ function createGetCoverageEventsHandler(config) {
 		const key = requireKey(config);
 		const project = requireProjectParam(ctx);
 		const sinceSeq = requireSinceSeqParam(ctx.url);
-		sendJson(ctx.res, 200, await readStream(config, key, project, sinceSeq));
+		const events = [];
+		let truncated = false;
+		const { lastSeq, skipped } = await scanStream(config, key, project, sinceSeq, (event) => {
+			if (events.length < MAX_EVENTS_PER_READ) events.push(event);
+			else truncated = true;
+		});
+		sendJson(ctx.res, 200, {
+			events,
+			lastSeq,
+			skipped,
+			truncated
+		});
 	};
 }
-/** The stored stream after `sinceSeq` (exclusive), decrypted and parsed. */
-async function readStream(config, key, project, sinceSeq) {
-	const { entries, lastSeq, skipped } = await config.store.read(project, sinceSeq);
-	const events = [];
+/**
+* Hand each event after `sinceSeq` (exclusive) to `visit`, decrypted and
+* parsed. Nothing is retained here: what a caller keeps is its own choice,
+* which is what lets a whole-stream read stay bounded.
+*/
+async function scanStream(config, key, project, sinceSeq, visit) {
 	let unreadable = 0;
-	for (const entry of entries) try {
-		const plain = decrypt(decodeEncryptedBlob(entry.payload), key);
-		const body = InboxBodySchema.parse(JSON.parse(new TextDecoder().decode(plain)));
-		events.push({
-			seq: entry.seq,
-			at: entry.at,
-			body
-		});
-	} catch {
-		unreadable += 1;
-	}
+	const { lastSeq, skipped } = await config.store.scan(project, sinceSeq, (entry) => {
+		let event;
+		try {
+			const plain = decrypt(decodeEncryptedBlob(entry.payload), key);
+			event = {
+				seq: entry.seq,
+				at: entry.at,
+				body: InboxBodySchema.parse(JSON.parse(new TextDecoder().decode(plain)))
+			};
+		} catch {
+			unreadable += 1;
+			return;
+		}
+		visit(event);
+	});
 	return {
-		events,
 		lastSeq,
 		skipped: skipped + unreadable
 	};
 }
 /** Newest runs the resolve read offers; past twenty the answer is history nobody pages through. */
 const RUN_IDS_LIMIT = 20;
+/** How many events one `GET /events` body carries; past it the answer is `truncated`. */
+const MAX_EVENTS_PER_READ = 5e3;
 /** Resolved answers kept per handler; one page polls one key, so a handful covers the readers. */
 const RESOLVE_CACHE_LIMIT = 8;
 /**
@@ -23522,14 +23607,27 @@ function createResolveCoverageHandler(config) {
 			sendJson(ctx.res, 200, hit);
 			return;
 		}
-		const { events, lastSeq } = await readStream(config, key, project, 0);
-		const runIds = listRunIds(events).slice(0, RUN_IDS_LIMIT);
+		const markers = [];
+		let seen = 0;
+		const first = await scanStream(config, key, project, 0, (event) => {
+			seen += 1;
+			if ("kind" in event.body) markers.push(event);
+		});
+		const runIds = listRunIds(markers).slice(0, RUN_IDS_LIMIT);
 		const runId = runKey !== "" ? runKey : runIds[0];
+		let resolved = null;
+		if (runId !== void 0 && seen > 0) {
+			const resolution = new StreamResolution(markers, runId);
+			await scanStream(config, key, project, 0, (event) => {
+				if (event.seq <= first.lastSeq) resolution.accept(event);
+			});
+			resolved = resolution.finish();
+		}
 		const answer = {
-			resolved: runId === void 0 || events.length === 0 ? null : resolveStream(events, runId),
+			resolved,
 			runIds
 		};
-		memo.put(project, runKey, lastSeq, answer);
+		memo.put(project, runKey, first.lastSeq, answer);
 		sendJson(ctx.res, 200, answer);
 	};
 }
@@ -30613,7 +30711,6 @@ function createLearningWorker(deps) {
 			prompt: buildLearningUserPrompt(cases.slice(0, LEARNING_MAX_CASES)),
 			systemPrompt: LEARNING_SYSTEM_PROMPT,
 			allowedTools: [],
-			disableBuiltinTools: true,
 			maxTurns: 1
 		}, () => {});
 		const guidance = result?.trim();
@@ -31167,7 +31264,7 @@ function createFileCoverageEventStore(root, caps) {
 			oldestAt: null,
 			endsWithNewline: raw === "" || raw.endsWith("\n")
 		};
-		for (const rawLine of nonEmptyLines(raw)) {
+		for (const rawLine of raw.split("\n")) {
 			const line = parseLine(rawLine);
 			if (line === null) continue;
 			if (line.seq >= state.nextSeq) state.nextSeq = line.seq + 1;
@@ -31223,19 +31320,17 @@ function createFileCoverageEventStore(root, caps) {
 				return stamp;
 			});
 		},
-		async read(project, sinceSeq) {
+		async scan(project, sinceSeq, visit) {
 			assertSafeName(project, "project");
 			const path = coverageEventsPath(root, project);
 			const now = Date.now();
 			await serialize(path, async () => {
 				await pruneIfDue(project, path, await loadState(project, path), now);
 			});
-			const raw = await readRaw(path);
 			const cutoff = now - retentionMs;
-			const entries = [];
 			let lastSeq = 0;
 			let skipped = 0;
-			for (const rawLine of nonEmptyLines(raw)) {
+			for await (const rawLine of streamLines(path)) {
 				const line = parseLine(rawLine);
 				if (line === null) {
 					skipped += 1;
@@ -31244,15 +31339,13 @@ function createFileCoverageEventStore(root, caps) {
 				if (line.seq > lastSeq) lastSeq = line.seq;
 				if (line.seq <= sinceSeq) continue;
 				if (line.at < cutoff) continue;
-				entries.push({
+				visit({
 					seq: line.seq,
 					at: line.at,
 					payload: new Uint8Array(Buffer.from(line.payload, "base64"))
 				});
 			}
-			entries.sort((a, b) => a.seq - b.seq);
 			return {
-				entries,
 				lastSeq,
 				skipped
 			};
@@ -31283,13 +31376,31 @@ async function readRaw(path) {
 		throw err;
 	}
 }
-function nonEmptyLines(raw) {
-	return raw.split("\n").filter((l) => l !== "");
+/**
+* The stream's non-empty lines, one at a time. Streamed rather than read as one
+* string because a project's stream is capped in the hundreds of megabytes, far
+* past what a reader can hold. Order is the file's, which is append order,
+* which is seq order — the prune rewrites a suffix and never reorders.
+*/
+async function* streamLines(path) {
+	const input = createReadStream(path, { encoding: "utf8" });
+	const lines = createInterface$1({
+		input,
+		crlfDelay: Infinity
+	});
+	try {
+		for await (const line of lines) if (line !== "") yield line;
+	} catch (err) {
+		if (!(err instanceof Error && "code" in err && err.code === "ENOENT")) throw err;
+	} finally {
+		lines.close();
+		input.destroy();
+	}
 }
 /** Every parseable line of the log; partial or corrupt lines are silently omitted (the read side counts them). */
 async function readLines(path) {
 	const lines = [];
-	for (const rawLine of nonEmptyLines(await readRaw(path))) {
+	for await (const rawLine of streamLines(path)) {
 		const line = parseLine(rawLine);
 		if (line !== null) lines.push(line);
 	}

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccqa",
-  "version": "1.42.2",
+  "version": "1.44.0",
   "type": "module",
   "description": "Browser test recorder powered by Claude Code and agent-browser",
   "repository": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccqa",
-  "version": "1.42.2",
+  "version": "1.44.0",
   "type": "module",
   "description": "Browser test recorder powered by Claude Code and agent-browser",
   "repository": {