ccqa 1.22.0 → 1.24.0

package/dist/bin/ccqa.mjs

@@ -4556,6 +4556,7 @@ const PerspectiveSpecSchema = z.object({
 	testCondition: z.string().optional(),
 	preconditions: z.array(z.string().min(1)).optional(),
 	status: PerspectiveStatusSchema,
+	changedAt: z.string().optional(),
 	note: z.string().optional()
 }).strip();
 const PerspectiveFeatureSchema = z.object({
@@ -7038,6 +7039,7 @@ const SpecRerunSchema = z.object({
 	driftLabel: DriftLabelSchema.exclude(["UNKNOWN"]).optional(),
 	auditAssumedReached: RerunUnknownReasonSchema.optional(),
 	executionAssumedReached: RerunUnknownReasonSchema.optional(),
+	specChangedSince: z.string().optional(),
 	heldBy: SpecLockSchema.nullable(),
 	lastRun: SpecLedgerEntrySchema.nullable(),
 	lastGreen: SpecLedgerEntrySchema.nullable(),
@@ -15315,16 +15317,18 @@ const DEFAULT_CONCURRENCY$1 = 3;
 * `cli/run` calls this with just the failing specs after vitest.
 */
 async function analyzeDrift(input) {
-	const { targets, cwd, blocks, concurrency = DEFAULT_CONCURRENCY$1, model, language, guidance, onSpecStart } = input;
+	const { targets, cwd, blocks, concurrency = DEFAULT_CONCURRENCY$1, model, language, guidance, onSpecStart, onSpecDone } = input;
 	return runPool(targets, concurrency, async (target) => {
 		onSpecStart?.(target);
-		return checkSpec(target, {
+		const result = await checkSpec(target, {
 			cwd,
 			blocks,
 			model,
 			language,
 			guidance
 		});
+		await onSpecDone?.(result);
+		return result;
 	});
 }
 async function checkSpec(target, opts) {
@@ -15513,37 +15517,35 @@ function specStatus(result, threshold) {
 	return "passed";
 }
 /**
-* Adapts `ccqa audit` results into the shared RunReportData shape so they can
-* be pushed to the hub (`ccqa audit --report-to-hub`) and rendered by the same report
-* UI as `ccqa run`/`ccqa live`. Browser-execution fields (testCounts,
-* evidence, liveRun, ...) don't apply to a drift audit and are always null —
-* which is why `mode` is carried separately: nothing ran, but which surfaces
-* were audited is still a fact about the row.
+* One audited spec as a report row. Browser-execution fields don't apply to an
+* audit and stay empty — which is why `mode` is carried separately: nothing
+* ran, but which surfaces were audited is still a fact about the row. The
+* diagnosis goes into `analysis` because for a `kind: "drift"` report the
+* diagnosis IS the row's verdict, so it renders through the same card a failed
+* `ccqa run` spec does.
 *
-* Each result's diagnosis goes into `analysis`: for a `kind: "drift"` report
-* the diagnosis IS the row's verdict, so it renders through the same diagnosis
-* card a failed `ccqa run` spec does. `reasoning` has no drift-audit
-* equivalent (the audit gives one headline, not a deliberation) so it is
-* filled with an empty string to satisfy `FailureAnalysisSchema`.
+* Shared by the incremental push and the final report: the hub upserts by
+* feature/spec, so two mappings would let the closing patch rewrite history.
 */
-function driftResultsToReport(results, meta) {
-	const specResults = results.map((result) => ({
-		feature: result.target.featureName,
-		spec: result.target.specName,
-		title: result.title ?? null,
+function driftResultToRow(result, threshold) {
+	return {
+		...emptySpecRow({
+			feature: result.target.featureName,
+			spec: result.target.specName,
+			title: result.title ?? null,
+			status: specStatus(result, threshold)
+		}),
 		...result.live === void 0 ? {} : { mode: result.live ? "live" : "deterministic" },
-		status: specStatus(result, meta.threshold),
-		testCounts: null,
-		durationMs: null,
-		assertions: null,
-		analysis: result.drift ? result.drift : null,
-		analysisSkipped: null,
-		failureLogExcerpt: null,
-		diffExcerpt: null,
-		specYaml: null,
-		evidence: null,
-		liveRun: null
-	}));
+		analysis: result.drift ?? null
+	};
+}
+/**
+* Adapts `ccqa audit` results into the shared RunReportData shape so they can
+* be pushed to the hub (`ccqa audit --report-to-hub`) and rendered by the same
+* report UI as `ccqa run`/`ccqa live`.
+*/
+function driftResultsToReport(results, meta) {
+	const specResults = results.map((result) => driftResultToRow(result, meta.threshold));
 	return {
 		schemaVersion: 1,
 		kind: "drift",
@@ -15823,8 +15825,13 @@ async function runAudit(specPath, opts) {
 	requireReportToHubConnection(opts);
 	let results;
 	let promptCtx;
+	let push = null;
 	try {
 		promptCtx = await resolveAuditPromptContext(opts, cwd);
+		if (opts.reportToHub) {
+			push = await openDriftPush(opts, cwd);
+			if (format === "text") info(`hub: incremental drift run opened (${push.runId})`);
+		}
 		results = await analyzeDrift({
 			targets,
 			cwd,
@@ -15835,16 +15842,18 @@ async function runAudit(specPath, opts) {
 			guidance: promptCtx.guidance,
 			onSpecStart: (t) => {
 				if (format === "text") info(`checking ${t.featureName}/${t.specName}`);
+			},
+			onSpecDone: async (r) => {
+				if (push) await sendDriftRow(push, r, threshold);
 			}
 		});
 	} finally {
 		if (holder) await releaseSpecs(hub, hubProject, opts.hubProfile, holder);
 	}
 	process.stdout.write(renderDrift(results, format, cwd));
-	if (opts.reportToHub) await pushDriftResults({
+	if (push) await sealDriftPush(push, {
 		results,
 		threshold,
-		cwd,
 		opts,
 		format,
 		baseRef,
@@ -15893,59 +15902,92 @@ function requireReportToHubConnection(opts) {
 	process.exit(2);
 }
 /**
-* Push a finished drift audit to a ccqa hub as a `kind: "drift"` run, so it
-* shows up alongside `ccqa run` runs in the hub UI. A missing hub connection
-* is a usage error, not a silent skip — a CI job that asked to publish and
-* did not must say so.
+* Open the drift run this sweep patches into. A failure here is fatal, as it
+* is for `ccqa run`: a job that asked to publish and cannot reach the hub has
+* not done what it was told, and the audit has no local artifact to fall back
+* on — the hub is its only output. Raised before any spec is checked, so
+* nothing is wasted. Not retried: a dropped response after the hub committed
+* would leave a second orphan running run.
 *
-* `resolveHub` is injectable so tests can supply a fake `HubClient` without
-* a real hub connection; it defaults to the real flag/env resolution.
+* `resolveHub` is injectable for tests.
 */
-async function pushDriftResults(args, resolveHub = resolveHubClient) {
-	const { results, threshold, cwd, opts, format, baseRef, promptCtx } = args;
+async function openDriftPush(opts, cwd, resolveHub = resolveHubClient) {
 	const hub = resolveHub(opts);
-	if (!hub) {
-		error("--report-to-hub requires a hub connection (--hub-url/--hub-token or CCQA_HUB_URL/CCQA_HUB_TOKEN)");
-		process.exit(2);
+	if (!hub) throw new RunUsageError("--report-to-hub requires a hub connection (--hub-url/--hub-token or CCQA_HUB_URL/CCQA_HUB_TOKEN)");
+	const project = resolveProject({
+		project: opts.project,
+		cwd
+	});
+	const [branch, gitHead] = await Promise.all([detectBranch(cwd), getGitHead(cwd)]);
+	const ciRunId = githubRunId();
+	const runUrl = githubRunUrl();
+	try {
+		return {
+			hub,
+			runId: (await hub.openRun({
+				project,
+				kind: "drift",
+				...branch ? { branch } : {},
+				...opts.hubProfile ? { profile: opts.hubProfile } : {},
+				...gitHead ? { gitHead } : {},
+				...ciRunId ? { ciRunId } : {},
+				...runUrl ? { runUrl } : {}
+			})).id,
+			gitHead
+		};
+	} catch (err) {
+		throw new RunUsageError(`--report-to-hub: could not open a run on the hub (${errMessage(err)})`);
 	}
+}
+/**
+* Send one finished spec. A failure is warned and swallowed rather than
+* thrown: the seal resends every row, so a dropped patch costs freshness for
+* the rest of the sweep, not the record.
+*/
+async function sendDriftRow(push, result, threshold) {
 	try {
-		const project = resolveProject({
-			project: opts.project,
-			cwd
+		await push.hub.patchRun(push.runId, {
+			rows: [driftResultToRow(result, threshold)],
+			reportMeta: { cost: currentReportCost() }
 		});
-		const [branch, head] = await Promise.all([detectBranch(cwd), getGitHead(cwd)]);
-		const report = driftResultsToReport(results, {
-			threshold,
-			git: {
-				head,
-				base: baseRef ?? null
-			},
-			customPromptVersion: promptCtx?.customPromptVersion ?? null,
-			triageUserPromptHash: promptCtx?.triageUserPromptHash ?? null
+	} catch (err) {
+		warn(`hub: could not push ${result.target.featureName}/${result.target.specName}: ${errMessage(err)}`);
+	}
+}
+/**
+* Close the run with every row and the envelope metadata. Resends all rows
+* rather than only the unsent ones, so this one call also repairs any row
+* whose mid-sweep patch failed. Status is left to the hub, which derives it
+* from the rows.
+*/
+async function sealDriftPush(push, args) {
+	const { results, threshold, opts, format, baseRef, promptCtx } = args;
+	const report = driftResultsToReport(results, {
+		threshold,
+		git: {
+			head: push.gitHead,
+			base: baseRef ?? null
+		},
+		customPromptVersion: promptCtx?.customPromptVersion ?? null,
+		triageUserPromptHash: promptCtx?.triageUserPromptHash ?? null
+	});
+	try {
+		await push.hub.patchRun(push.runId, {
+			rows: report.results,
+			done: true,
+			reportMeta: {
+				git: report.git,
+				promptVersion: report.promptVersion,
+				customPromptVersion: report.customPromptVersion,
+				...report.triageUserPromptHash ? { triageUserPromptHash: report.triageUserPromptHash } : {},
+				cost: report.cost
+			}
 		});
-		const dir = await mkdtemp(join(tmpdir(), "ccqa-drift-push-"));
-		try {
-			await writeFile(join(dir, "report.json"), JSON.stringify(report, null, 2), "utf8");
-			const archive = await packDirToTarGz(dir);
-			const run = await hub.pushRun(archive, {
-				project,
-				...branch ? { branch } : {},
-				kind: "drift"
-			});
-			if (format === "text") info(`pushed drift result to hub: ${(opts.hubUrl ?? process.env.CCQA_HUB_URL ?? "").replace(/\/+$/, "")}/#/runs/${run.id}`);
-		} finally {
-			await rm(dir, {
-				recursive: true,
-				force: true
-			});
-		}
 	} catch (err) {
-		if (err instanceof HubApiError) {
-			error(`hub request failed (${err.status} ${err.code}): ${err.message}`);
-			process.exit(2);
-		}
-		throw err;
+		error(`hub: could not close the drift run ${push.runId}: ${errMessage(err)}`);
+		process.exit(2);
 	}
+	if (format === "text") info(`pushed drift result to hub: ${(opts.hubUrl ?? process.env.CCQA_HUB_URL ?? "").replace(/\/+$/, "")}/#/runs/${push.runId}`);
 }
 /**
 * Adapts `AuditOptions` to `resolveHubContext`'s flat option shape. Unlike
@@ -16140,6 +16182,53 @@ For each test case above, write a 1–2 sentence factual \`summary\` of what it
 `;
 }
 //#endregion
+//#region src/spec/spec-changed-at.ts
+/**
+* One `git log` over the spec tree, walked newest-first. The first time a spec's
+* directory appears is that spec's last edit.
+*
+* Best-effort: outside a repository (or with no history) this returns an empty
+* map and every caller falls back to what it did before. A missing timestamp
+* must never make a spec look fresher than it is.
+*/
+async function readSpecChangedAt(cwd) {
+	const out = /* @__PURE__ */ new Map();
+	let stdout;
+	try {
+		({stdout} = await execFileP("git", [
+			"log",
+			"--pretty=format:%x00%cI",
+			"--name-only",
+			"--",
+			".ccqa/features"
+		], {
+			cwd,
+			maxBuffer: 64 * 1024 * 1024
+		}));
+	} catch {
+		return out;
+	}
+	let when = "";
+	for (const line of stdout.split("\n")) {
+		if (line.startsWith("\0")) {
+			when = line.slice(1).trim();
+			continue;
+		}
+		const key = specKeyOf(line.trim());
+		if (key && when && !out.has(key)) out.set(key, when);
+	}
+	return out;
+}
+/**
+* "feature/spec" for a path under the spec tree, or null for anything else.
+* Every file in a case's directory counts: the generated code moving is as
+* much a change to the test as the spec.yaml moving.
+*/
+function specKeyOf(path) {
+	const m = /^\.ccqa\/features\/([^/]+)\/test-cases\/([^/]+)\//.exec(path);
+	return m ? `${m[1]}/${m[2]}` : null;
+}
+//#endregion
 //#region src/cli/perspectives.ts
 const perspectivesCommand = addHubOptions(addLanguageOption(new Command("perspectives").description("Generate/update the project's perspectives document on the hub — a factual inventory of existing test coverage (no severity, no gap analysis)").option("--instruction <text>", "Hint to steer how summaries are written").option("-y, --yes", "Apply without asking [y/N]", false).option("--verify", "Check the hub document against the local specs (mechanical fields only) and exit 1 when it is stale. No Claude calls — cheap enough for CI.", false).option("-m, --model <name>", "Claude model alias ('sonnet'|'opus'|'haiku') or full ID").option("--project <name>", "Hub project to store the document under (default: cwd directory name)"))).action(withHubErrors(async (opts) => {
 	await withCostReporting("perspectives", () => opts.verify ? runPerspectivesCheck(opts) : runPerspectives(opts));
@@ -16290,17 +16379,20 @@ async function cleanupLegacyLocalFiles() {
 */
 async function buildSkeleton(tree) {
 	const config = await loadProjectConfig(process.cwd()).catch(() => null);
+	const changedAt = await readSpecChangedAt(process.cwd());
 	return (await Promise.all(tree.map(async (feature) => {
 		const specs = await Promise.all(feature.specs.filter((s) => s.hasSpecFile).map(async (s) => {
 			const specYaml = await tryReadSpecFile(feature.featureName, s.specName);
 			const meta = readSpecMeta(s.specName, specYaml);
 			const plugin = resolveSpecTarget(specYaml, config);
 			const status = await deriveStatus(feature.featureName, s.specName, meta.mode, plugin);
+			const lastEdit = changedAt.get(`${feature.featureName}/${s.specName}`);
 			return {
 				specName: s.specName,
 				title: meta.title,
 				summary: "",
-				status
+				status,
+				...lastEdit ? { changedAt: lastEdit } : {}
 			};
 		}));
 		return {
@@ -17157,23 +17249,20 @@ function createPatchRunHandler(config) {
 			};
 		});
 		if (evidence) for (const [relPath, b64] of Object.entries(evidence)) await config.storage.artifacts.putFile(id, relPath, Buffer.from(b64, "base64"));
-		const patch = done ? {
-			status: finalStatus ?? (specs.failed > 0 ? "failed" : "passed"),
+		const patch = {
 			specs,
 			costUsd,
 			...run.kind === "drift" ? { drift: summarizeDrift(mergedResults) } : {},
-			...reportMeta?.git?.head ? { gitHead: reportMeta.git.head } : {},
-			...reportMeta?.promptVersion ? { promptVersion: reportMeta.promptVersion } : {},
-			...await deployHeadMovedDuringRun(config.storage, run) ? { deployedShaAmbiguous: true } : {}
-		} : {
-			specs,
-			costUsd
+			...done ? {
+				status: finalStatus ?? (specs.failed > 0 ? "failed" : "passed"),
+				...reportMeta?.git?.head ? { gitHead: reportMeta.git.head } : {},
+				...reportMeta?.promptVersion ? { promptVersion: reportMeta.promptVersion } : {},
+				...await deployHeadMovedDuringRun(config.storage, run) ? { deployedShaAmbiguous: true } : {}
+			} : {}
 		};
 		const updated = await config.storage.runs.update(id, patch);
-		if (done) {
-			await updateSpecLedger(config.storage, updated, mergedResults);
-			await updateDriftLedger(config.storage, updated, mergedResults);
-		}
+		await updateDriftLedger(config.storage, updated, mergedResults);
+		if (done) await updateSpecLedger(config.storage, updated, mergedResults);
 		sendJson(ctx.res, 200, updated);
 	};
 }
@@ -17801,7 +17890,11 @@ function readSpecTargets(doc) {
 		for (const spec of specs) {
 			const specName = prop(spec, "specName");
 			if (typeof specName !== "string") continue;
-			out.push({ key: `${featureName}/${specName}` });
+			const changedAt = prop(spec, "changedAt");
+			out.push({
+				key: `${featureName}/${specName}`,
+				...typeof changedAt === "string" && changedAt ? { changedAt } : {}
+			});
 		}
 	}
 	return out;
@@ -17922,9 +18015,40 @@ function createReleaseLocksHandler(storage) {
 }
 //#endregion
 //#region src/hub/core/rerun.ts
+/**
+* When each deployed commit reached the environment. A baseline read at that
+* commit cannot have seen anything committed after it was deployed.
+*/
+function deployedAt(log) {
+	const out = /* @__PURE__ */ new Map();
+	for (const entry of log.entries) out.set(entry.sha, entry.at);
+	return out;
+}
+/**
+* Has the spec moved since the baseline was taken?
+*
+* A verdict is a claim about a (spec, product) pair, so either side moving
+* invalidates it. The deploy log covers the product side; this covers the
+* other one. Without it a spec repaired and merged stays `needsRepair` until
+* a deploy happens to reach it, and a run that passed against the previous
+* spec keeps answering `verified` for the new one.
+*
+* Compared against when the baseline commit was *deployed*, not when the audit
+* or run happened: the tree read at that commit predates its deployment, so an
+* edit after it is definitely not in it. Falls back to the baseline's own
+* timestamp when the log cannot place the commit.
+*
+* One-directional. A later edit time proves the baseline is stale; an earlier
+* one proves nothing, and this answers false rather than guessing.
+*/
+function specMovedSince(changedAt, baselineSha, baselineAt, deployTimes) {
+	if (!changedAt) return null;
+	return changedAt > (baselineSha && deployTimes.get(baselineSha) || baselineAt) ? changedAt : null;
+}
 function computeRerun(input) {
 	const { specs, ledger, log, touchIndex, drift, locks, now } = input;
 	const range = buildRange(log, touchIndex);
+	const deployTimes = deployedAt(log);
 	const out = {};
 	for (const spec of specs) {
 		const coords = {
@@ -17932,11 +18056,17 @@ function computeRerun(input) {
 			lastGreen: ledger.green[spec.key] ?? null,
 			lastRed: ledger.red[spec.key] ?? null
 		};
-		const audit = auditState(drift, spec.key, range);
-		const execution = executionState(coords, (sha) => freshness(sha, spec.key, range));
+		let audit = auditState(drift, spec.key, range);
+		let execution = executionState(coords, (sha) => freshness(sha, spec.key, range));
+		const driftEntry = drift.specs[spec.key];
+		const auditMoved = specMovedSince(spec.changedAt, driftEntry?.gitHead ?? null, driftEntry?.at ?? "", deployTimes);
+		const runMoved = specMovedSince(spec.changedAt, coords.lastRun?.deployedSha ?? null, coords.lastRun?.at ?? "", deployTimes);
+		if (auditMoved && audit.audit !== "due") audit = { audit: "due" };
+		if (runMoved && execution.execution === "passed") execution = { execution: "stale" };
 		const held = heldBy(locks, spec.key, now);
 		out[spec.key] = {
 			verdict: decide(audit.audit, execution.execution, held),
+			...auditMoved || runMoved ? { specChangedSince: auditMoved ?? runMoved } : {},
 			...audit,
 			...execution,
 			heldBy: held,

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

@@ -286,6 +286,7 @@ declare const RerunReportSchema: z.ZodObject<{
       deployedShaNotInLog: "deployedShaNotInLog";
       gapInRange: "gapInRange";
     }>>;
+    specChangedSince: z.ZodOptional<z.ZodString>;
     heldBy: z.ZodNullable<z.ZodObject<{
       kind: z.ZodEnum<{
         run: "run";

package/dist/package.json

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