ccqa 1.48.2 → 1.50.0

package/dist/bin/ccqa.mjs

@@ -23,6 +23,7 @@ import { connect as connect$1 } from "node:tls";
 import { gunzipSync, gzipSync } from "node:zlib";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { createInterface as createInterface$1 } from "node:readline";
+import { pipeline } from "node:stream/promises";
 //#region src/run/report-constants.ts
 /**
 * Pure report/run constants with no runtime dependencies. Kept separate from
@@ -1501,6 +1502,8 @@ const ReportSpecResultSchema = z.object({
 		failed: z.number()
 	}).nullable(),
 	durationMs: z.number().nullable(),
+	startedAt: z.string().optional(),
+	finishedAt: z.string().optional(),
 	assertions: z.array(ReportAssertionSchema).nullable(),
 	analysis: FailureAnalysisSchema.nullable(),
 	analysisSkipped: z.string().nullable(),
@@ -6197,6 +6200,7 @@ async function runOneSpec$1(ref, opts, blocks) {
 	meta("command", command);
 	blank();
 	const started = Date.now();
+	const startedAt = new Date(started).toISOString();
 	let outcome;
 	let spawnFailure;
 	let measured;
@@ -6217,6 +6221,7 @@ async function runOneSpec$1(ref, opts, blocks) {
 	const coverageFields = coverageRowFields(opts, measured, attachError);
 	if (spawnFailure !== void 0 || outcome === void 0) return {
 		...didNotExecute(`could not spawn runCommand: ${spawnFailure ?? "unknown error"}`, "the runCommand could not be spawned"),
+		startedAt,
 		...coverageFields
 	};
 	const durationMs = Date.now() - started;
@@ -6243,6 +6248,8 @@ async function runOneSpec$1(ref, opts, blocks) {
 			status: "passed"
 		}),
 		target: opts.targetId,
+		startedAt,
+		finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
 		durationMs,
 		...artifactFields,
 		...evidenceFields,
@@ -6250,6 +6257,8 @@ async function runOneSpec$1(ref, opts, blocks) {
 	};
 	return {
 		...failedRow([`command failed (exit ${outcome.exitCode}): ${command}`, outcome.tail.length > 0 ? `--- output (tail) ---\n${outcome.tail}` : null].filter((p) => p !== null).join("\n")),
+		startedAt,
+		finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
 		durationMs,
 		...artifactFields,
 		...evidenceFields,
@@ -10188,6 +10197,36 @@ function foldTouchIndex(current, entry, selection) {
 	}
 	return out;
 }
+/**
+* How much clock skew between the runner (which stamps a row's window) and
+* the hub (which stamps a deploy) the placement tolerates. The window is
+* widened by this on both ends, so a skewed clock costs a row its credit
+* rather than crediting a row that straddled.
+*/
+const PLACEMENT_SKEW_MS = 1e4;
+/**
+* Place one row's execution window against the deploy log (ADR-0027).
+*
+* The window is widened by {@link PLACEMENT_SKEW_MS} and its start is
+* exclusive, so a deploy landing exactly as the spec began reads as a
+* straddle. Both choices err the same way: toward `ambiguous`, never toward
+* crediting a spec with a commit it may not have exercised.
+*
+* `entries` must be in append order, which the log guarantees and which is
+* time order.
+*/
+function placeRowInDeployLog(entries, window) {
+	const before = (ms, inclusive) => entries.findLast((e) => {
+		const at = Date.parse(e.at);
+		return inclusive ? at <= ms : at < ms;
+	});
+	const opened = before(window.startMs - PLACEMENT_SKEW_MS, false);
+	const closed = before(Math.max(window.startMs, window.endMs) + PLACEMENT_SKEW_MS, true);
+	return {
+		deployedSha: opened?.sha ?? null,
+		deployedShaAmbiguous: opened?.sha !== closed?.sha
+	};
+}
 //#endregion
 //#region src/coverage/resolve-stream.ts
 /**
@@ -11773,6 +11812,8 @@ async function liveRunToReportResult(args) {
 		target: AGENT_BROWSER_TARGET,
 		status: result.status,
 		testCounts: null,
+		startedAt: result.startedAt,
+		finishedAt: new Date(Date.parse(result.startedAt) + result.durationMs).toISOString(),
 		durationMs: result.durationMs,
 		assertions: null,
 		analysis: null,
@@ -15728,6 +15769,7 @@ async function runOneDeterministicSpec(spec, index, ctx) {
 		CCQA_RUN_ID: runId
 	};
 	if (evidenceDir) specEnv[EVIDENCE_DIR_ENV] = evidenceDir;
+	const startedAt = (/* @__PURE__ */ new Date()).toISOString();
 	const proc = spawnVitestStreaming([
 		"run",
 		"--config",
@@ -15744,11 +15786,14 @@ async function runOneDeterministicSpec(spec, index, ctx) {
 	await Promise.all([streamFiltered(proc.stdout, sink, tail), streamFiltered(proc.stderr, sink, tail)]);
 	const specExitCode = await proc.exited;
 	blank();
+	const report = await readReport$1(reportFile);
 	return {
 		featureName,
 		specName,
 		scriptFile,
-		report: await readReport$1(reportFile),
+		startedAt,
+		finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		report,
 		exitCode: specExitCode,
 		outputTail: tail ? tail.toString() : null,
 		evidenceDir
@@ -15777,6 +15822,8 @@ async function analyzeDeterministicSummaries(summaries, cwd, reportDir, { pass,
 			spec: s.specName,
 			title: parsedSpec?.title ?? null,
 			target: AGENT_BROWSER_TARGET,
+			startedAt: s.startedAt,
+			finishedAt: s.finishedAt,
 			testCounts: s.report ? {
 				total: s.report.numTotalTests,
 				passed: s.report.numPassedTests,
@@ -20185,17 +20232,20 @@ function countSpecs(results) {
 async function updateSpecLedger(storage, run, results) {
 	const { gitHead, branch } = run;
 	if (run.kind !== "run" || !gitHead || !branch) return;
-	const entry = {
+	const placeRow = await rowDeployPlacer(storage, run);
+	const base = {
 		gitHead,
 		runId: run.id,
-		at: run.reportCreatedAt,
-		deployedSha: run.deployedSha ?? null,
-		deployedShaAmbiguous: run.deployedShaAmbiguous ?? false
+		at: run.reportCreatedAt
 	};
 	const ledger = emptyLedger();
 	for (const row of results) {
 		if (row.status === "skipped") continue;
 		const key = `${row.feature}/${row.spec}`;
+		const entry = {
+			...base,
+			...placeRow(row)
+		};
 		ledger.run[key] = entry;
 		if (row.status === "passed") ledger.green[key] = entry;
 		else ledger.red[key] = redEntry(entry, row);
@@ -20298,6 +20348,38 @@ async function resolveDeployedSha(storage, kind, project, profile, explicit) {
 	};
 }
 /**
+* Place each row against the deploy log by its own execution window rather
+* than the run's (ADR-0027), so a run that outlives a deploy loses only the
+* specs that straddled it.
+*
+* Falls back to the run's placement where a finer answer isn't available: a
+* client-asserted sha is the caller's claim about its whole run, and a row
+* with no `startedAt` (an older client) has nothing finer to say. A row with
+* no end is measured to now, which only widens its window.
+*/
+async function rowDeployPlacer(storage, run) {
+	const runPlacement = {
+		deployedSha: run.deployedSha ?? null,
+		deployedShaAmbiguous: run.deployedShaAmbiguous ?? false
+	};
+	if (run.deployedShaSource !== "hub-deploy-log") return () => runPlacement;
+	const log = await storage.deploys.getLog(run.project, run.profile ?? "default").catch((err) => {
+		console.error(`hub: could not read the deploy log to place rows of run "${run.id}": ${errMsg(err)}`);
+		return null;
+	});
+	if (!log) return () => runPlacement;
+	const sealedAt = Date.now();
+	return (row) => {
+		const startMs = row.startedAt ? Date.parse(row.startedAt) : NaN;
+		if (Number.isNaN(startMs)) return runPlacement;
+		const endMs = row.finishedAt ? Date.parse(row.finishedAt) : sealedAt;
+		return placeRowInDeployLog(log.entries, {
+			startMs,
+			endMs: Number.isNaN(endMs) ? sealedAt : endMs
+		});
+	};
+}
+/**
 * True when the deploy-log head moved while the run was open: the run
 * straddled a deploy, so which commit it exercised is not knowable and re-run
 * selection must report `unknown` instead of picking one. Only meaningful for
@@ -29403,7 +29485,7 @@ const PRUNE_AGE_SLACK_MS = 3600 * 1e3;
 * event per line, appended in place (not atomic-rewritten — an append must
 * not cost the whole stream). A reader can therefore observe a partial final
 * line mid-append; the read side counts such lines as skipped rather than
-* failing, and the prune's full rewrite goes through the atomic path.
+* failing, and the prune's full rewrite goes through a temp file + rename.
 */
 function createFileCoverageEventStore(root, caps) {
 	const maxEvents = caps?.maxEvents ?? 2e5;
@@ -29415,15 +29497,15 @@ function createFileCoverageEventStore(root, caps) {
 	async function loadState(project, path) {
 		const cached = states.get(project);
 		if (cached) return cached;
-		const raw = await readRaw(path);
+		const tail = await statTail(path);
 		const state = {
 			nextSeq: 1,
 			count: 0,
-			bytes: Buffer.byteLength(raw),
+			bytes: tail?.size ?? 0,
 			oldestAt: null,
-			endsWithNewline: raw === "" || raw.endsWith("\n")
+			endsWithNewline: tail?.endsWithNewline ?? true
 		};
-		for (const rawLine of raw.split("\n")) {
+		for await (const rawLine of streamLines(path)) {
 			const line = parseLine(rawLine);
 			if (line === null) continue;
 			if (line.seq >= state.nextSeq) state.nextSeq = line.seq + 1;
@@ -29438,18 +29520,39 @@ function createFileCoverageEventStore(root, caps) {
 		const overBytes = state.bytes > maxBytes;
 		const overAge = state.oldestAt !== null && state.oldestAt < now - retentionMs - PRUNE_AGE_SLACK_MS;
 		if (!overCount && !overBytes && !overAge) return;
-		const lines = await readLines(path);
 		const cutoff = now - retentionMs;
-		const fresh = lines.filter((l) => l.at >= cutoff);
+		const freshSizes = [];
+		for await (const line of streamFreshLines(path, cutoff)) freshSizes.push(Buffer.byteLength(JSON.stringify(line)) + 1);
 		const keep = overCount ? Math.max(0, maxEvents - pruneBatch) : maxEvents;
-		let kept = fresh.length > keep ? fresh.slice(fresh.length - keep) : fresh;
-		if (overBytes) kept = newestWithinBytes(kept, pruneBytesTarget);
-		const encoded = new TextEncoder().encode(kept.map((l) => JSON.stringify(l)).join("\n") + (kept.length > 0 ? "\n" : ""));
-		await writeBytes(path, encoded);
-		const dropped = state.count - kept.length;
-		state.count = kept.length;
-		state.bytes = encoded.byteLength;
-		state.oldestAt = kept[0]?.at ?? null;
+		let firstKept = freshSizes.length > keep ? freshSizes.length - keep : 0;
+		if (overBytes) firstKept = firstWithinBytes(freshSizes, firstKept, pruneBytesTarget);
+		await mkdir(dirname(path), { recursive: true });
+		const tmp = `${path}.${randomUUID()}.tmp`;
+		let keptCount = 0;
+		let keptBytes = 0;
+		let oldestKeptAt = null;
+		try {
+			await pipeline(async function* () {
+				let freshIdx = 0;
+				for await (const line of streamFreshLines(path, cutoff)) {
+					freshIdx += 1;
+					if (freshIdx <= firstKept) continue;
+					const text = JSON.stringify(line) + "\n";
+					keptCount += 1;
+					keptBytes += Buffer.byteLength(text);
+					if (oldestKeptAt === null) oldestKeptAt = line.at;
+					yield text;
+				}
+			}, createWriteStream(tmp, { encoding: "utf8" }));
+		} catch (err) {
+			await rm(tmp, { force: true });
+			throw err;
+		}
+		await rename(tmp, path);
+		const dropped = state.count - keptCount;
+		state.count = keptCount;
+		state.bytes = keptBytes;
+		state.oldestAt = oldestKeptAt;
 		state.endsWithNewline = true;
 		if (dropped > 0) console.warn(`hub: coverage inbox for "${project}": dropped ${dropped} events past retention (${maxEvents} events / ${Math.round(maxBytes / 1048576)} MiB / ${Math.round(retentionMs / 864e5)} days)`);
 	}
@@ -29518,22 +29621,46 @@ function createFileCoverageEventStore(root, caps) {
 		}
 	};
 }
-/** The longest tail of `lines` whose serialized size (newlines included) fits in `budget`. */
-function newestWithinBytes(lines, budget) {
-	let total = 0;
-	for (let i = lines.length - 1; i >= 0; i -= 1) {
-		total += Buffer.byteLength(JSON.stringify(lines[i])) + 1;
-		if (total > budget) return lines.slice(i + 1);
-	}
-	return lines;
-}
-async function readRaw(path) {
+/** Size and trailing-newline state of the stream file, or null when it doesn't exist. */
+async function statTail(path) {
+	let fh;
 	try {
-		return await readFile(path, "utf8");
+		fh = await open(path, "r");
 	} catch (err) {
-		if (err instanceof Error && "code" in err && err.code === "ENOENT") return "";
+		if (isNotFound(err)) return null;
 		throw err;
 	}
+	try {
+		const { size } = await fh.stat();
+		if (size === 0) return {
+			size,
+			endsWithNewline: true
+		};
+		const tail = Buffer.alloc(1);
+		await fh.read(tail, 0, 1, size - 1);
+		return {
+			size,
+			endsWithNewline: tail[0] === 10
+		};
+	} finally {
+		await fh.close();
+	}
+}
+/** Retention-window lines only, in file order (= append order = seq order). */
+async function* streamFreshLines(path, cutoff) {
+	for await (const rawLine of streamLines(path)) {
+		const line = parseLine(rawLine);
+		if (line !== null && line.at >= cutoff) yield line;
+	}
+}
+/** Start of the longest suffix of `sizes` that fits `budget` (never below `lower`). */
+function firstWithinBytes(sizes, lower, budget) {
+	let total = 0;
+	for (let i = sizes.length - 1; i >= lower; i -= 1) {
+		total += sizes[i];
+		if (total > budget) return i + 1;
+	}
+	return lower;
 }
 /**
 * The stream's non-empty lines, one at a time. Streamed rather than read as one
@@ -29550,21 +29677,12 @@ async function* streamLines(path) {
 	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;
+		if (!isNotFound(err)) 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 await (const rawLine of streamLines(path)) {
-		const line = parseLine(rawLine);
-		if (line !== null) lines.push(line);
-	}
-	return lines;
-}
 function parseLine(rawLine) {
 	let value;
 	try {

package/dist/hub-client/index.d.mts

@@ -655,6 +655,8 @@ declare const ReportSpecResultSchema: z.ZodObject<{
     failed: z.ZodNumber;
   }, z.core.$strip>>;
   durationMs: z.ZodNullable<z.ZodNumber>;
+  startedAt: z.ZodOptional<z.ZodString>;
+  finishedAt: z.ZodOptional<z.ZodString>;
   assertions: z.ZodNullable<z.ZodArray<z.ZodObject<{
     name: z.ZodString;
     status: z.ZodEnum<{
@@ -869,6 +871,8 @@ declare const RunReportDataSchema: z.ZodObject<{
       failed: z.ZodNumber;
     }, z.core.$strip>>;
     durationMs: z.ZodNullable<z.ZodNumber>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    finishedAt: z.ZodOptional<z.ZodString>;
     assertions: z.ZodNullable<z.ZodArray<z.ZodObject<{
       name: z.ZodString;
       status: z.ZodEnum<{

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccqa",
-  "version": "1.48.2",
+  "version": "1.50.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.48.2",
+  "version": "1.50.0",
   "type": "module",
   "description": "Browser test recorder powered by Claude Code and agent-browser",
   "repository": {