ccqa 1.19.0 → 1.20.0

package/dist/bin/ccqa.mjs

@@ -6779,18 +6779,16 @@ const AuditStateSchema = z.enum([
 	"due",
 	"clean",
 	"drifted",
-	"undecided",
-	"cannotTell"
+	"undecided"
 ]);
 /**
-* Axis 2: what happened the last time this spec ran. Deliberately has no
-* "stale pass" value — *which* deploy a run covered is a separate fact
-* (`lastRun.deployedSha`), and collapsing the two is what left the old
-* single-axis state unable to tell a red spec from an up-to-date one.
+* Axis 2: what happened the last time this spec ran, and whether that result
+* still covers what is deployed.
 */
 const ExecutionStateSchema = z.enum([
 	"passed",
 	"failed",
+	"stale",
 	"neverRun"
 ]);
 /**
@@ -6803,16 +6801,15 @@ const SpecVerdictSchema = z.enum([
 	"inProgress",
 	"needsRepair",
 	"rerunNeeded",
-	"verified",
-	"unanswerable"
+	"verified"
 ]);
 /**
-* Why a spec is `unanswerable`. Always carried, so the view can name the
-* missing input ("no deploy log for this profile") instead of shrugging.
-* `unanswerable` is never rendered as `verified`.
+* Which hole in the deploy log made the hub assume a deploy reached this spec
+* (ADR-0014). Not a state: the verdict is already decided by the time one of
+* these is attached, and it exists so the view can say *why* a spec is pending
+* instead of leaving the reader to guess.
 */
 const RerunUnknownReasonSchema = z.enum([
-	"notEvaluated",
 	"noSelectionInRange",
 	"selectionUnknown",
 	"noDeployLog",
@@ -6874,7 +6871,8 @@ const SpecRerunSchema = z.object({
 	audit: AuditStateSchema,
 	execution: ExecutionStateSchema,
 	driftLabel: DriftLabelSchema.exclude(["UNKNOWN"]).optional(),
-	reason: RerunUnknownReasonSchema.optional(),
+	auditAssumedReached: RerunUnknownReasonSchema.optional(),
+	executionAssumedReached: RerunUnknownReasonSchema.optional(),
 	heldBy: SpecLockSchema.nullable(),
 	lastRun: SpecLedgerEntrySchema.nullable(),
 	lastGreen: SpecLedgerEntrySchema.nullable(),
@@ -6884,9 +6882,10 @@ const SpecRerunSchema = z.object({
 });
 /**
 * Why this spec does or does not need auditing. Everything but `current` and
-* `held` audits: the audit is cheap, so it errs towards doing the work where
-* the run errs away from it. `held` is not an answer about freshness at all —
-* another job is on it, so this one skips it and asks again next cycle.
+* `held` audits. `held` is not an answer about freshness at all — another job
+* is on it, so this one skips it and asks again next cycle. `cannotTell`
+* survives here because it is a real explanation of why an audit is owed; the
+* re-run axis folds it into `due` (ADR-0014).
 */
 const AuditNeedSchema = z.object({
 	because: z.enum([
@@ -7001,12 +7000,13 @@ const CreateLearningJobRequestSchema = z.object({
 * makes either flag dangerous.
 */
 /**
-* The release whose hub serves these endpoints in their current shape. Both
-* were reshaped together, so one number covers both — an older hub either
-* 404s (audit-need, which did not exist) or answers a shape the caller now
-* rejects (re-run, whose fields were renamed).
+* The release whose hub serves these endpoints in their current shape — the
+* newest reshape of either, since one number is what a reader can act on. An
+* older hub either 404s (audit-need, which did not exist before 1.16) or
+* answers a vocabulary the caller now rejects (re-run, whose verdict values
+* changed in 1.20).
 */
-const MIN_HUB_VERSION = "1.16";
+const MIN_HUB_VERSION = "1.20";
 /**
 * Which of the two 404s this was. The handlers answer `no_perspectives` when
 * the route exists but the project has no document; any other code on a 404
@@ -7033,7 +7033,7 @@ function requireHubProfile(flag, profile, question) {
 function rankedOrder(rank) {
 	return Object.keys(rank).sort((a, b) => rank[a] - rank[b]);
 }
-/** "3 rerunNeeded, 1 unanswerable, 12 verified" — every offered spec accounted for. */
+/** "3 rerunNeeded, 1 inProgress, 12 verified" — every offered spec accounted for. */
 function formatCounts(order, counts) {
 	return order.filter((key) => counts.has(key)).map((key) => `${counts.get(key)} ${key}`).join(", ");
 }
@@ -7077,39 +7077,47 @@ async function fetchRerunReport(hubCtx, profile) {
 const SUMMARY_ORDER$1 = rankedOrder({
 	needsRepair: 0,
 	rerunNeeded: 1,
-	unanswerable: 2,
-	inProgress: 3,
-	verified: 4
+	inProgress: 2,
+	verified: 3
 });
 /**
 * Narrow `specs` to the ones the hub says are worth running.
 *
-* `rerunNeeded` is always selected, and a spec that has never run is part of
-* it — a spec with no result at all is as uncovered as one whose result a
-* deploy invalidated. `unanswerable` is "the question cannot be answered", so
-* it is excluded by default and opted into with
-* `--only-hub-rerun-needed-with-unknown` — fail-open on request, never
-* silently. `needsRepair`, `inProgress` and `verified` are never selected:
-* running them repairs nothing, races something already in flight, or repeats
-* work that is still current.
-*/
-function selectSpecsNeedingRerun(specs, report, opts) {
+* `rerunNeeded` is always selected, and it now covers everything the hub could
+* not place: a spec that never ran, and one whose currency the deploy log
+* cannot vouch for, are both as uncovered as one a deploy demonstrably
+* invalidated (ADR-0014). `needsRepair`, `inProgress` and `verified` are never
+* selected: running them repairs nothing, races something already in flight,
+* or repeats work that is still current.
+*/
+function selectSpecsNeedingRerun(specs, report) {
 	const counts = /* @__PURE__ */ new Map();
 	const selected = [];
-	let excludedUnanswerable = 0;
 	let excludedInProgress = 0;
+	let excludedUnknownToHub = 0;
+	let excludedAssumedReached = 0;
+	const assumedReachedReasons = /* @__PURE__ */ new Set();
 	for (const spec of specs) {
-		const verdict = report.specs[specKey(spec)]?.verdict ?? "unanswerable";
+		const entry = report.specs[specKey(spec)];
+		const verdict = entry?.verdict ?? "inProgress";
 		counts.set(verdict, (counts.get(verdict) ?? 0) + 1);
-		if (verdict === "rerunNeeded" || opts.includeUnknown && verdict === "unanswerable") selected.push(spec);
-		else if (verdict === "unanswerable") excludedUnanswerable++;
-		else if (verdict === "inProgress") excludedInProgress++;
+		if (verdict === "rerunNeeded") selected.push(spec);
+		else if (verdict === "inProgress") {
+			excludedInProgress++;
+			if (!entry) excludedUnknownToHub++;
+			else if (entry.auditAssumedReached) {
+				excludedAssumedReached++;
+				assumedReachedReasons.add(entry.auditAssumedReached);
+			}
+		}
 	}
 	return {
 		selected,
 		summary: formatCounts(SUMMARY_ORDER$1, counts),
-		excludedUnanswerable,
-		excludedInProgress
+		excludedInProgress,
+		excludedUnknownToHub,
+		excludedAssumedReached,
+		excludedAssumedReachedReasons: [...assumedReachedReasons]
 	};
 }
 //#endregion
@@ -8672,7 +8680,7 @@ const promptRm = new Command("rm").description("Delete a prompt from the hub.").
 	info(`deleted prompt "${name}" from the hub`);
 }));
 const promptCommand = new Command("prompt").description("Manage prompt assets (per-flow user/agent guidance, triage/audit user guidance, learned calibration prompts) stored on the hub (fetched automatically by `ccqa run` / `ccqa audit` at run time).").addCommand(promptPush).addCommand(promptLs).addCommand(promptRm);
-const deployRecord = new Command("record").description("Tell the hub what a deploy shipped, so it can answer which specs need a re-run (`ccqa run --only-hub-rerun-needed`). Run this from the deploy job, after the deploy succeeds. The changed paths are computed locally with a two-dot `git diff <previous> <sha>`; a job that has only curl and git can POST the same body directly (see docs/hub.md).").requiredOption("--profile <name>", "Environment this deploy landed in (e.g. 'stg'). Required: dev and stg sit at different commits, so the deploy log is per-profile.").requiredOption("--sha <sha>", "Commit that was deployed.").option("--previous <sha>", "Commit this deploy replaced. Defaults to the profile's current deploy-log head on the hub. With neither, there's nothing to diff against: changedPaths is unset and the spec selection is skipped.").option("--ref <ref>", "Ref that was deployed (branch or tag). Recorded for display only.").option("--no-select-specs", "Record the deploy without deciding which specs it reaches. The entry then becomes a hole in the range — every spec behind it answers 'unanswerable' rather than being cleared, and nothing can fill it in later, since the hub has no checkout to diff. Only pass this when no Claude credential is available; it costs one model call to leave the log answerable.").option("-m, --model <name>", "Model for the spec selection. Claude alias ('sonnet'|'opus'|'haiku') or full ID. Overrides CCQA_MODEL.").option(...hubUrlOption).option(...hubTokenOption).option("--project <name>", "Project whose deploy log this entry joins. Defaults to the current directory's name.").option("--cwd <path>", "Directory the git diff and the default --project name are resolved against.").action(withHubErrors(async (opts) => {
+const deployRecord = new Command("record").description("Tell the hub what a deploy shipped, so it can answer which specs need a re-run (`ccqa run --only-hub-rerun-needed`). Run this from the deploy job, after the deploy succeeds. The changed paths are computed locally with a two-dot `git diff <previous> <sha>`; a job that has only curl and git can POST the same body directly (see docs/hub.md).").requiredOption("--profile <name>", "Environment this deploy landed in (e.g. 'stg'). Required: dev and stg sit at different commits, so the deploy log is per-profile.").requiredOption("--sha <sha>", "Commit that was deployed.").option("--previous <sha>", "Commit this deploy replaced. Omit it and the hub's current log head is used — the normal case, recording no discontinuity. Pass a sha that differs from the head and the hub records one (gapBefore) in the chain: use this for a first record with a real baseline, or to re-anchor a head that no longer matches reality. With no head and nothing passed, there's nothing to diff against: changedPaths is unset and the spec selection is skipped.").option("--ref <ref>", "Ref that was deployed (branch or tag). Recorded for display only.").option("--no-select-specs", "Record the deploy without deciding which specs it reaches. The entry then becomes a hole in the range — every spec behind it is assumed reached rather than being cleared, and nothing can fill it in later, since the hub has no checkout to diff. Only pass this when no Claude credential is available; it costs one model call to leave the range clearable.").option("-m, --model <name>", "Model for the spec selection. Claude alias ('sonnet'|'opus'|'haiku') or full ID. Overrides CCQA_MODEL.").option(...hubUrlOption).option(...hubTokenOption).option("--project <name>", "Project whose deploy log this entry joins. Defaults to the current directory's name.").option("--cwd <path>", "Directory the git diff and the default --project name are resolved against.").action(withHubErrors(async (opts) => {
 	const cwd = resolveCwd(opts.cwd);
 	const project = resolveProject(opts);
 	const hub = connect(opts);
@@ -8695,9 +8703,9 @@ const deployRecord = new Command("record").description("Tell the hub what a depl
 	meta("previous", previous ? previous.slice(0, 12) : "(none)");
 	meta("changed paths", changedPaths === null ? "(not reported)" : String(changedPaths.length));
 	if (opts.selectSpecs !== false) meta("selection", describeSelection(selection, diff !== null));
-	if (entry.gapBefore) warn("this deploy does not chain onto the log head, so a gap is recorded — specs whose baseline sits behind it report 'unanswerable' rather than 'verified'");
+	if (entry.gapBefore) warn("this deploy does not chain onto the log head, so a gap is recorded — specs whose baseline sits behind it are assumed reached rather than cleared to 'verified'");
 	if (selection && !entry.hasSelection) {
-		error("the hub recorded this deploy but could not store its spec selection — the range answers 'unanswerable' from here on, and nothing fills it in later. Re-record this deploy.");
+		error("the hub recorded this deploy but could not store its spec selection — every spec behind it is assumed reached from here on, and nothing fills it in later. Re-record this deploy.");
 		process.exit(1);
 	}
 	info(`recorded deploy #${entry.index}`);
@@ -12193,7 +12201,6 @@ async function executeRun(targets, opts) {
 	const filtering = Boolean(opts.onlyAffectedBy || opts.onlyHubRerunNeeded);
 	if (filtering && targets.length > 0) throw new RunUsageError("a --only-* filter and an explicit spec target cannot be combined");
 	const rerunProfile = opts.onlyHubRerunNeeded === true ? requireRerunProfile(opts.hubProfile) : null;
-	if (opts.onlyHubRerunNeededWithUnknown && rerunProfile === null) warn("--only-hub-rerun-needed-with-unknown is ignored: it only applies to --only-hub-rerun-needed");
 	const forExecution = opts.dryRun !== true;
 	const cwd = opts.cwd ?? process.cwd();
 	const wantsLastGreen = opts.onFailExplain === true && opts.onFailExplainBase === void 0;
@@ -12281,13 +12288,17 @@ async function executeRun(targets, opts) {
 	let specs = dedupeSpecs((await Promise.all((targets.length ? targets : [void 0]).map((t) => resolveSpecTargets(t, enumerateAll, cwd)))).flat());
 	if (filtering) {
 		const before = specs.length;
-		let unanswerable = 0;
 		let inProgress = 0;
+		let unknownToHub = 0;
+		let assumedReached = 0;
+		let assumedReachedReasons = [];
 		if (rerunReport) {
-			const selection = selectSpecsNeedingRerun(specs, rerunReport, { includeUnknown: opts.onlyHubRerunNeededWithUnknown === true });
+			const selection = selectSpecsNeedingRerun(specs, rerunReport);
 			specs = selection.selected;
-			unanswerable = selection.excludedUnanswerable;
 			inProgress = selection.excludedInProgress;
+			unknownToHub = selection.excludedUnknownToHub;
+			assumedReached = selection.excludedAssumedReached;
+			assumedReachedReasons = selection.excludedAssumedReachedReasons;
 			meta("stale-base", `deploy ${rerunReport.deployHead.sha.slice(0, 12)} (profile ${rerunReport.profile})`);
 			meta("stale-states", selection.summary);
 		}
@@ -12297,9 +12308,11 @@ async function executeRun(targets, opts) {
 			...opts.model ? { model: opts.model } : {}
 		})).specs;
 		meta("selected", `${specs.length} of ${before} spec${before === 1 ? "" : "s"}`);
-		if (specs.length === 0 && (unanswerable > 0 || inProgress > 0)) {
-			if (unanswerable > 0) hint(`${unanswerable} spec(s) were excluded because the hub could not tell whether they need a re-run; pass --only-hub-rerun-needed-with-unknown to run them anyway`);
-			if (inProgress > 0) hint(`${inProgress} spec(s) were excluded because the audit has not answered for the deployed commit yet; run \`ccqa audit --only-hub-audit-needed --report-to-hub\` first`);
+		if (specs.length === 0 && inProgress > 0) {
+			if (unknownToHub > 0) hint(`${unknownToHub} spec(s) were excluded because the hub's perspectives document has never heard of them; run \`ccqa perspectives\` to register them`);
+			if (assumedReached > 0) hint(`${assumedReached} spec(s) were excluded because the audit ran at a commit the deploy log cannot place (${assumedReachedReasons.join(", ")}); re-running \`ccqa audit --only-hub-audit-needed\` at the same commit will not clear it — record the deploy (\`ccqa hub deploy record\`) so the log can place it, or select with --only-affected-by <ref> to make progress meanwhile`);
+			const explained = unknownToHub + assumedReached;
+			if (explained < inProgress) hint(`${inProgress - explained} spec(s) were excluded because the audit has not answered for the deployed commit yet; run \`ccqa audit --only-hub-audit-needed --report-to-hub\` first`);
 			throw new RunUsageError("nothing was selected and no spec was cleared to run: exiting non-zero rather than reporting a green run that verified nothing");
 		}
 	}
@@ -13053,7 +13066,7 @@ function installTeardownSignalHandlers(teardown) {
 }
 //#endregion
 //#region src/cli/run.ts
-const runCommand = addHubOptions(addProfileOption(addLanguageOption(new Command("run").argument("[targets...]", "Specs to run, space-separated: each '<feature>/<spec>', '<feature>', or omit for all. Duplicates are de-duped.").description("Run specs, on any target. Agent-browser specs replay the recorded test.spec.ts under vitest (default), or, with spec.yaml `mode: live`, have Claude drive agent-browser live per step. External-target specs (playwright, runn) run through the target's configured `runCommand`. A structured report (report.json + evidence) is always written; use --report-to-hub to also stream it to a hub.").optionsGroup("Which specs to run:").option("--only-affected-by <ref>", "Only specs `ccqa select-specs` judges reached by the diff against <ref> (e.g. origin/main). In pull_request CI, pass $GITHUB_BASE_REF. Cannot be combined with an explicit spec id.").option("--only-hub-rerun-needed", "Only specs the hub answers `rerunNeeded` for: the audit cleared them, and their last result does not cover what is deployed. A spec whose audit has not caught up answers `inProgress`, and one the audit rejected or whose last run failed answers `needsRepair`; neither is taken, because running them races the audit or repairs nothing. No git diff involved. Requires a hub connection and --hub-profile.").option("--only-hub-rerun-needed-with-unknown", "With --only-hub-rerun-needed: also take specs the hub cannot answer for at all ('unanswerable' — a hole in the deploy log). Off by default: an unanswerable question is reported, not guessed.").option("--dry-run", "Print the specs this invocation would run, then exit 0 without executing anything and without writing a report. Works with every selection flag.").optionsGroup("How to run them:").option("--concurrency <n>", "Run up to N specs in parallel within each phase (deterministic / external-target / live), never across phases. Default 1 (sequential). Specs in the same `serialGroups` entry of .ccqa/config.yaml still take turns. Live specs each get an isolated agent-browser session; high values spawn many headed Chrome instances.", parseConcurrency$1, 1).option("-m, --model <name>", "Claude model alias ('sonnet'|'opus'|'haiku') or full ID. Overrides CCQA_MODEL.").option("--live-step-retry <n>", "(live only) Retry each failed step up to N more times before recording failure. This retries a step, not the whole spec — see --on-fail-explain-rerun for that.", (raw) => {
+const runCommand = addHubOptions(addProfileOption(addLanguageOption(new Command("run").argument("[targets...]", "Specs to run, space-separated: each '<feature>/<spec>', '<feature>', or omit for all. Duplicates are de-duped.").description("Run specs, on any target. Agent-browser specs replay the recorded test.spec.ts under vitest (default), or, with spec.yaml `mode: live`, have Claude drive agent-browser live per step. External-target specs (playwright, runn) run through the target's configured `runCommand`. A structured report (report.json + evidence) is always written; use --report-to-hub to also stream it to a hub.").optionsGroup("Which specs to run:").option("--only-affected-by <ref>", "Only specs `ccqa select-specs` judges reached by the diff against <ref> (e.g. origin/main). In pull_request CI, pass $GITHUB_BASE_REF. Cannot be combined with an explicit spec id.").option("--only-hub-rerun-needed", "Only specs the hub answers `rerunNeeded` for: the audit cleared them, and their last result does not cover what is deployed — including every spec the deploy log cannot place, which is assumed reached rather than skipped. A spec whose audit has not caught up answers `inProgress`, and one the audit rejected or whose last run failed answers `needsRepair`; neither is taken, because running them races the audit or repairs nothing. No git diff involved. Requires a hub connection and --hub-profile.").option("--dry-run", "Print the specs this invocation would run, then exit 0 without executing anything and without writing a report. Works with every selection flag.").optionsGroup("How to run them:").option("--concurrency <n>", "Run up to N specs in parallel within each phase (deterministic / external-target / live), never across phases. Default 1 (sequential). Specs in the same `serialGroups` entry of .ccqa/config.yaml still take turns. Live specs each get an isolated agent-browser session; high values spawn many headed Chrome instances.", parseConcurrency$1, 1).option("-m, --model <name>", "Claude model alias ('sonnet'|'opus'|'haiku') or full ID. Overrides CCQA_MODEL.").option("--live-step-retry <n>", "(live only) Retry each failed step up to N more times before recording failure. This retries a step, not the whole spec — see --on-fail-explain-rerun for that.", (raw) => {
 	const n = Number(raw);
 	if (!Number.isFinite(n) || n < 0 || Math.floor(n) !== n) throw new Error(`--live-step-retry must be a non-negative integer, got "${raw}"`);
 	return n;
@@ -15466,9 +15479,9 @@ function buildRange(log, touchIndex) {
 }
 function freshness(baselineSha, key, range) {
 	const { log, positionBySha, touchIndex } = range;
-	if (log.entries.length === 0) return unanswerable$1("noDeployLog");
+	if (log.entries.length === 0) return unanswerable("noDeployLog");
 	const baselinePos = positionBySha.get(baselineSha);
-	if (baselinePos === void 0) return unanswerable$1("deployedShaNotInLog");
+	if (baselinePos === void 0) return unanswerable("deployedShaNotInLog");
 	const baselineIndex = log.entries[baselinePos].index;
 	const touch = touchIndex[key];
 	const touched = touch?.needed;
@@ -15480,9 +15493,9 @@ function freshness(baselineSha, key, range) {
 			touchedByDeploy: entry ? deployRef(entry) : null
 		};
 	}
-	if (range.gapFromPos[baselinePos + 1]) return unanswerable$1("gapInRange");
-	if (range.noSelectionFromPos[baselinePos + 1]) return unanswerable$1("noSelectionInRange");
-	if (touch?.undecidedIndex !== void 0 && touch.undecidedIndex > baselineIndex) return unanswerable$1("selectionUnknown");
+	if (range.gapFromPos[baselinePos + 1]) return unanswerable("gapInRange");
+	if (range.noSelectionFromPos[baselinePos + 1]) return unanswerable("noSelectionInRange");
+	if (touch?.undecidedIndex !== void 0 && touch.undecidedIndex > baselineIndex) return unanswerable("selectionUnknown");
 	return { kind: "current" };
 }
 function deployRef(entry) {
@@ -15492,7 +15505,7 @@ function deployRef(entry) {
 		at: entry.at
 	};
 }
-function unanswerable$1(reason) {
+function unanswerable(reason) {
 	return {
 		kind: "unanswerable",
 		reason
@@ -17778,7 +17791,6 @@ function createReleaseLocksHandler(storage) {
 function computeRerun(input) {
 	const { specs, ledger, log, touchIndex, drift, locks, now } = input;
 	const range = buildRange(log, touchIndex);
-	const nothingRecorded = log.entries.length === 0 && Object.keys(ledger.run).length === 0 && Object.keys(ledger.green).length === 0;
 	const out = {};
 	for (const spec of specs) {
 		const coords = {
@@ -17787,16 +17799,12 @@ function computeRerun(input) {
 			lastRed: ledger.red[spec.key] ?? null
 		};
 		const audit = auditState(drift, spec.key, range);
-		const execution = executionState(coords);
+		const execution = executionState(coords, (sha) => freshness(sha, spec.key, range));
 		const held = heldBy(locks, spec.key, now);
-		const derived = nothingRecorded ? {
-			verdict: "unanswerable",
-			reason: "notEvaluated"
-		} : decide(audit, execution, held, coords.lastRun, (sha) => freshness(sha, spec.key, range));
 		out[spec.key] = {
-			...derived,
+			verdict: decide(audit.audit, execution.execution, held),
 			...audit,
-			execution,
+			...execution,
 			heldBy: held,
 			...coords
 		};
@@ -17807,6 +17815,10 @@ function computeRerun(input) {
 * Axis 1, derived from the same freshness answer `--only-hub-audit-needed`
 * reads. The label only speaks once the audit is known to be current: a
 * verdict about an older commit says nothing about the one running now.
+*
+* A commit the log cannot place is `due` like any other: a deploy we cannot
+* rule out is treated as having landed (ADR-0014). The hole is kept as an
+* annotation so the answer stays explicable.
 */
 function auditState(drift, key, range) {
 	const need = auditNeed(drift, key, range);
@@ -17814,8 +17826,8 @@ function auditState(drift, key, range) {
 		case "neverAudited":
 		case "deployReached": return { audit: "due" };
 		case "cannotTell": return {
-			audit: "cannotTell",
-			...need.reason ? { reason: need.reason } : {}
+			audit: "due",
+			...need.reason ? { auditAssumedReached: need.reason } : {}
 		};
 		case "current": {
 			const label = drift.specs[key].label;
@@ -17833,56 +17845,57 @@ function auditState(drift, key, range) {
 	}
 }
 /**
-* Axis 2. The red bucket is compared by run id rather than by timestamp
-* because both buckets advance from the same terminal-run trigger, so the run
-* that wrote `run` wrote exactly one of `green` or `red`.
-*/
-function executionState(coords) {
-	if (!coords.lastRun) return "neverRun";
-	if (coords.lastRed && coords.lastRed.runId === coords.lastRun.runId) return "failed";
-	return "passed";
+* Axis 2: how the last run ended, and whether a deploy has overtaken it. The
+* red bucket is compared by run id rather than by timestamp because both
+* buckets advance from the same terminal-run trigger, so the run that wrote
+* `run` wrote exactly one of `green` or `red`.
+*
+* `failed` outranks `stale`: a red result is current information whatever has
+* deployed since, and re-running it teaches nothing until someone repairs it.
+*/
+function executionState(coords, since) {
+	const { lastRun, lastRed } = coords;
+	if (!lastRun) return { execution: "neverRun" };
+	if (lastRed && lastRed.runId === lastRun.runId) return { execution: "failed" };
+	if (lastRun.deployedShaAmbiguous) return assumedReached("ambiguousDeployedSha");
+	if (!lastRun.deployedSha) return assumedReached("unknownDeployedSha");
+	const answer = since(lastRun.deployedSha);
+	if (answer.kind === "unanswerable") return assumedReached(answer.reason);
+	if (answer.kind === "current") return { execution: "passed" };
+	return {
+		execution: "stale",
+		...answer.touchedBy ? { touchedBy: answer.touchedBy } : {},
+		touchedByDeploy: answer.touchedByDeploy
+	};
+}
+function assumedReached(reason) {
+	return {
+		execution: "stale",
+		executionAssumedReached: reason
+	};
 }
 /**
-* The derived answer, evaluated in order. Order is the whole design: a failed
-* spec is answered before its age is considered, because re-running it teaches
-* nothing until the code it exercises moves.
+* The derived answer: a total function of the two axes plus whether a job
+* holds the spec. Nothing else is consulted — an axis that needed a third
+* input to be read is an axis that cannot be shown next to the verdict as its
+* reason.
 */
-function decide(audit, execution, held, lastRun, since) {
-	if (held) return { verdict: "inProgress" };
-	switch (audit.audit) {
-		case "cannotTell": return unanswerable(audit.reason);
-		case "due": return { verdict: "inProgress" };
+function decide(audit, execution, held) {
+	if (held) return "inProgress";
+	switch (audit) {
+		case "due": return "inProgress";
 		case "drifted":
-		case "undecided": return { verdict: "needsRepair" };
+		case "undecided": return "needsRepair";
 		case "clean": break;
-		default: {
-			const unreachable = audit.audit;
-			throw new Error(`unhandled audit state: ${String(unreachable)}`);
-		}
+		default: throw new Error(`unhandled audit state: ${String(audit)}`);
 	}
 	switch (execution) {
-		case "failed": return { verdict: "needsRepair" };
-		case "passed":
-		case "neverRun": break;
+		case "failed": return "needsRepair";
+		case "stale":
+		case "neverRun": return "rerunNeeded";
+		case "passed": return "verified";
 		default: throw new Error(`unhandled execution state: ${String(execution)}`);
 	}
-	if (!lastRun) return { verdict: "rerunNeeded" };
-	if (lastRun.deployedShaAmbiguous) return unanswerable("ambiguousDeployedSha");
-	if (!lastRun.deployedSha) return unanswerable("unknownDeployedSha");
-	const answer = since(lastRun.deployedSha);
-	if (answer.kind === "unanswerable") return unanswerable(answer.reason);
-	if (answer.kind === "current") return { verdict: "verified" };
-	return {
-		verdict: "rerunNeeded",
-		...answer.touchedBy ? { touchedBy: answer.touchedBy } : {},
-		touchedByDeploy: answer.touchedByDeploy
-	};
-}
-function unanswerable(reason) {
-	return {
-		verdict: "unanswerable",
-		reason
-	};
 }
 //#endregion
 //#region src/hub/api/handlers/rerun.ts
@@ -18601,17 +18614,30 @@ const HTML_BODY = `
         <div id="persp-body" hidden>
           <div class="ov" id="persp-ov"></div>
           <div class="note info persp-note" id="persp-rerun-note" hidden></div>
-          <div class="note info persp-note" id="persp-drift-note" hidden></div>
           <div class="toolbar">
             <label class="search"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor"><circle cx="11" cy="11" r="7"/><path d="m21 21-4.3-4.3"/></svg><input id="persp-q" type="search" data-i18n-ph="perspectives.search" aria-label="Search cases"></label>
             <!-- Each chip carries the count of what it would leave behind, so
                  data-i18n sits on the inner label span: applyStaticI18n swaps
-                 textContent, which on the button would delete the count. -->
-            <button class="fchip" data-f="all" aria-pressed="true" type="button"><span data-i18n="perspectives.filter.all">All</span><span class="fcount"></span></button>
-            <button class="fchip" data-f="deterministic" aria-pressed="false" type="button"><span data-i18n="perspectives.filter.deterministic">Deterministic</span><span class="fcount"></span></button>
-            <button class="fchip" data-f="live" aria-pressed="false" type="button"><span data-i18n="perspectives.filter.live">Live</span><span class="fcount"></span></button>
-            <button class="fchip" id="persp-chip-rerun" data-f="rerun" aria-pressed="false" type="button" hidden><span data-i18n="perspectives.filter.rerun">Needs re-run only</span><span class="fcount"></span></button>
-            <button class="fchip" id="persp-chip-drift" data-f="drift" aria-pressed="false" type="button" hidden><span data-i18n="perspectives.filter.drift">Drift found only</span><span class="fcount"></span></button>
+                 textContent, which on the button would delete the count. Two
+                 labelled groups rather than one row: mode and verdict are
+                 different questions, and mixing their chips together read as
+                 one. -->
+            <div class="fgroup">
+              <span class="fgroup-label" data-i18n="perspectives.filter.group.mode">Mode</span>
+              <button class="fchip" data-f="all" aria-pressed="true" type="button"><span data-i18n="perspectives.filter.all">All</span><span class="fcount"></span></button>
+              <button class="fchip" data-f="deterministic" aria-pressed="false" type="button"><span data-i18n="perspectives.filter.deterministic">Deterministic</span><span class="fcount"></span></button>
+              <button class="fchip" data-f="live" aria-pressed="false" type="button"><span data-i18n="perspectives.filter.live">Live</span><span class="fcount"></span></button>
+            </div>
+            <!-- Same words as the 判定 column (perspectives.rerun.state.*) and
+                 the same group label as its header (perspectives.col.verdict)
+                 — a filter chip must never coin its own name for a verdict. -->
+            <div class="fgroup" id="persp-verdict-chips" hidden>
+              <span class="fgroup-label" data-i18n="perspectives.col.verdict">Verdict</span>
+              <button class="fchip" id="persp-chip-needsrepair" data-f="needsRepair" aria-pressed="false" type="button"><span data-i18n="perspectives.rerun.state.needsRepair">Needs repair</span><span class="fcount"></span></button>
+              <button class="fchip" id="persp-chip-rerunneeded" data-f="rerunNeeded" aria-pressed="false" type="button"><span data-i18n="perspectives.rerun.state.rerunNeeded">Re-run needed</span><span class="fcount"></span></button>
+              <button class="fchip" id="persp-chip-inprogress" data-f="inProgress" aria-pressed="false" type="button"><span data-i18n="perspectives.rerun.state.inProgress">In progress</span><span class="fcount"></span></button>
+              <button class="fchip" id="persp-chip-verified" data-f="verified" aria-pressed="false" type="button"><span data-i18n="perspectives.rerun.state.verified">Verified</span><span class="fcount"></span></button>
+            </div>
             <div class="spacer"></div>
             <span class="muted persp-head" id="persp-deploy-head" hidden></span>
             <div class="sw-wrap" id="persp-profile-wrap">
@@ -18623,7 +18649,7 @@ const HTML_BODY = `
             </div>
           </div>
           <div class="tblcard"><div class="table-wrap"><table>
-            <thead><tr><th data-i18n="perspectives.col.case">Case</th><th data-i18n="perspectives.col.mode">Mode</th><th id="persp-th-verdict" data-i18n="perspectives.col.verdict" hidden>Next</th><th id="persp-th-audit" data-i18n="perspectives.col.audit" hidden>Audit</th><th id="persp-th-run" data-i18n="perspectives.col.run" hidden>Execution</th><th id="persp-th-drift" data-i18n="perspectives.col.drift" hidden>Drift audit</th><th></th></tr></thead>
+            <thead><tr><th data-i18n="perspectives.col.case">Case</th><th data-i18n="perspectives.col.mode">Mode</th><th id="persp-th-verdict" data-i18n="perspectives.col.verdict" hidden>Verdict</th><th id="persp-th-run" data-i18n="perspectives.col.run" hidden>Execution</th><th id="persp-th-audit" data-i18n="perspectives.col.audit" hidden>Audit</th><th></th></tr></thead>
             <tbody id="persp-tbody"></tbody>
           </table></div></div>
           <p class="empty-note" id="persp-no-hit" hidden data-i18n="perspectives.noHit">No matching cases.</p>
@@ -19294,13 +19320,15 @@ const CSS = `
      existing badge/chip primitives above, so no new tokens are needed.
 
      The summary row answers the question this tab exists for — which cases
-     need re-running — as one inventory line plus one bar segmented by re-run
-     state. The mode and recorded-ness counts moved onto the filter chips,
-     which is where a count says something actionable. */
+     need attention — as one inventory line plus one bar per axis: verdict,
+     execution, audit, the same three groupings the table's columns show. The
+     mode and recorded-ness counts moved onto the filter chips, which is
+     where a count says something actionable. */
   .ov { display: flex; flex-direction: column; gap: 10px; padding: 14px 18px; border: 1px solid var(--border); border-radius: var(--radius); background: var(--surface); margin-bottom: 16px; }
   .ov-inv { font-size: 13px; color: var(--muted); }
   .ov-inv b { color: var(--fg); font-size: 15px; font-weight: 650; font-variant-numeric: tabular-nums; }
-  /* One row per overview axis (re-run, drift): a short label above its own bar+legend. */
+  /* One row per overview axis (verdict, execution, audit): a short label —
+     reusing that axis's own column header text — above its own bar+legend. */
   .ov-axis { display: flex; flex-direction: column; gap: 4px; }
   .ov-axis-label { font-size: 11px; font-weight: 600; text-transform: uppercase; letter-spacing: 0.05em; color: var(--muted-2); }
   .rrbar { height: 8px; border-radius: 999px; overflow: hidden; display: flex; background: var(--surface-3); }
@@ -19308,22 +19336,25 @@ const CSS = `
   .rrleg span { display: inline-flex; align-items: center; gap: 6px; }
   .rrleg i { width: 8px; height: 8px; border-radius: 50%; flex: none; }
   .rrleg b { color: var(--fg); font-weight: 600; font-variant-numeric: tabular-nums; }
-  /* One class per verdict, worn by both the bar segment and its legend dot.
-     "unanswerable" takes the info hue: it must never be mistaken for a pass.
-     Drift's own three states share these colours rather than inventing a
-     second palette — same reasoning as the badge classes below. Careful
-     writing in here: a star followed by a slash closes the comment early and
-     silently eats the next rule, and a backtick ends the template literal this
-     CSS lives in. */
-  .sg-drift-found, .sg-rerunneeded { background: var(--amber-fill); }
-  .sg-needsrepair { background: var(--fail); }
-  .sg-unanswerable, .sg-drift-unknown { background: var(--info); }
-  .sg-drift-clean, .sg-verified { background: var(--pass); }
-  .sg-drift-none, .sg-inprogress { background: var(--muted-2); }
+  /* One class per state, worn by both the bar segment and its legend dot.
+     The execution and audit axes share these colours with the verdict axis
+     rather than inventing two more palettes — same reasoning as the badge
+     classes below. Careful writing in here: a star followed by a slash
+     closes the comment early and silently eats the next rule, and a
+     backtick ends the template literal this CSS lives in. */
+  .sg-rerunneeded, .sg-exec-stale { background: var(--amber-fill); }
+  .sg-needsrepair, .sg-audit-drifted, .sg-exec-failed { background: var(--fail); }
+  .sg-audit-undecided { background: var(--info); }
+  .sg-verified, .sg-audit-clean, .sg-exec-passed { background: var(--pass); }
+  .sg-inprogress, .sg-audit-due, .sg-exec-never { background: var(--muted-2); }
 
   .search { flex: 1; min-width: 200px; max-width: 340px; display: flex; align-items: center; gap: 7px; border: 1px solid var(--border-strong); border-radius: var(--radius-sm); padding: 0 10px; height: 32px; background: var(--surface); }
   .search svg { width: 15px; height: 15px; flex: none; color: var(--muted-2); }
   .search input { border: none; outline: none; font: inherit; font-size: 13px; width: 100%; background: transparent; color: var(--fg); }
+  /* A labelled cluster of chips (mode, verdict) rather than one flat row —
+     the label says what question the chips beside it answer. */
+  .fgroup { display: inline-flex; align-items: center; gap: 6px; }
+  .fgroup-label { font-size: 11px; font-weight: 600; text-transform: uppercase; letter-spacing: 0.04em; color: var(--muted-2); margin-right: 2px; }
   .fchip { border: 1px solid var(--border-strong); background: var(--surface); border-radius: 999px; padding: 5px 12px; font-size: 12.5px; color: var(--muted); }
   .fchip[aria-pressed="true"] { background: var(--accent); color: var(--accent-fg); border-color: var(--accent); }
   .fchip .fcount { margin-left: 6px; font-variant-numeric: tabular-nums; color: var(--muted-2); }
@@ -19335,35 +19366,24 @@ const CSS = `
   .badge.norec { background: var(--amber-bg); color: var(--amber); border-color: var(--amber-border); }
   .badge.norec .d { background: var(--amber); }
 
-  /* "Needs re-run" (ADR-0010). Four distinct looks on purpose: rr-unknown must
-     never be mistaken for rr-notneeded, so it takes the info hue rather than a
-     dimmed green, and every badge is paired with a .cellsub saying what the
-     verdict rests on.
-
-     The drift column (dr-*) answers a different question — does the spec
-     still describe the code, not whether the last result is stale — but
-     reuses these same three hues so the two columns read as siblings rather
-     than inventing a fourth palette: dr-found (a diagnosis exists) shares
-     rr-needed's amber, dr-clean (audited, no drift) shares rr-notneeded's
-     green, dr-none (never audited) shares rr-none's grey. */
-  .badge.rr-needed, .badge.dr-found { background: var(--amber-bg); color: var(--amber); border-color: var(--amber-border); }
-  .badge.rr-needed .d, .badge.dr-found .d { background: var(--amber); }
-  .badge.rr-notneeded, .badge.dr-clean { background: var(--pass-bg); color: var(--pass); border-color: var(--pass-border); }
-  .badge.rr-notneeded .d, .badge.dr-clean .d { background: var(--pass); }
-  /* Same blue on both axes: "we cannot say" means the same thing whether the
-     question is re-run or drift, and a reader should not have to relearn it. */
-  .badge.rr-unknown, .badge.dr-unknown { background: var(--info-bg); color: var(--info); border-color: var(--info-border); }
-  .badge.rr-unknown .d, .badge.dr-unknown .d { background: var(--info); }
-  .badge.rr-none, .badge.dr-none { background: var(--surface-3); color: var(--muted); border-color: var(--border); }
-  .badge.rr-none .d, .badge.dr-none .d { background: var(--muted); }
+  /* Shared by the verdict and audit columns (ADR-0010, ADR-0014): rr-unknown
+     must never be mistaken for a clean rr-none, so it takes the info hue
+     rather than a dimmed grey, and every badge is paired with a .cellsub
+     saying what it rests on. */
+  .badge.rr-needed { background: var(--amber-bg); color: var(--amber); border-color: var(--amber-border); }
+  .badge.rr-needed .d { background: var(--amber); }
+  .badge.rr-unknown { background: var(--info-bg); color: var(--info); border-color: var(--info-border); }
+  .badge.rr-unknown .d { background: var(--info); }
+  .badge.rr-none { background: var(--surface-3); color: var(--muted); border-color: var(--border); }
+  .badge.rr-none .d { background: var(--muted); }
   .cellsub { display: block; margin-top: 3px; max-width: 260px; color: var(--muted); font-size: 11.5px; line-height: 1.45; }
   .graded-mark { color: var(--fg-dim); font-weight: 600; }
   .cellsub a { color: var(--muted); text-decoration: none; border-bottom: 1px dotted var(--border-strong); }
   .cellsub a:hover { color: var(--fg); }
   .persp-note { margin-bottom: 12px; }
   .persp-head { font-size: 12px; white-space: nowrap; }
-  /* The Perspectives toolbar carries search + five chips + the profile
-     selector, so it wraps instead of overflowing on a narrow window. */
+  /* The Perspectives toolbar carries search + two filter-chip groups + the
+     profile selector, so it wraps instead of overflowing on a narrow window. */
   #view-perspectives .toolbar { flex-wrap: wrap; }
   .proj-menu.right { left: auto; right: 0; }
   .d-note { margin-top: 12px; max-width: 900px; }
@@ -19510,15 +19530,14 @@ const CLIENT_JS = `
       "perspectives.search": "Search cases…",
       "perspectives.filter.all": "All", "perspectives.filter.deterministic": "Deterministic",
       "perspectives.filter.live": "Live",
-      "perspectives.filter.rerun": "Needs re-run only", "perspectives.filter.drift": "Drift found only",
-      "perspectives.col.verdict": "Next", "perspectives.col.audit": "Audit",
-      "perspectives.col.run": "Execution", "perspectives.col.drift": "Drift audit",
+      "perspectives.filter.group.mode": "Mode",
+      "perspectives.col.verdict": "Verdict", "perspectives.col.audit": "Audit",
+      "perspectives.col.run": "Execution",
       "perspectives.audit.state.due": "Audit due",
       "perspectives.audit.state.clean": "Describes the code",
       "perspectives.audit.state.drifted": "Drifted",
       "perspectives.audit.state.undecided": "Couldn't tell",
-      "perspectives.audit.state.cannotTell": "Can't tell",
-      "perspectives.run.state.needed": "re-run needed", "perspectives.run.state.unknown": "can't tell",
+      "perspectives.run.state.superseded": "pending",
       "perspectives.run.state.failed": "failed", "perspectives.run.state.passed": "passed",
       "perspectives.run.state.never": "never run",
       "perspectives.col.case": "Case", "perspectives.col.mode": "Mode",
@@ -19528,7 +19547,6 @@ const CLIENT_JS = `
       "perspectives.loadFailed": "Loading perspectives failed",
       "perspectives.mode.deterministic": "deterministic", "perspectives.mode.live": "live",
       "perspectives.ov.cases": "cases", "perspectives.ov.features": "features",
-      "perspectives.ov.axis.rerun": "Re-run", "perspectives.ov.axis.drift": "Drift",
       "perspectives.d.preconditions": "Preconditions", "perspectives.d.startScreen": "Start screen",
       "perspectives.d.testCondition": "Condition", "perspectives.d.spec": "spec",
       "perspectives.note.label": "Note",
@@ -19537,12 +19555,11 @@ const CLIENT_JS = `
       "perspectives.note.error": "Could not save — retry",
       "perspectives.d.lastRed": "Most recent failure",
       "perspectives.d.changedSince": "Changes since the last run",
-      "perspectives.d.cannotJudge": "Why this cannot be judged",
+      "perspectives.d.whyVerdict": "Why this verdict",
       "perspectives.result.openRun": "Open this run in the hub",
       "perspectives.result.ci": "CI",
       "perspectives.rerun.state.needsRepair": "Needs repair",
       "perspectives.rerun.state.rerunNeeded": "Re-run needed",
-      "perspectives.rerun.state.unanswerable": "Can't tell",
       "perspectives.rerun.state.inProgress": "In progress",
       "perspectives.rerun.state.verified": "Verified",
       "perspectives.rerun.vsDeploy": "judged against deploy",
@@ -19553,11 +19570,11 @@ const CLIENT_JS = `
       "perspectives.rerun.touchedCount": "{n} deployed path(s) matched this case",
       "perspectives.rerun.touchedUnknown": "a deploy since the last run matched this case",
       "perspectives.rerun.inProgressHint": "an audit or a run is still going, or the audit has not caught up with the deploy",
+      "perspectives.rerun.heldHint": "another job already holds this spec — acting on it now would race that job",
       "perspectives.rerun.repair.testDrift": "the generated test no longer matches the code — re-record it",
       "perspectives.rerun.repair.specChange": "the spec describes something the code no longer does — a human decides",
       "perspectives.rerun.repair.auditUndecided": "the audit read the code and could not decide — a human looks",
       "perspectives.rerun.repair.runFailed": "the last run failed — re-running it changes nothing until the cause is fixed",
-      "perspectives.rerun.why.notEvaluated": "no run and no deploy has ever been recorded for this profile",
       "perspectives.rerun.why.noSelectionInRange": "a deploy in range was recorded without a spec selection",
       "perspectives.rerun.why.selectionUnknown": "the selector could not tell whether this case was affected",
       "perspectives.rerun.why.noDeployLog": "no deploy log for this profile",
@@ -19566,7 +19583,6 @@ const CLIENT_JS = `
       "perspectives.rerun.why.deployedShaNotInLog": "the last run's commit predates the retained deploy log",
       "perspectives.rerun.why.gapInRange": "deploys are missing from the range",
       "perspectives.rerun.why.unrecognized": "this hub reported a reason this UI does not recognise",
-      "perspectives.rerun.fix.notEvaluated": "Nothing has been recorded for this profile at all. Wire ccqa hub deploy record into the deploy job and push a run report, so there is something to compare against.",
       "perspectives.rerun.fix.noSelectionInRange": "A deploy in range was recorded without a spec selection, so nothing says whether it affected this case. Run ccqa select-specs in the deploy job and send its verdict with the deploy.",
       "perspectives.rerun.fix.selectionUnknown": "A deploy in range was judged, but the selector could not decide this case. Re-run it to get a clean baseline.",
       "perspectives.rerun.fix.noDeployLog": "Nothing has been recorded in this profile's deploy log. Wire ccqa hub deploy record into the deploy job for this environment so ccqa knows what shipped.",
@@ -19579,12 +19595,7 @@ const CLIENT_JS = `
       "perspectives.rerun.loadFailed": "Loading re-run data failed",
       "perspectives.rerun.noDeployLogBanner": "No deploy has been recorded for profile {profile}, so no case can be judged. Wire ccqa hub deploy record into the deploy job for this environment.",
       "perspectives.rerun.deployHead": "deploy head",
-      "perspectives.drift.state.notAudited": "Not audited",
-      "perspectives.drift.state.clean": "No drift",
-      "perspectives.drift.state.found": "Drift found", "perspectives.drift.state.unknown": "Can't tell",
       "perspectives.drift.graded": "confirmed",
-      "perspectives.drift.unsupported": "This hub does not report drift audit results. Upgrade the hub to enable it.",
-      "perspectives.drift.loadFailed": "Loading drift data failed",
       "prompt.card.record": "Recording browser actions",
       "prompt.card.live": "Live run (AI-driven)",
       "prompt.card.playwright": "Playwright test generation",
@@ -19676,15 +19687,14 @@ const CLIENT_JS = `
       "perspectives.search": "ケースを検索…",
       "perspectives.filter.all": "すべて", "perspectives.filter.deterministic": "決定的",
       "perspectives.filter.live": "ライブ",
-      "perspectives.filter.rerun": "要再実行のみ", "perspectives.filter.drift": "ズレありのみ",
-      "perspectives.col.verdict": "次にすること", "perspectives.col.audit": "監査",
-      "perspectives.col.run": "実行", "perspectives.col.drift": "ドリフト監査",
+      "perspectives.filter.group.mode": "モード",
+      "perspectives.col.verdict": "判定", "perspectives.col.audit": "監査",
+      "perspectives.col.run": "実行",
       "perspectives.audit.state.due": "監査待ち",
-      "perspectives.audit.state.clean": "ずれなし",
-      "perspectives.audit.state.drifted": "ずれあり",
+      "perspectives.audit.state.clean": "ズレなし",
+      "perspectives.audit.state.drifted": "ズレあり",
       "perspectives.audit.state.undecided": "判定不能",
-      "perspectives.audit.state.cannotTell": "判定できない",
-      "perspectives.run.state.needed": "要再実行", "perspectives.run.state.unknown": "判定できない",
+      "perspectives.run.state.superseded": "実行待ち",
       "perspectives.run.state.failed": "失敗", "perspectives.run.state.passed": "合格",
       "perspectives.run.state.never": "未実行",
       "perspectives.col.case": "ケース", "perspectives.col.mode": "モード",
@@ -19694,7 +19704,6 @@ const CLIENT_JS = `
       "perspectives.loadFailed": "テスト観点の読み込みに失敗しました",
       "perspectives.mode.deterministic": "決定的", "perspectives.mode.live": "ライブ",
       "perspectives.ov.cases": "ケース", "perspectives.ov.features": "機能",
-      "perspectives.ov.axis.rerun": "実行", "perspectives.ov.axis.drift": "ドリフト",
       "perspectives.d.preconditions": "前提条件", "perspectives.d.startScreen": "開始画面",
       "perspectives.d.testCondition": "実行条件", "perspectives.d.spec": "spec",
       "perspectives.note.label": "note",
@@ -19703,12 +19712,11 @@ const CLIENT_JS = `
       "perspectives.note.error": "保存に失敗しました — 再試行してください",
       "perspectives.d.lastRed": "直近の失敗",
       "perspectives.d.changedSince": "前回実行以降の変更",
-      "perspectives.d.cannotJudge": "判定できない理由",
+      "perspectives.d.whyVerdict": "この判定の理由",
       "perspectives.result.openRun": "ハブでこの実行を開く",
       "perspectives.result.ci": "CI",
       "perspectives.rerun.state.needsRepair": "修正待ち",
       "perspectives.rerun.state.rerunNeeded": "要再実行",
-      "perspectives.rerun.state.unanswerable": "判定できない",
       "perspectives.rerun.state.inProgress": "進行中",
       "perspectives.rerun.state.verified": "検証済み",
       "perspectives.rerun.vsDeploy": "判定基準: デプロイ",
@@ -19719,11 +19727,11 @@ const CLIENT_JS = `
       "perspectives.rerun.touchedCount": "このケースに一致したデプロイ差分 {n} 件",
       "perspectives.rerun.touchedUnknown": "前回実行以降のデプロイがこのケースに一致する変更を行っています",
       "perspectives.rerun.inProgressHint": "監査か実行がまだ走っているか、監査がデプロイに追いついていません",
+      "perspectives.rerun.heldHint": "このスペックは既に別のジョブが保持しています。今操作するとそのジョブと競合します",
       "perspectives.rerun.repair.testDrift": "生成されたテストが古くなっています。録り直してください",
       "perspectives.rerun.repair.specChange": "spec がコードのやめた動作を書いています。人が判断します",
       "perspectives.rerun.repair.auditUndecided": "監査がコードを読んだうえで判定できませんでした。人が見ます",
       "perspectives.rerun.repair.runFailed": "最後の実行が落ちています。原因を直すまで再実行しても変わりません",
-      "perspectives.rerun.why.notEvaluated": "このプロファイルには実行もデプロイも記録がありません",
       "perspectives.rerun.why.noSelectionInRange": "対象範囲に判定を伴わないデプロイがあります",
       "perspectives.rerun.why.selectionUnknown": "影響の有無を判定できませんでした",
       "perspectives.rerun.why.noDeployLog": "このプロファイルのデプロイ記録がありません",
@@ -19732,7 +19740,6 @@ const CLIENT_JS = `
       "perspectives.rerun.why.deployedShaNotInLog": "前回実行のcommitが保持中のデプロイログより古いです",
       "perspectives.rerun.why.gapInRange": "対象範囲のデプロイ記録が欠けています",
       "perspectives.rerun.why.unrecognized": "このUIが認識できない理由がハブから返されました",
-      "perspectives.rerun.fix.notEvaluated": "このプロファイルには何も記録がありません。デプロイジョブに ccqa hub deploy record を組み込み、実行レポートを送ってください。比較する対象がそこで初めて生まれます。",
       "perspectives.rerun.fix.noSelectionInRange": "対象範囲に判定を伴わないデプロイがあり、このケースに影響したかどうかを示すものがありません。デプロイジョブで ccqa select-specs を実行し、判定をデプロイと一緒に送ってください。",
       "perspectives.rerun.fix.selectionUnknown": "対象範囲のデプロイは判定されましたが、このケースについては判断がつきませんでした。再実行して基準を取り直してください。",
       "perspectives.rerun.fix.noDeployLog": "このプロファイルのデプロイログに記録がありません。何がデプロイされたかをccqaに伝えるため、この環境のデプロイジョブに ccqa hub deploy record を組み込んでください。",
@@ -19745,12 +19752,7 @@ const CLIENT_JS = `
       "perspectives.rerun.loadFailed": "再実行の要否の読み込みに失敗しました",
       "perspectives.rerun.noDeployLogBanner": "プロファイル {profile} にデプロイの記録がないため、どのケースも判定できません。この環境のデプロイジョブに ccqa hub deploy record を組み込んでください。",
       "perspectives.rerun.deployHead": "最新デプロイ",
-      "perspectives.drift.state.notAudited": "未監査",
-      "perspectives.drift.state.clean": "ズレなし",
-      "perspectives.drift.state.found": "ズレあり", "perspectives.drift.state.unknown": "判定できない",
       "perspectives.drift.graded": "人が確認",
-      "perspectives.drift.unsupported": "このハブはdrift監査結果を返しません。利用するにはハブを更新してください。",
-      "perspectives.drift.loadFailed": "drift監査結果の読み込みに失敗しました",
       "prompt.card.record": "ブラウザ操作の記録",
       "prompt.card.live": "ライブ実行（AI操作）",
       "prompt.card.playwright": "Playwrightテスト生成",
@@ -21612,13 +21614,14 @@ const CLIENT_JS = `
 
   // "rerun" is the RerunReport for the currently selected profile, or null when
   // this hub can't answer (older hub, or the fetch failed) — in which case the
-  // two re-run columns are dropped rather than filled with blanks.
+  // three re-run columns are dropped rather than filled with blanks.
   // "rerunSupported" is tri-state: null until the first answer, then whether
   // this hub answers at all. Chip visibility follows it rather than the report,
   // so switching profile doesn't drop the filter while the next one loads.
   // "drift" is the DriftLedgerResponse, or null when unanswered (older hub, or
   // a failed fetch) — not profile-scoped, so it does not reset when the
-  // profile switcher changes (unlike "rerun" above).
+  // profile switcher changes (unlike "rerun" above). Only feeds the audit
+  // column's "audited at" line now; its own finding is superseded by rr.audit.
   var perspState = {
     doc: null, q: "", f: "all",
     rerun: null, rerunSupported: null, runUrls: {}, rerunProfiles: [],
@@ -21655,11 +21658,11 @@ const CLIENT_JS = `
       "/rerun?profile=" + encodeURIComponent(state.profile);
   }
 
-  // Shared by rerun and drift, which differ only in path and i18n prefix.
   // Resolves { report } or { note } and never rejects: a hub that predates
-  // the endpoint costs only that column, not the whole tab. A 404 here can
-  // only mean "no such route" — the endpoint's own 404 is "the project has no
-  // perspectives document", and this runs only after that document loaded.
+  // the endpoint costs only the columns it feeds, not the whole tab. A 404
+  // here can only mean "no such route" — the endpoint's own 404 is "the
+  // project has no perspectives document", and this runs only after that
+  // document loaded.
   function fetchLedgerColumn(path, i18nPrefix) {
     return fetch(path, { headers: { Authorization: "Bearer " + state.token } }).then(function (res) {
       if (res.status === 404) return { note: t(i18nPrefix + "unsupported"), kind: "info" };
@@ -21674,7 +21677,10 @@ const CLIENT_JS = `
 
   // ── perspectives: drift ledger ────────────────────────────────────────
   // Not profile-scoped (see perspState.drift above), so unlike rerunPath this
-  // takes no ?profile=.
+  // takes no ?profile=. Its own finding is superseded by the audit axis in
+  // the /rerun report (ADR-0014); what survives into the view is only its
+  // coordinate — when a spec was last audited — folded into the audit
+  // column's evidence line (perspAuditCell).
 
   function driftPath() {
     return "/api/v1/projects/" + encodeURIComponent(state.project) + "/drift";
@@ -21726,16 +21732,25 @@ const CLIENT_JS = `
     return text === prefix + reason ? t(prefix + "unrecognized") : text;
   }
 
-  // Why the question cannot be answered, in the actionable phrasing the detail
-  // panel wants: name the missing input and how to supply it. Only
-  // "unanswerable" carries a machine-readable reason (ADR-0010).
-  // Every verdict that carries no evidence row explains itself here. A verdict
-  // a newer hub invented falls through to the fix lookup, so the row says the
-  // UI cannot read it rather than going blank — which looks like missing data.
-  function rerunCannotJudge(rr) {
-    if (rr.verdict === "unanswerable") return rerunReasonText("perspectives.rerun.fix.", rr.reason || "");
+  // Every verdict that carries no evidence row explains itself here, in the
+  // actionable phrasing the detail panel wants. decide() checks heldBy before
+  // the audit axis, so a spec another job already holds must be explained by
+  // that hold, not by the audit-hole annotation below — which only applies to
+  // an "inProgress" verdict that decide() reached by falling through to a due
+  // audit (ADR-0014). A verdict a newer hub invented falls through to the fix
+  // lookup, so the row says the UI cannot read it rather than going blank —
+  // which looks like missing data.
+  function rerunWhyVerdict(rr) {
     if (rr.verdict === "needsRepair") return rerunReasonText("perspectives.rerun.repair.", rerunRepairCause(rr));
-    if (rr.verdict === "inProgress") return t("perspectives.rerun.inProgressHint");
+    if (rr.verdict === "rerunNeeded" && rr.executionAssumedReached) {
+      return rerunReasonText("perspectives.rerun.fix.", rr.executionAssumedReached);
+    }
+    if (rr.verdict === "inProgress") {
+      if (rr.heldBy) return t("perspectives.rerun.heldHint");
+      return rr.auditAssumedReached
+        ? rerunReasonText("perspectives.rerun.fix.", rr.auditAssumedReached)
+        : t("perspectives.rerun.inProgressHint");
+    }
     return rerunReasonText("perspectives.rerun.fix.", rr.verdict);
   }
 
@@ -21750,10 +21765,12 @@ const CLIENT_JS = `
 
   // The short justification a table cell carries under its badge. Nothing here
   // may collapse to a bare "up to date" — verified names the deploy it was
-  // judged against, and unanswerable names the missing input.
+  // judged against, and a spec assumed reached names the hole that made it so
+  // rather than claiming a deploy matched it.
   function rerunCellWhy(rr) {
     var head = perspState.rerun && perspState.rerun.deployHead;
     if (rr.verdict === "rerunNeeded") {
+      if (rr.executionAssumedReached) return rerunReasonText("perspectives.rerun.why.", rr.executionAssumedReached);
       if (!rr.touchedBy || !rr.touchedBy.length) return t("perspectives.rerun.touchedUnknown");
       return t("perspectives.rerun.touchedCount").replace("{n}", String(rr.touchedBy.length));
     }
@@ -21761,8 +21778,7 @@ const CLIENT_JS = `
       if (!head) return t("perspectives.rerun.noDeployHead");
       return t("perspectives.rerun.vsDeploy") + " " + shortSha(head.sha) + " · " + relTime(head.at);
     }
-    if (rr.verdict === "unanswerable") return rerunReasonText("perspectives.rerun.why.", rr.reason || "");
-    return rerunCannotJudge(rr);
+    return rerunWhyVerdict(rr);
   }
 
 
@@ -21775,27 +21791,26 @@ const CLIENT_JS = `
   // Bar segments in drawing order: what a person must act on first, then what
   // the pipeline still owes, then what needs nothing. "needsRepair" leads
   // because it is the only verdict a run cannot clear — someone has to repair
-  // the spec or the product. "unanswerable" keeps its own place and its own
-  // colour: folding it into "verified" would turn "we cannot say" into "all
-  // clear", which is what ADR-0010 forbids.
-  var RERUN_ORDER = ["needsRepair", "rerunNeeded", "unanswerable", "inProgress", "verified"];
+  // the spec or the product.
+  var RERUN_ORDER = ["needsRepair", "rerunNeeded", "inProgress", "verified"];
   var RERUN_SEG_CLASS = {
-    needsRepair: "sg-needsrepair", rerunNeeded: "sg-rerunneeded", unanswerable: "sg-unanswerable",
+    needsRepair: "sg-needsrepair", rerunNeeded: "sg-rerunneeded",
     inProgress: "sg-inprogress", verified: "sg-verified"
   };
 
-  // One verdict per case, bucketed. A case with no verdict at all — this hub
-  // does not answer the question, the fetch failed, or the case was added
-  // after the report was computed — is unanswerable, never "verified". A
-  // verdict this UI does not know reads the same way for the same reason: an
-  // answer we cannot interpret is not evidence that nothing is needed.
+  // The one rule the summary bar and the verdict filter chips both answer
+  // to: a case with no verdict, or a verdict a newer hub invented, counts as
+  // needing a run — unanswered means unverified (ADR-0014). Both call this
+  // rather than each keeping its own copy of the fallback.
+  function rerunVerdictOf(rr) {
+    var v = rr && rr.verdict;
+    return v && RERUN_ORDER.indexOf(v) !== -1 ? v : "rerunNeeded";
+  }
+
+  // One verdict per case, bucketed, via rerunVerdictOf above.
   function rerunComposition(verdicts) {
-    var counts = { needsRepair: 0, rerunNeeded: 0, unanswerable: 0, inProgress: 0, verified: 0 };
-    verdicts.forEach(function (rr) {
-      if (!rr || !rr.verdict) { counts.unanswerable += 1; return; }
-      var known = Object.prototype.hasOwnProperty.call(counts, rr.verdict);
-      counts[known ? rr.verdict : "unanswerable"] += 1;
-    });
+    var counts = { needsRepair: 0, rerunNeeded: 0, inProgress: 0, verified: 0 };
+    verdicts.forEach(function (rr) { counts[rerunVerdictOf(rr)] += 1; });
     return counts;
   }
 
@@ -21811,52 +21826,69 @@ const CLIENT_JS = `
   }
   // --- end pure: rerun composition -----------------------------------------
 
-  // --- pure: drift composition ----------------------------------------------
-  // Same shape as rerun composition above, and self-contained for the same
-  // reason: drift-overview.test.ts lifts this region out and runs it directly.
-  // Unlike rerun, drift does not split by label at the overview level — each
-  // spec carries at most one diagnosis already. UNKNOWN is the exception, and
-  // it earns its own state rather than a label: it is the audit saying it could
-  // not tell, so counting it as "drift found" would assert a mismatch nobody
-  // established, and counting it as clean would hide one. Four states, three of
-  // which the ledger distinguishes structurally:
-  //
-  //   no entry      → never audited
-  //   null label    → audited, nothing found
-  //   UNKNOWN label → audited, could not tell
-  //   other label   → audited, drift found
-  function driftState(entry) {
-    if (!entry) return "notAudited";
-    if (!entry.label) return "clean";
-    return entry.label === "UNKNOWN" ? "unknown" : "found";
+  // --- pure: execution composition ------------------------------------------
+  // Same shape as rerun composition above, self-contained for the same
+  // reason, and read from the same rr records: bucketed by the execution
+  // axis rather than the derived verdict. The mapping duplicates
+  // perspRunState's two renames (neverRun -> never, stale -> superseded)
+  // rather than calling it, so this region stays independently liftable.
+  var EXEC_ORDER = ["failed", "superseded", "never", "passed"];
+  var EXEC_SEG_CLASS = {
+    failed: "sg-exec-failed", superseded: "sg-exec-stale",
+    never: "sg-exec-never", passed: "sg-exec-passed"
+  };
+
+  // A case with no verdict at all reads as never run — same "unanswered
+  // means unverified" rule rerunComposition applies, and the safe direction:
+  // it never inflates "passed".
+  function executionComposition(records) {
+    var counts = { failed: 0, superseded: 0, never: 0, passed: 0 };
+    records.forEach(function (rr) {
+      var exec = rr && rr.execution;
+      var key = !exec || exec === "neverRun" ? "never" : exec === "stale" ? "superseded" : exec;
+      counts[Object.prototype.hasOwnProperty.call(counts, key) ? key : "never"] += 1;
+    });
+    return counts;
   }
 
-  // Drawing order: what needs a look first, then what could not be judged, then
-  // what was never audited, then confirmed clean — same reasoning as
-  // RERUN_ORDER above.
-  var DRIFT_ORDER = ["found", "unknown", "notAudited", "clean"];
-  var DRIFT_SEG_CLASS = {
-    found: "sg-drift-found",
-    unknown: "sg-drift-unknown",
-    notAudited: "sg-drift-none",
-    clean: "sg-drift-clean",
+  // Only states with cases in them get drawn — see rerunSegments' comment above.
+  function executionSegments(counts) {
+    var out = [];
+    EXEC_ORDER.forEach(function (key) {
+      if (counts[key] > 0) out.push({ state: key, count: counts[key], cls: EXEC_SEG_CLASS[key] });
+    });
+    return out;
+  }
+  // --- end pure: execution composition --------------------------------------
+
+  // --- pure: audit composition -----------------------------------------------
+  // Same shape again, bucketed by the audit axis (ADR-0014).
+  var AUDIT_ORDER = ["drifted", "undecided", "due", "clean"];
+  var AUDIT_SEG_CLASS = {
+    drifted: "sg-audit-drifted", undecided: "sg-audit-undecided",
+    due: "sg-audit-due", clean: "sg-audit-clean"
   };
 
-  function driftComposition(entries) {
-    var counts = { found: 0, unknown: 0, notAudited: 0, clean: 0 };
-    entries.forEach(function (entry) { counts[driftState(entry)] += 1; });
+  // A case with no audit axis at all reads as due — the same "unanswered
+  // means not yet cleared" rule as the other two axes.
+  function auditComposition(records) {
+    var counts = { drifted: 0, undecided: 0, due: 0, clean: 0 };
+    records.forEach(function (rr) {
+      var key = (rr && rr.audit) || "due";
+      counts[Object.prototype.hasOwnProperty.call(counts, key) ? key : "due"] += 1;
+    });
     return counts;
   }
 
   // Only states with cases in them get drawn — see rerunSegments' comment above.
-  function driftSegments(counts) {
+  function auditSegments(counts) {
     var out = [];
-    DRIFT_ORDER.forEach(function (key) {
-      if (counts[key] > 0) out.push({ state: key, count: counts[key], cls: DRIFT_SEG_CLASS[key] });
+    AUDIT_ORDER.forEach(function (key) {
+      if (counts[key] > 0) out.push({ state: key, count: counts[key], cls: AUDIT_SEG_CLASS[key] });
     });
     return out;
   }
-  // --- end pure: drift composition -------------------------------------------
+  // --- end pure: audit composition --------------------------------------------
 
   // One ledger entry as "<short sha> · <when>", linking to the hub's run detail
   // and, when that run recorded one, to the CI run. Clicks must not bubble: the
@@ -21914,30 +21946,34 @@ const CLIENT_JS = `
   // still true" are two faces of one question, so the row answers it once and
   // the detail panel keeps the coordinates.
   //
-  // A needed re-run outranks a recorded failure: once the last result is known
-  // to be stale it is no longer a verdict, and what to do next is the same
-  // either way — run it. Reporting "failed" there would be describing a result
-  // nobody should still be acting on.
+  // --- pure: run-state labels ----------------------------------------------
+  // Self-contained (no DOM, no closures) so rerun-view.test.ts can lift it and
+  // check that every execution value the hub can send has a badge and wording.
+
+  // A recorded failure outranks the deploy that landed after it: a red result
+  // is current information, and repeating it teaches nothing until someone
+  // repairs it.
   //
-  // "unknown" keeps its own state rather than folding into the last result:
-  // it means the hub cannot say whether that result still holds, and
-  // --only-hub-rerun-needed does not re-run it without --only-hub-rerun-needed-with-unknown. Showing
-  // it as passed or failed would claim a confidence nothing supports.
+  // The wording keys are not the axis values: ADR-0010 reserves the freshness
+  // adjectives for drift, so what the schema calls "stale" is shown as what it
+  // means for this case — it has not run since the deploy.
   function perspRunState(rr) {
     if (!rr || !rr.execution) return null;
-    return rr.execution === "neverRun" ? "never" : rr.execution;
+    if (rr.execution === "neverRun") return "never";
+    return rr.execution === "stale" ? "superseded" : rr.execution;
   }
 
   // Reuses the badge classes that already mean these things elsewhere rather
-  // than minting a parallel palette: amber for "act on this", info for "cannot
-  // say", and the run status colours for a result that still stands.
-  var RUN_STATE_BADGE = { failed: "failed", passed: "passed", never: "rr-none" };
+  // than minting a parallel palette: amber for "act on this", and the run
+  // status colours for a result that still stands.
+  var RUN_STATE_BADGE = { failed: "failed", passed: "passed", superseded: "rr-needed", never: "rr-none" };
+  // --- end pure: run-state labels -------------------------------------------
 
   // The primary column. The two axes beside it answer "why"; this one answers
   // "who acts next", which is the only question a reader scanning a list of
   // specs has. Exactly one value, needsRepair, asks for a person.
   var VERDICT_BADGE = {
-    needsRepair: "rr-needed", rerunNeeded: "rr-needed", unanswerable: "rr-unknown",
+    needsRepair: "rr-needed", rerunNeeded: "rr-needed",
     inProgress: "rr-none", verified: "passed"
   };
 
@@ -21957,15 +21993,28 @@ const CLIENT_JS = `
     return td;
   }
 
-  // Axis 1, as the hub derived it against the deployed commit — which is not
-  // the same as the raw drift ledger beside it, whose verdict may predate the
-  // deploy.
+  // A reason that pinned a spec to a pending state without a demonstrable
+  // deploy touch (ADR-0014, auditAssumedReached / executionAssumedReached).
+  // The short form is always visible as a .cellsub; the title attribute
+  // carries the longer, actionable form for hover, so what closes the hole
+  // is available without depending on a pointer to find it.
+  function assumedReachedSub(reason) {
+    var sub = el("span", "cellsub", rerunReasonText("perspectives.rerun.why.", reason));
+    sub.title = rerunReasonText("perspectives.rerun.fix.", reason);
+    return sub;
+  }
+
+  // Axis 1, as the hub derived it against the deployed commit — fresher than
+  // the raw drift ledger, whose entry may predate the deploy. The ledger
+  // survives here only as the "audited at" coordinate (ledgerLine below):
+  // its own finding is superseded by rr.audit/rr.driftLabel above, so
+  // showing both would repeat one answer in two vocabularies — the bug this
+  // column used to have paired with a since-removed fourth column.
   var AUDIT_BADGE = {
-    due: "rr-none", clean: "passed", drifted: "failed",
-    undecided: "rr-unknown", cannotTell: "rr-unknown"
+    due: "rr-none", clean: "passed", drifted: "failed", undecided: "rr-unknown"
   };
 
-  function perspAuditCell(rr) {
+  function perspAuditCell(rr, driftEntry) {
     var td = el("td");
     if (!rr || !rr.audit) {
       td.appendChild(el("span", "muted", "\u2014"));
@@ -21977,6 +22026,23 @@ const CLIENT_JS = `
     td.appendChild(badge);
     if (rr.audit === "drifted" && rr.driftLabel) {
       td.appendChild(el("span", "cellsub", labelText(rr.driftLabel)));
+    } else if (rr.auditAssumedReached) {
+      // Due because the log could not place the audit, not because a deploy
+      // demonstrably reached it. Say which, or the whole column reads "due"
+      // with no cause anywhere on the page.
+      td.appendChild(assumedReachedSub(rr.auditAssumedReached));
+    }
+    // "audited at sha · when" — the same freshness evidence the execution
+    // column gives its own last result, below. SpecRerun does not carry the
+    // audit's own coordinate, so it comes from the drift ledger.
+    if (driftEntry) {
+      var sub = el("span", "cellsub");
+      sub.appendChild(ledgerLine(driftEntry));
+      if (driftEntry.graded) {
+        sub.appendChild(document.createTextNode(" · "));
+        sub.appendChild(el("span", "graded-mark", t("perspectives.drift.graded")));
+      }
+      td.appendChild(sub);
     }
     return td;
   }
@@ -21987,7 +22053,7 @@ const CLIENT_JS = `
     // No verdict at all: this case is in the document but not in the report
     // (added since it was computed). Not the same statement as "never run".
     if (!runState) {
-      td.appendChild(el("span", "muted", "—"));
+      td.appendChild(el("span", "muted", "\u2014"));
       return td;
     }
     var badge = el("span", "badge " + RUN_STATE_BADGE[runState]);
@@ -21995,8 +22061,11 @@ const CLIENT_JS = `
     badge.appendChild(document.createTextNode(" " + t("perspectives.run.state." + runState)));
     td.appendChild(badge);
 
-    // The sub-line is the coordinate of the result being reported. Why it
-    // matters belongs to the verdict column, not here.
+    // The sub-line is the coordinate of the result being reported — the same
+    // "when is this from" evidence the audit column carries above, so the two
+    // axes read as siblings. Why the currency matters belongs to the verdict
+    // column, except for the hole that pinned this to "pending" with no
+    // deploy to point at.
     if (runState !== "never") {
       var last = lastResult(rr);
       if (last) {
@@ -22005,53 +22074,7 @@ const CLIENT_JS = `
         td.appendChild(sub);
       }
     }
-    return td;
-  }
-
-  // ── perspectives: drift ledger ────────────────────────────────────────
-  // "Does this case still describe the product?" — a different question from
-  // re-run above, and shown as its own column rather than folded into it.
-  // Unlike re-run, drift carries no profile: an audit is a property of the
-  // code at a commit, not of an environment, so this column never changes
-  // when the profile switcher above it does.
-
-  var DRIFT_BADGE_CLASS = { notAudited: "dr-none", clean: "dr-clean", found: "dr-found", unknown: "dr-unknown" };
-
-  // driftState() lives with driftComposition/driftSegments above (the "pure:
-  // drift composition" region) — the badge must not collapse "never audited"
-  // and "audited, no drift found" into one grey, same reasoning either way.
-  function driftBadge(state) {
-    var span = el("span", "badge " + (DRIFT_BADGE_CLASS[state] || "dr-none"));
-    span.appendChild(el("span", "d"));
-    span.appendChild(document.createTextNode(" " + t("perspectives.drift.state." + state)));
-    return span;
-  }
-
-  function perspDriftCell(entry) {
-    var td = el("td");
-    td.appendChild(driftBadge(driftState(entry)));
-    if (entry) {
-      var sub = el("span", "cellsub");
-      // The label and surface go here only when they add to the badge. A clean
-      // audit has neither. An UNKNOWN one has both on paper, but the badge
-      // already says "could not tell" — repeating it as a label says the same
-      // thing in a second wording, and naming the surface it could not judge
-      // claims more than the audit found.
-      if (entry.label && driftState(entry) === "found") {
-        sub.appendChild(document.createTextNode(
-          labelText(entry.label) + (entry.surface ? " (" + t("diag.surface." + entry.surface) + ")" : "") + " · ",
-        ));
-      }
-      sub.appendChild(ledgerLine(entry));
-      // A verdict someone has looked at is worth more than one nobody has, in
-      // both directions: a confirmed finding is real, and a confirmed clean is
-      // not just "the audit found nothing".
-      if (entry.graded) {
-        sub.appendChild(document.createTextNode(" · "));
-        sub.appendChild(el("span", "graded-mark", t("perspectives.drift.graded")));
-      }
-      td.appendChild(sub);
-    }
+    if (rr.executionAssumedReached) td.appendChild(assumedReachedSub(rr.executionAssumedReached));
     return td;
   }
 
@@ -22105,45 +22128,47 @@ const CLIENT_JS = `
     return row;
   }
 
-  // Summary: the inventory as one line, then one row per axis — the two
-  // questions this tab answers, needs-re-run and drift, each segmented on its
-  // own bar rather than blended into one. The mode and recorded-ness counts
-  // are not lost; they moved onto the filter chips, where a count states what
-  // that filter would leave behind.
+  // Summary: the inventory as one line, then one row per axis — verdict,
+  // execution, audit, the same three groupings the table's columns show, so
+  // the bars and the table never disagree about what a word means. The mode
+  // and recorded-ness counts are not lost; they moved onto the filter chips,
+  // where a count states what that filter would leave behind.
   //
   // With no re-run data (an older hub, a failed fetch, or a profile nothing
-  // has been recorded on) every case is "not evaluated" and the bar says so in
-  // one neutral segment, rather than showing a composition that reads as
-  // "nothing to do". Drift has no profile and loads separately (loadDrift):
-  // when it hasn't (older hub, failed fetch), its row is omitted entirely
-  // rather than drawn as "all not audited" — that would read as a finding
-  // instead of missing data.
+  // has been recorded on) every case is "not evaluated" and all three bars
+  // are omitted together, rather than showing a composition that reads as
+  // "nothing to do".
   function renderPerspOverview(doc) {
     var host = document.getElementById("persp-ov");
     clear(host);
-    var verdicts = [];
-    var driftEntries = perspState.drift ? [] : null;
+    var records = [];
     doc.features.forEach(function (feature) {
       feature.specs.forEach(function (spec) {
-        verdicts.push(ledgerEntryFor(perspState.rerun, feature, spec));
-        if (driftEntries) driftEntries.push(ledgerEntryFor(perspState.drift, feature, spec));
+        records.push(ledgerEntryFor(perspState.rerun, feature, spec));
       });
     });
 
     var inv = el("div", "ov-inv");
-    inv.appendChild(el("b", null, String(verdicts.length)));
+    inv.appendChild(el("b", null, String(records.length)));
     inv.appendChild(document.createTextNode(" " + t("perspectives.ov.cases") + " / "));
     inv.appendChild(el("b", null, String(doc.features.length)));
     inv.appendChild(document.createTextNode(" " + t("perspectives.ov.features")));
     host.appendChild(inv);
-    if (!verdicts.length) return;
+    if (!records.length) return;
 
-    host.appendChild(ovAxisRow(
-      t("perspectives.ov.axis.rerun"), rerunSegments(rerunComposition(verdicts)), "perspectives.rerun.state.", verdicts.length,
-    ));
-    if (driftEntries) {
+    // Gated on the report as a whole: with none, none of the three axes has
+    // anything to compose, and an un-composed bar would paint every case as
+    // needing work — an overstatement about the hub rather than about the
+    // specs.
+    if (perspState.rerun) {
       host.appendChild(ovAxisRow(
-        t("perspectives.ov.axis.drift"), driftSegments(driftComposition(driftEntries)), "perspectives.drift.state.", driftEntries.length,
+        t("perspectives.col.verdict"), rerunSegments(rerunComposition(records)), "perspectives.rerun.state.", records.length,
+      ));
+      host.appendChild(ovAxisRow(
+        t("perspectives.col.run"), executionSegments(executionComposition(records)), "perspectives.run.state.", records.length,
+      ));
+      host.appendChild(ovAxisRow(
+        t("perspectives.col.audit"), auditSegments(auditComposition(records)), "perspectives.audit.state.", records.length,
       ));
     }
   }
@@ -22155,15 +22180,16 @@ const CLIENT_JS = `
   function perspMatches(feature, spec, f) {
     if (f === "deterministic" && perspMode(spec) !== "deterministic") return false;
     if (f === "live" && perspMode(spec) !== "live") return false;
-    if (f === "rerun") {
+    // The verdict chips (same words as RERUN_ORDER/the 判定 column) share
+    // rerunVerdictOf with the summary bar, so an unrecognised verdict is
+    // "rerunNeeded" in both places rather than matching no chip. With no
+    // report at all there is nothing to filter on, so every chip yields
+    // nothing.
+    if (RERUN_ORDER.indexOf(f) !== -1) {
+      if (!perspState.rerun) return false;
       var rr = ledgerEntryFor(perspState.rerun, feature, spec);
-      // Only "needed": "unknown" is not a weaker "probably needed", and
-      // folding it in here would be exactly the overstatement ADR-0010 forbids.
-      if (!rr || rr.verdict !== "rerunNeeded") return false;
+      if (rerunVerdictOf(rr) !== f) return false;
     }
-    // Same asymmetry: an unaudited spec is not a quiet "probably clean", so it
-    // does not belong under a chip that claims to list what drifted.
-    if (f === "drift" && driftState(ledgerEntryFor(perspState.drift, feature, spec)) !== "found") return false;
     if (perspState.q) {
       var hay = (spec.title + " " + (spec.summary || "") + " " + spec.specName).toLowerCase();
       if (hay.indexOf(perspState.q) === -1) return false;
@@ -22186,14 +22212,19 @@ const CLIENT_JS = `
   // lift this region out of the rendered page and run it: which label the
   // panel's evidence row wears, and whether it has a failure row at all.
 
-  // needed/notNeeded put evidence in that row, so it is labelled by the
-  // timeframe the evidence covers. The other three have no evidence to show,
-  // only a missing input to name — a different kind of content, and forcing one
-  // label over both would make one of the two read as a lie.
-  function rerunEvidenceLabelKey(rerunState) {
-    return rerunState === "rerunNeeded" || rerunState === "verified"
-      ? "perspectives.d.changedSince"
-      : "perspectives.d.cannotJudge";
+  // The deploy log answered for this case: the row can show what it holds.
+  // A case the log could not place has no evidence to show even though its
+  // verdict is the same — the assumption is the answer, not a finding.
+  function rerunHasEvidence(rr) {
+    if (rr.verdict === "verified") return true;
+    return rr.verdict === "rerunNeeded" && !rr.executionAssumedReached;
+  }
+
+  // Evidence is labelled by the timeframe it covers; everything else names why
+  // the verdict landed — a different kind of content, and forcing one label
+  // over both would make one of the two read as a lie.
+  function rerunEvidenceLabelKey(rr) {
+    return rerunHasEvidence(rr) ? "perspectives.d.changedSince" : "perspectives.d.whyVerdict";
   }
 
   // The failure row points at a run. With no failure there is nothing to point
@@ -22229,8 +22260,8 @@ const CLIENT_JS = `
   // The label already states the timeframe, so the value never repeats it.
   function rerunEvidenceValue(rr) {
     var wrap = el("div");
-    if (rr.verdict !== "rerunNeeded" && rr.verdict !== "verified") {
-      wrap.appendChild(el("div", "d-prose", rerunCannotJudge(rr)));
+    if (!rerunHasEvidence(rr)) {
+      wrap.appendChild(el("div", "d-prose", rerunWhyVerdict(rr)));
       return wrap;
     }
     // Both states require a non-empty deploy log, so a head-less report
@@ -22280,7 +22311,7 @@ const CLIENT_JS = `
 
     var rr = ledgerEntryFor(perspState.rerun, feature, spec);
     if (rr) {
-      row(rerunEvidenceLabelKey(rr.verdict), rerunEvidenceValue(rr));
+      row(rerunEvidenceLabelKey(rr), rerunEvidenceValue(rr));
       if (rerunHasFailure(rr)) row("perspectives.d.lastRed", ledgerLine(rr.lastRed));
     }
     frag.appendChild(dl);
@@ -22325,14 +22356,12 @@ const CLIENT_JS = `
     var tbody = document.getElementById("persp-tbody");
     clear(tbody);
     // Hiding the <th>s (rather than emitting empty cells) leaves the table
-    // exactly as it was on a hub that cannot answer the re-run/drift question.
+    // exactly as it was on a hub that cannot answer the re-run question.
     var showRerun = perspState.rerun != null;
-    var showDrift = perspState.drift != null;
     document.getElementById("persp-th-verdict").hidden = !showRerun;
     document.getElementById("persp-th-audit").hidden = !showRerun;
     document.getElementById("persp-th-run").hidden = !showRerun;
-    document.getElementById("persp-th-drift").hidden = !showDrift;
-    var cols = 3 + (showRerun ? 3 : 0) + (showDrift ? 1 : 0);
+    var cols = 3 + (showRerun ? 3 : 0);
     var hits = 0;
     doc.features.forEach(function (feature) {
       var specs = feature.specs.filter(function (s) { return perspMatches(feature, s, perspState.f); });
@@ -22364,10 +22393,9 @@ const CLIENT_JS = `
         if (showRerun) {
           var rr = ledgerEntryFor(perspState.rerun, feature, spec);
           row.appendChild(perspVerdictCell(rr));
-          row.appendChild(perspAuditCell(rr));
           row.appendChild(perspRunCell(rr));
+          row.appendChild(perspAuditCell(rr, ledgerEntryFor(perspState.drift, feature, spec)));
         }
-        if (showDrift) row.appendChild(perspDriftCell(ledgerEntryFor(perspState.drift, feature, spec)));
 
         var chevTd = el("td", "c-chev");
         chevTd.appendChild(el("span", "chev-i", "\\u25b6"));
@@ -22410,21 +22438,17 @@ const CLIENT_JS = `
     renderPerspTable(doc);
   }
 
-  // The needs-re-run chip only exists while the hub answers the question;
-  // otherwise it would filter everything away. Drop back to "all" if it was
-  // the active filter when the answer came back "not supported".
+  // The verdict chip group only exists while the hub answers the re-run
+  // question; otherwise every one of them would filter everything away. Drop
+  // back to "all" if one was the active filter when the answer came back
+  // "not supported".
   //
   // Each chip also carries what it would yield — the mode breakdown the
   // summary row used to spend four tiles on.
   function syncPerspChips() {
-    var chip = document.getElementById("persp-chip-rerun");
-    chip.hidden = perspState.rerunSupported !== true;
-    if (perspState.rerunSupported === false && perspState.f === "rerun") perspState.f = "all";
-    // Same rule as the drift column: no ledger, no chip. A chip reading "0"
-    // would say "nothing drifted" when the hub was never asked.
-    var driftChip = document.getElementById("persp-chip-drift");
-    driftChip.hidden = perspState.drift == null;
-    if (perspState.drift == null && perspState.f === "drift") perspState.f = "all";
+    var group = document.getElementById("persp-verdict-chips");
+    group.hidden = perspState.rerunSupported !== true;
+    if (perspState.rerunSupported !== true && RERUN_ORDER.indexOf(perspState.f) !== -1) perspState.f = "all";
     document.querySelectorAll("#view-perspectives .fchip").forEach(function (b) {
       var f = b.getAttribute("data-f");
       b.setAttribute("aria-pressed", String(f === perspState.f));
@@ -22432,7 +22456,8 @@ const CLIENT_JS = `
     });
   }
 
-  // Shared by the rerun and drift notes, which differ only in which box they fill.
+  // boxId is a parameter rather than hardcoded so a future note box can reuse
+  // this without copying it — today only "persp-rerun-note" calls it.
   function setPerspNote(boxId, text, kind) {
     var box = document.getElementById(boxId);
     box.hidden = !text;
@@ -22468,7 +22493,6 @@ const CLIENT_JS = `
     setPerspDeployHead(null);
     perspState.rerun = null;
     perspState.rerunSupported = null;
-    setPerspNote("persp-drift-note", "");
     perspState.drift = null;
     syncPerspChips();
     fetchPerspectives()
@@ -22491,9 +22515,9 @@ const CLIENT_JS = `
           loadRerun().catch(function (err) {
             setPerspNote("persp-rerun-note", t("perspectives.rerun.loadFailed") + ": " + err.message, "warn");
           }),
-          loadDrift().catch(function (err) {
-            setPerspNote("persp-drift-note", t("perspectives.drift.loadFailed") + ": " + err.message, "warn");
-          }),
+          // Evidence-only (the "audited at" line in the audit column) — a
+          // failed or unsupported fetch just omits that line, no banner.
+          loadDrift().catch(function () {}),
         ]);
       })
       .catch(function (err) {
@@ -22506,6 +22530,82 @@ const CLIENT_JS = `
     return state.project + "/" + state.profile;
   }
 
+  // --- pure: data-profile pick ---------------------------------------------
+  // Self-contained on purpose (no DOM, no closures): the network probing this
+  // feeds is what makes "has deploy data" answerable at all, but which
+  // candidate wins from the results is a plain function worth pinning without
+  // mocking a fetch.
+
+  // "default" is always offered (the API guarantees it) but usually holds no
+  // deploys, so opening straight into it reads as broken: every row pending,
+  // a "no deploy log" banner. Fallback for when no candidate's deploy log can
+  // be confirmed (a fresh project): prefer a profile the run index shows has
+  // runs, with exactly one such profile the only reasonable pick.
+  function pickDataProfile(current, dataProfiles) {
+    if (!dataProfiles.length || dataProfiles.indexOf(current) !== -1) return current;
+    return dataProfiles.length === 1 ? dataProfiles[0] : dataProfiles.slice().sort()[0];
+  }
+
+  // Every profile worth checking for deploy data, in preference order: the
+  // current profile first (so an already-fine pick is left alone), then
+  // run-index profiles (a profile with runs is a maintained environment),
+  // then the project's full profile set. That last tier is what makes a
+  // profile deploys are recorded under but nothing has ever run against
+  // reachable at all — the run index alone has no way to see it.
+  function dataProfileCandidates(current, dataProfiles, projectProfiles) {
+    var seen = {};
+    var out = [];
+    [current].concat(dataProfiles, projectProfiles).forEach(function (p) {
+      if (p && !seen[p]) { seen[p] = true; out.push(p); }
+    });
+    return out;
+  }
+
+  // The deterministic half of resolveDataProfile below: given which
+  // candidates actually have a deploy log (probed in parallel, so answers can
+  // arrive in any order), pick the first by candidate order, not by response
+  // order — the result must not depend on network timing. Falls back to
+  // pickDataProfile's answer when nothing confirms (no project has deploy
+  // data yet), leaving that case's behaviour unchanged.
+  function pickFirstWithDeployLog(candidates, hasLog, current, dataProfiles) {
+    for (var i = 0; i < candidates.length; i++) {
+      if (hasLog[i]) return candidates[i];
+    }
+    return pickDataProfile(current, dataProfiles);
+  }
+  // --- end pure: data-profile pick ------------------------------------------
+
+  // Confirms a candidate actually has a deploy log, rather than merely being
+  // known to the run index or the secrets tab — the two facts pickDataProfile
+  // used to conflate (a profile can hold runs, or secrets, with no deploy log
+  // at all). limit=1 makes this a cheap existence check.
+  function hasDeployLog(profile) {
+    return apiFetch(
+      "/api/v1/projects/" + encodeURIComponent(state.project) + "/deploys?profile=" + encodeURIComponent(profile) + "&limit=1",
+    ).then(function (data) { return !!(data && data.entries && data.entries.length); })
+      .catch(function () { return false; });
+  }
+
+  // The candidate set from /profiles is broader than the run index (see
+  // dataProfileCandidates), so probe every candidate's deploy log in
+  // parallel before letting pickFirstWithDeployLog decide.
+  function resolveDataProfile(current, dataProfiles, projectProfiles) {
+    var candidates = dataProfileCandidates(current, dataProfiles, projectProfiles);
+    return Promise.all(candidates.map(hasDeployLog))
+      .then(function (hasLog) { return pickFirstWithDeployLog(candidates, hasLog, current, dataProfiles); });
+  }
+
+  // The full profile set (secrets tab's universe) is broader than the run
+  // index: a profile deploys are recorded under but nothing has ever run
+  // against is invisible to fetchRunIndex. Fetched independently from
+  // loadProfiles, which mutates knownProfiles/state.profile as a side effect
+  // the Secrets tab depends on and this must not trigger.
+  function fetchProjectProfiles() {
+    return apiFetch("/api/v1/projects/" + encodeURIComponent(state.project) + "/profiles")
+      .then(function (data) { return (data && data.profiles) || []; })
+      .catch(function () { return []; });
+  }
+
   // Project-scoped (see fetchRunIndex) — never rejects, so this always
   // re-renders once the run index settles, whichever of the three loads in
   // loadPerspectives is slowest.
@@ -22513,7 +22613,22 @@ const CLIENT_JS = `
     return fetchRunIndex().then(function (result) {
       perspState.runUrls = result.urls;
       perspState.rerunProfiles = result.profiles;
-      renderPerspectives();
+      if (storedProfileForProject(state.project)) {
+        renderPerspectives();
+        return;
+      }
+      // Never overrides a choice the user made explicitly (the check above)
+      // — this only fills in the very first, unopinionated default.
+      return fetchProjectProfiles()
+        .then(function (projectProfiles) { return resolveDataProfile(state.profile, result.profiles, projectProfiles); })
+        .then(function (pick) {
+          if (pick !== state.profile) {
+            setProfile(pick);
+            renderPerspectives();
+            return reloadRerun();
+          }
+          renderPerspectives();
+        });
     });
   }
 
@@ -22529,8 +22644,9 @@ const CLIENT_JS = `
       if (rerun.note) {
         setPerspNote("persp-rerun-note", rerun.note, rerun.kind);
       } else if (perspState.rerun && !perspState.rerun.deployHead) {
-        // Every case is "unknown" in this state, so say once, at the top, what
-        // is missing and how to supply it, rather than only per row.
+        // With no deploy log nothing can be placed, so every case is assumed
+        // reached. Say once, at the top, what is missing and how to supply it,
+        // rather than repeating it on every row.
         setPerspNote("persp-rerun-note", t("perspectives.rerun.noDeployLogBanner").replace("{profile}", state.profile), "warn");
       } else {
         setPerspNote("persp-rerun-note", "");
@@ -22540,13 +22656,18 @@ const CLIENT_JS = `
   }
 
   // Loaded once per project open — never re-run on a profile switch, since
-  // drift carries no profile (unlike loadRerun/reloadRerun below).
+  // drift carries no profile (unlike loadRerun/reloadRerun below). Only the
+  // ledger's own coordinate (when a spec was last audited) survives into the
+  // view now — its finding is superseded by the fresher, deploy-aware audit
+  // axis in the /rerun report — so there is nothing here worth a banner on
+  // an older or unreachable hub.
   function loadDrift() {
-    return fetchLedgerColumn(driftPath(), "perspectives.drift.").then(function (result) {
-      perspState.drift = result.report || null;
-      setPerspNote("persp-drift-note", result.note || "", result.kind);
-      renderPerspectives();
-    });
+    return fetch(driftPath(), { headers: { Authorization: "Bearer " + state.token } })
+      .then(function (res) { return res.ok ? res.json() : null; }, function () { return null; })
+      .then(function (report) {
+        perspState.drift = report || null;
+        renderPerspectives();
+      });
   }
 
   // Switching profile re-asks only the profile-scoped question: the