ccqa 1.32.0 → 1.34.0

package/dist/bin/ccqa.mjs

@@ -1524,16 +1524,21 @@ const ENDPOINT_ENV_KEYS = [
 	"CLAUDE_CODE_OAUTH_TOKEN"
 ];
 /**
+* When both credentials are present the OAuth token wins and the API key is
+* dropped. Left to the CLI the API key would win, which makes "switch a CI
+* job to the subscription token" require unwiring the key everywhere; with
+* this rule, adding the one variable is the whole switch, and removing it is
+* the whole rollback. The one place the rule lives — both the resolved view
+* and the env the SDK receives apply it through here.
+*/
+function preferOauthToken(env) {
+	if (env["CLAUDE_CODE_OAUTH_TOKEN"]) delete env["ANTHROPIC_API_KEY"];
+}
+/**
 * Collects the endpoint/auth variables set in the current process environment
 * so they can be forwarded, verbatim, to every Claude Code invocation. Returns
 * only the keys that are actually set (non-empty), so unset variables never
-* override the SDK's own defaults.
-*
-* When both credentials are present the OAuth token wins and the API key is
-* not forwarded. Left to the CLI the API key would win, which makes "switch a
-* CI job to the subscription token" require unwiring the key everywhere; with
-* the precedence here, adding the one variable is the whole switch, and
-* removing it is the whole rollback.
+* override the SDK's own defaults. Credential precedence per preferOauthToken.
 */
 function resolveEndpointEnv() {
 	const endpointEnv = {};
@@ -1541,7 +1546,7 @@ function resolveEndpointEnv() {
 		const value = process.env[key];
 		if (value && value.length > 0) endpointEnv[key] = value;
 	}
-	if (endpointEnv["CLAUDE_CODE_OAUTH_TOKEN"]) delete endpointEnv["ANTHROPIC_API_KEY"];
+	preferOauthToken(endpointEnv);
 	return endpointEnv;
 }
 /**
@@ -1555,6 +1560,30 @@ function withoutEmptyEndpointVars(env) {
 	for (const key of ENDPOINT_ENV_KEYS) if (out[key] === "") delete out[key];
 	return out;
 }
+/**
+* The environment actually handed to the Claude Code process: the full process
+* environment with the caller's overrides on top, empty endpoint variables
+* dropped, and — when both credentials survive the merge — the API key removed
+* so the OAuth token wins.
+*
+* That removal MUST happen on the env the SDK receives, not only on the
+* resolved view: left to the CLI the API key would win, silently moving every
+* call from the subscription to metered billing when a CI job wires both
+* (which is exactly what happened before this function existed).
+*
+* Returns undefined when no endpoint variable is set and the caller passes no
+* env, so the SDK keeps its own default environment.
+*/
+function buildInvocationEnv(env) {
+	const hasEndpointEnv = Object.keys(resolveEndpointEnv()).length > 0;
+	if (!env && !hasEndpointEnv) return void 0;
+	const merged = withoutEmptyEndpointVars({
+		...process.env,
+		...env
+	});
+	preferOauthToken(merged);
+	return merged;
+}
 let nativeBinaryWarned = false;
 /**
 * Warn once per process when the SDK's per-platform native binary is missing:
@@ -1570,11 +1599,7 @@ function warnOnceIfNativeBinaryMissing() {
 async function invokeClaudeStreaming(options, onEvent) {
 	const { prompt, systemPrompt, allowedTools, disableBuiltinTools = false, disableThinking = false, mcpServers, maxTurns, env, model, cwd, onAbAction, onAbActionFailed, silenceBashLog = false, envScrubMap = [], relaxAbConstraints = false } = options;
 	const resolvedModel = resolveModel(model);
-	const hasEndpointEnv = Object.keys(resolveEndpointEnv()).length > 0;
-	const mergedEnv = env || hasEndpointEnv ? withoutEmptyEndpointVars({
-		...process.env,
-		...env
-	}) : void 0;
+	const mergedEnv = buildInvocationEnv(env);
 	let lastAbToolUseId = null;
 	const claimAbToolUse = (toolUseId) => {
 		if (toolUseId !== lastAbToolUseId) return false;
@@ -7518,6 +7543,46 @@ z.object({
 	specs: z.record(z.string(), AttestationSchema)
 });
 /**
+* A person's answer to one audit finding: the spec describes the code fine,
+* and the finding is wrong. Where an attestation speaks about the product,
+* this speaks about the *audit* — so it settles the audit axis rather than
+* the verdict, and the spec goes back to being run like any other.
+*
+* Pinned to the audit run whose finding it answers. A later audit is a new
+* observation of newer code, so it produces a new run and this stops
+* applying: the machine gets to raise the finding again, and the record of
+* the last dismissal is shown beside it rather than silently suppressing it.
+* No profile — an audit finding is about the repository, not an environment
+* (ADR-0013), which is also why this is scoped per project alone.
+*/
+const AuditDismissalSchema = z.object({
+	by: z.string().min(1),
+	at: z.string(),
+	note: z.string().min(1),
+	auditRunId: z.string(),
+	label: DriftLabelSchema,
+	headline: z.string()
+});
+/** The per-project dismissal document: "feature/spec" → the last dismissal. */
+const AuditDismissalsSchema = z.object({ specs: z.record(z.string(), AuditDismissalSchema).default({}) });
+/** Body of `PUT /projects/:project/audit-dismissals`. */
+const PutAuditDismissalRequestSchema = z.object({
+	spec: z.string().min(1).max(512),
+	by: z.string().min(1).max(256),
+	note: z.string().min(1).max(4e3)
+});
+/** Body of `DELETE /projects/:project/audit-dismissals`. */
+const DeleteAuditDismissalRequestSchema = z.object({ spec: z.string().min(1).max(512) });
+z.object({
+	project: z.string(),
+	spec: z.string(),
+	dismissal: AuditDismissalSchema
+});
+z.object({
+	project: z.string(),
+	specs: z.record(z.string(), AuditDismissalSchema)
+});
+/**
 * One spec's verdict, the two axes it was derived from, and the three ledger
 * coordinates the view shows alongside them. The coordinates are always
 * present (null when the spec has no such entry); the optional fields appear
@@ -7533,6 +7598,8 @@ const SpecRerunSchema = z.object({
 	execution: ExecutionStateSchema,
 	driftLabel: DriftLabelSchema.exclude(["UNKNOWN"]).optional(),
 	auditAssumedReached: RerunUnknownReasonSchema.optional(),
+	auditDismissed: AuditDismissalSchema.optional(),
+	auditDismissalApplied: z.boolean().optional(),
 	executionAssumedReached: RerunUnknownReasonSchema.optional(),
 	specChangedSince: z.string().optional(),
 	manual: AttestationSchema.optional(),
@@ -9297,6 +9364,20 @@ function connect(opts) {
 	error("hub token is required (--hub-token or CCQA_HUB_TOKEN)");
 	process.exit(2);
 }
+/**
+* The canonical "feature/spec" key for a CLI argument. Hub records are stored
+* and looked up under exactly this form, so an alias accepted here but kept
+* verbatim would silently never match.
+*/
+function requireSpecId(rawSpecId) {
+	try {
+		const parsed = parseSpecPath(rawSpecId);
+		return `${parsed.featureName}/${parsed.specName}`;
+	} catch (err) {
+		error(errMessage(err));
+		process.exit(2);
+	}
+}
 function validateSessionName(name) {
 	const parsed = SessionNameSchema.safeParse(name);
 	if (!parsed.success) {
@@ -9594,14 +9675,7 @@ const pushCommand = new Command("push").description("Upload the report directory
 const attestCommand = new Command("attest").argument("<feature/spec>", "Spec id, e.g. checkout/happy-path").description("Record that a person checked a spec's behaviour by hand against the deployed environment. The verdict answers manuallyVerified instead of asking a person for what a person already did — the drift ledger is untouched, so the repair loop keeps its reason to fix the test. The attestation lapses on its own when a deploy reaches the spec or the spec is edited.").requiredOption("--profile <name>", "Environment that was checked (e.g. 'stg'). The attestation is anchored to its current deploy head.").option("--by <name>", "Who checked. Required unless --revoke.").option("--note <text>", "What was checked and how — the reader deciding whether to trust it sees this.").option("--revoke", "Withdraw the spec's attestation instead of recording one.").option(...hubUrlOption).option(...hubTokenOption).option("--project <name>", "Hub project. Defaults to the current directory's name.").option("--cwd <path>", "Directory the default --project name is resolved against.").action(withHubErrors(async (rawSpecId, opts) => {
 	const project = resolveProject(opts);
 	const hub = connect(opts);
-	let specId;
-	try {
-		const parsed = parseSpecPath(rawSpecId);
-		specId = `${parsed.featureName}/${parsed.specName}`;
-	} catch (err) {
-		error(errMessage(err));
-		process.exit(2);
-	}
+	const specId = requireSpecId(rawSpecId);
 	if (opts.revoke) {
 		await hub.deleteAttestation(project, { profile: opts.profile }, specId);
 		header("hub attest", `${specId} revoked`);
@@ -9621,7 +9695,30 @@ const attestCommand = new Command("attest").argument("<feature/spec>", "Spec id,
 	meta("anchored to deploy", res.attestation.deployedSha ?? "(no deploy log)");
 	info("the verdict answers manuallyVerified until a deploy reaches this spec or the spec is edited");
 }));
-const hubCommand = new Command("hub").description("Client for a ccqa hub: push run results and manage sessions/variables/prompts used by `ccqa run`. See docs/hub.md.").addCommand(pushCommand).addCommand(deployCommand).addCommand(costCommand).addCommand(sessionCommand).addCommand(varCommand).addCommand(promptCommand).addCommand(attestCommand);
+const dismissCommand = new Command("dismiss").argument("<feature/spec>", "Spec id, e.g. checkout/happy-path").description("Record that a person judged the spec's current audit finding wrong: the spec describes the code fine. This settles the audit axis rather than the verdict — the spec goes back to being run like any other, and the next run says whether the person was right. The dismissal is pinned to the audit run that raised the finding, so a later audit can raise it again. No --profile: a finding is about the repository, not an environment.").option("--by <name>", "Who judged it wrong. Required unless --revoke.").option("--reason <text>", "Why the finding is wrong. Required unless --revoke — this is what a mis-firing audit learns from.").option("--revoke", "Withdraw the dismissal, putting the finding back in force.").option(...hubUrlOption).option(...hubTokenOption).option("--project <name>", "Hub project. Defaults to the current directory's name.").option("--cwd <path>", "Directory the default --project name is resolved against.").action(withHubErrors(async (rawSpecId, opts) => {
+	const project = resolveProject(opts);
+	const hub = connect(opts);
+	const specId = requireSpecId(rawSpecId);
+	if (opts.revoke) {
+		await hub.deleteAuditDismissal(project, specId);
+		header("hub dismiss", `${specId} revoked`);
+		return;
+	}
+	if (!opts.by || !opts.reason) {
+		error("--by <name> and --reason <text> are both required: a dismissal is a person's correction, and it needs the person and the correction");
+		process.exit(2);
+	}
+	const res = await hub.putAuditDismissal(project, {
+		spec: specId,
+		by: opts.by,
+		note: opts.reason
+	});
+	header("hub dismiss", specId);
+	meta("by", res.dismissal.by);
+	meta("dismissed", `${res.dismissal.label} — ${res.dismissal.headline || "(no headline)"}`);
+	info("this finding no longer holds the spec back; a later audit can raise one of its own");
+}));
+const hubCommand = new Command("hub").description("Client for a ccqa hub: push run results and manage sessions/variables/prompts used by `ccqa run`. See docs/hub.md.").addCommand(pushCommand).addCommand(deployCommand).addCommand(costCommand).addCommand(sessionCommand).addCommand(varCommand).addCommand(promptCommand).addCommand(attestCommand).addCommand(dismissCommand);
 /** Loose check that a fetched session is agent-browser storage-state, mirroring loadStorageState. */
 function isStorageStateShape(state) {
 	return typeof state === "object" && state !== null && Array.isArray(state.cookies) && Array.isArray(state.origins);
@@ -18929,7 +19026,7 @@ function createGetAuditNeedHandler(storage) {
 //#endregion
 //#region src/hub/api/handlers/locks.ts
 /** A spec-key list and three short strings; nothing here should approach this. */
-const MAX_BODY_BYTES$4 = 1024 * 1024;
+const MAX_BODY_BYTES$5 = 1024 * 1024;
 /**
 * POST /api/v1/projects/:project/locks?profile=
 *
@@ -18943,7 +19040,7 @@ function createAcquireLocksHandler(storage) {
 	return async (ctx) => {
 		const project = requireSafeSegment(ctx.params.project, "project");
 		const profile = requireProfileParam(ctx.url);
-		const body = await readJsonBody(ctx.req, MAX_BODY_BYTES$4, AcquireLocksRequestSchema, "lock request");
+		const body = await readJsonBody(ctx.req, MAX_BODY_BYTES$5, AcquireLocksRequestSchema, "lock request");
 		let result = {
 			granted: [],
 			denied: []
@@ -18972,7 +19069,7 @@ function createReleaseLocksHandler(storage) {
 	return async (ctx) => {
 		const project = requireSafeSegment(ctx.params.project, "project");
 		const profile = requireProfileParam(ctx.url);
-		const body = await readJsonBody(ctx.req, MAX_BODY_BYTES$4, ReleaseLocksRequestSchema, "release request");
+		const body = await readJsonBody(ctx.req, MAX_BODY_BYTES$5, ReleaseLocksRequestSchema, "release request");
 		await storage.locks.update(project, profile, (current) => releaseAll(current, body.holder));
 		ctx.res.writeHead(204).end();
 	};
@@ -18985,7 +19082,7 @@ function createReleaseLocksHandler(storage) {
 * 5000 keys of 256 `\uXXXX`-escaped characters — so a conforming client is
 * never answered 413 by a limit the documented bounds don't mention.
 */
-const MAX_BODY_BYTES$3 = 8 * 1024 * 1024;
+const MAX_BODY_BYTES$4 = 8 * 1024 * 1024;
 function requireAckKey(ctx) {
 	return {
 		project: requireSafeSegment(ctx.params.project, "project"),
@@ -19012,7 +19109,7 @@ function createGetAckHandler(storage) {
 function createPutAckHandler(storage) {
 	return async (ctx) => {
 		const key = requireAckKey(ctx);
-		const body = await readJsonBody(ctx.req, MAX_BODY_BYTES$3, PutAckRequestSchema, "ack body");
+		const body = await readJsonBody(ctx.req, MAX_BODY_BYTES$4, PutAckRequestSchema, "ack body");
 		const ack = await storage.acks.put(key.project, key.profile, key.name, body.keys);
 		sendJson(ctx.res, 200, {
 			...key,
@@ -19023,7 +19120,7 @@ function createPutAckHandler(storage) {
 //#endregion
 //#region src/hub/api/handlers/attestations.ts
 /** Far above the largest body `PutAttestationRequestSchema`'s bounds admit. */
-const MAX_BODY_BYTES$2 = 64 * 1024;
+const MAX_BODY_BYTES$3 = 64 * 1024;
 function requireScope(ctx) {
 	return {
 		project: requireSafeSegment(ctx.params.project, "project"),
@@ -19056,7 +19153,7 @@ function createPutAttestationHandler(storage) {
 	return async (ctx) => {
 		const scope = requireScope(ctx);
 		const [body, head, targets] = await Promise.all([
-			readJsonBody(ctx.req, MAX_BODY_BYTES$2, PutAttestationRequestSchema, "attestation body"),
+			readJsonBody(ctx.req, MAX_BODY_BYTES$3, PutAttestationRequestSchema, "attestation body"),
 			storage.deploys.head(scope.project, scope.profile),
 			requireSpecTargets(storage.perspectives, scope.project, "what can be attested")
 		]);
@@ -19086,7 +19183,7 @@ function createPutAttestationHandler(storage) {
 function createDeleteAttestationHandler(storage) {
 	return async (ctx) => {
 		const scope = requireScope(ctx);
-		const body = await readJsonBody(ctx.req, MAX_BODY_BYTES$2, DeleteAttestationRequestSchema, "attestation body");
+		const body = await readJsonBody(ctx.req, MAX_BODY_BYTES$3, DeleteAttestationRequestSchema, "attestation body");
 		await storage.attestations.update(scope.project, scope.profile, (current) => {
 			const { [body.spec]: _, ...rest } = current.specs;
 			return { specs: rest };
@@ -19095,6 +19192,83 @@ function createDeleteAttestationHandler(storage) {
 	};
 }
 //#endregion
+//#region src/hub/api/handlers/audit-dismissals.ts
+/** Far above the largest body `PutAuditDismissalRequestSchema`'s bounds admit. */
+const MAX_BODY_BYTES$2 = 64 * 1024;
+/**
+* GET /api/v1/projects/:project/audit-dismissals — the raw document,
+* whether or not each entry still answers the spec's current finding. No
+* `?profile=`: a finding is about the repository (see `AuditDismissalSchema`).
+*/
+function createGetAuditDismissalsHandler(storage) {
+	return async (ctx) => {
+		const project = requireSafeSegment(ctx.params.project, "project");
+		const doc = await storage.auditDismissals.get(project);
+		sendJson(ctx.res, 200, {
+			project,
+			specs: doc.specs
+		});
+	};
+}
+/**
+* PUT /api/v1/projects/:project/audit-dismissals — record that a person
+* judged the spec's current audit finding wrong.
+*
+* The finding being answered is read from the ledger rather than taken from
+* the caller: a dismissal must name the run and the label it answers, and
+* only the hub knows which finding is current. A spec with no open finding is
+* a 400 — there is nothing to dismiss, and accepting it would write a record
+* that never applies to anything.
+*
+* The guard stops there on purpose. `/rerun` applies a dismissal only while
+* the audit is also *current* for the profile being asked about, and that is
+* a per-profile question this endpoint has no profile to ask it of (a finding
+* is about the repository, so the dismissal is project-scoped). A dismissal
+* written while a deploy has overtaken the audit is harmless: the next audit
+* supersedes the finding, and the record with it.
+*/
+function createPutAuditDismissalHandler(storage) {
+	return async (ctx) => {
+		const project = requireSafeSegment(ctx.params.project, "project");
+		const [body, ledger] = await Promise.all([readJsonBody(ctx.req, MAX_BODY_BYTES$2, PutAuditDismissalRequestSchema, "dismissal body"), storage.driftLedger.getMerged(project)]);
+		const entry = ledger.specs[body.spec];
+		if (!entry || entry.label === null) throw new HttpError(400, "no_open_finding", `spec "${body.spec}" has no open audit finding in project "${project}" — there is nothing to dismiss`);
+		const dismissal = {
+			by: body.by,
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			note: body.note,
+			auditRunId: entry.runId,
+			label: entry.label,
+			headline: entry.headline ?? ""
+		};
+		await storage.auditDismissals.update(project, (current) => ({ specs: {
+			...current.specs,
+			[body.spec]: dismissal
+		} }));
+		sendJson(ctx.res, 200, {
+			project,
+			spec: body.spec,
+			dismissal
+		});
+	};
+}
+/**
+* DELETE /api/v1/projects/:project/audit-dismissals — withdraw a dismissal,
+* putting the audit's finding back in force. Deleting one that does not exist
+* is 200: the caller asked for its absence, and it is absent.
+*/
+function createDeleteAuditDismissalHandler(storage) {
+	return async (ctx) => {
+		const project = requireSafeSegment(ctx.params.project, "project");
+		const body = await readJsonBody(ctx.req, MAX_BODY_BYTES$2, DeleteAuditDismissalRequestSchema, "dismissal body");
+		await storage.auditDismissals.update(project, (current) => {
+			const { [body.spec]: _, ...rest } = current.specs;
+			return { specs: rest };
+		});
+		sendJson(ctx.res, 200, { removed: body.spec });
+	};
+}
+//#endregion
 //#region src/hub/api/handlers/spend.ts
 /** One entry is a handful of short fields; anything larger is a malformed client. */
 const MAX_BODY_BYTES$1 = 4 * 1024;
@@ -19167,7 +19341,7 @@ function specMovedSince(changedAt, baselineSha, baselineAt, deployTimes) {
 	return changedAt > (baselineSha && deployTimes.get(baselineSha) || baselineAt) ? changedAt : null;
 }
 function computeRerun(input) {
-	const { specs, ledger, log, touchIndex, drift, locks, attestations, now } = input;
+	const { specs, ledger, log, touchIndex, drift, locks, attestations, dismissals, now } = input;
 	const range = buildRange(log, touchIndex);
 	const deployTimes = deployedAt(log);
 	const out = {};
@@ -19180,6 +19354,9 @@ function computeRerun(input) {
 		let audit = auditState(drift, spec.key, range);
 		let execution = executionState(coords, (sha) => freshness(sha, spec.key, range));
 		const driftEntry = drift.specs[spec.key];
+		const dismissal = dismissals.specs[spec.key];
+		const dismissed = dismissal !== void 0 && driftEntry !== void 0 && dismissal.auditRunId === driftEntry.runId && dismissal.label === driftEntry.label && (audit.audit === "drifted" || audit.audit === "undecided");
+		if (dismissed) audit = { audit: "clean" };
 		const auditMoved = specMovedSince(spec.changedAt, driftEntry?.gitHead ?? null, driftEntry?.at ?? "", deployTimes);
 		const runMoved = specMovedSince(spec.changedAt, coords.lastRun?.deployedSha ?? null, coords.lastRun?.at ?? "", deployTimes);
 		if (auditMoved && audit.audit !== "due") audit = { audit: "due" };
@@ -19193,6 +19370,10 @@ function computeRerun(input) {
 			...auditMoved || runMoved ? { specChangedSince: auditMoved ?? runMoved } : {},
 			...audit,
 			...execution,
+			...dismissal ? {
+				auditDismissed: dismissal,
+				auditDismissalApplied: dismissed
+			} : {},
 			...manualState?.kind === "covers" ? { manual: manualState.attest } : {},
 			...manualState?.kind === "lapsed" ? {
 				manualLapsed: {
@@ -19356,14 +19537,15 @@ function createGetRerunHandler(storage) {
 	return async (ctx) => {
 		const project = requireSafeSegment(ctx.params.project, "project");
 		const profile = requireProfileParam(ctx.url);
-		const [specs, ledger, log, touchIndex, drift, locks, attestations] = await Promise.all([
+		const [specs, ledger, log, touchIndex, drift, locks, attestations, dismissals] = await Promise.all([
 			requireSpecTargets(storage.perspectives, project, "which specs need a re-run"),
 			storage.ledger.getMerged(project, profile),
 			storage.deploys.getLog(project, profile),
 			storage.deploys.getTouchIndex(project, profile),
 			storage.driftLedger.getMerged(project),
 			storage.locks.get(project, profile),
-			storage.attestations.get(project, profile)
+			storage.attestations.get(project, profile),
+			storage.auditDismissals.get(project)
 		]);
 		const head = log.entries[log.entries.length - 1];
 		sendJson(ctx.res, 200, {
@@ -19378,6 +19560,7 @@ function createGetRerunHandler(storage) {
 				drift,
 				locks,
 				attestations,
+				dismissals,
 				now: /* @__PURE__ */ new Date()
 			})
 		});
@@ -20921,7 +21104,7 @@ const CSS = `
   .d-grid dt { color: var(--muted); font-size: 12px; padding-top: 1px; }
   .d-grid dd { color: var(--fg-dim); }
   .d-grid dd ul { list-style: none; display: flex; flex-direction: column; gap: 3px; margin: 0; padding: 0; }
-  .d-grid dd li::before { content: "\\2022 "; color: var(--muted-2); }
+  .d-grid dd ul li::before { content: "\\2022 "; color: var(--muted-2); }
   .d-grid code { font-size: 12px; background: var(--surface-2); border: 1px solid var(--border); border-radius: 4px; padding: 1px 5px; }
   /* Prose gets a measure so it stops wrapping mid-phrase in a narrow column;
      paths wrap as whole chips, never inside a path. */
@@ -20930,17 +21113,26 @@ const CSS = `
   .d-paths code { white-space: nowrap; }
   .d-prose + .d-paths { margin-top: 6px; }
   .manual-attest { margin-top: 14px; }
-  .steps-box { margin-top: 14px; max-width: 900px; }
-  .steps-box .slabel { font-size: 12px; color: var(--muted); margin-bottom: 4px; }
   .d-steps { margin: 4px 0 0; padding-left: 18px; display: flex; flex-direction: column; gap: 10px; font-size: 13px; color: var(--fg-dim); white-space: pre-line; }
   .d-steps .step-expected { display: block; margin-top: 2px; font-size: 12.5px; }
-  .notebox { margin-top: 14px; max-width: 900px; }
-  .notebox .nlabel { font-size: 12px; color: var(--muted); margin-bottom: 4px; }
   .notebox textarea { width: 100%; min-height: 54px; resize: vertical; font: inherit; font-size: 13px; color: var(--fg-dim); background: var(--surface); border: 1px solid var(--border-strong); border-radius: var(--radius-sm); padding: 8px 10px; }
-  .notebox .nact { margin-top: 6px; display: flex; align-items: center; gap: 8px; }
+  .notebox .nact { margin-top: 6px; display: flex; align-items: center; justify-content: flex-end; gap: 8px; }
   .notebox .nstatus { font-size: 12px; color: var(--muted); }
   .notebox .nstatus.ok { color: var(--pass); }
   .notebox .nstatus.err { color: var(--fail); }
+  /* ── detail panel: one card stack — reason, contents, note ── */
+  .c-title .c-id { display: block; font-family: var(--mono); font-size: 11px; color: var(--muted-2); margin-top: 2px; }
+  .p-sect { margin-top: 16px; max-width: 900px; }
+  .p-sect:first-child { margin-top: 12px; }
+  .p-slabel { font-size: 13px; font-weight: 600; color: var(--fg); margin-bottom: 6px; }
+  /* The one-line state note beside the finding chip: what happens next. */
+  .p-head-note { margin-left: auto; font-size: 12.5px; color: var(--muted); }
+  /* The inline form an audit-dismissal or environment-attestation button
+     expands into, in place of the two window.prompt() calls this replaces. */
+  .override-form { margin-top: 10px; max-width: 480px; display: flex; flex-direction: column; gap: 10px; }
+  .override-form textarea { width: 100%; min-height: 54px; resize: vertical; font: inherit; font-size: 13px; color: var(--fg-dim); background: var(--surface); border: 1px solid var(--border-strong); border-radius: var(--radius-sm); padding: 8px 10px; }
+  .override-form .of-act { display: flex; align-items: center; gap: 8px; }
+  .override-form .of-hint { font-size: 12px; color: var(--muted); max-width: 62ch; line-height: 1.5; }
 
   @media (max-width: 900px) { .app { grid-template-columns: 1fr; } .sidebar { display: none; } .logo .wm { display: none; } .split { grid-template-columns: 1fr; } .rd-head .meta { margin-left: 0; } }
   @media (max-width: 700px) { .prompt-grid { grid-template-columns: 1fr; } .prompt-diff { grid-template-columns: 1fr; } }
@@ -21062,16 +21254,15 @@ const CLIENT_JS = `
       "perspectives.mode.deterministic": "deterministic", "perspectives.mode.live": "live",
       "perspectives.ov.cases": "cases", "perspectives.ov.features": "features",
       "perspectives.d.preconditions": "Preconditions", "perspectives.d.startScreen": "Start screen",
-      "perspectives.d.testCondition": "Condition", "perspectives.d.spec": "spec",
-      "perspectives.d.steps": "Steps", "perspectives.d.stepInclude": "Include: {name}",
+      "perspectives.d.testCondition": "Condition", "perspectives.d.steps": "Steps", "perspectives.d.stepInclude": "Include: {name}",
       "perspectives.d.stepExpected": "Expected:",
       "perspectives.note.label": "Note",
       "perspectives.note.placeholder": "Notes about this case…",
       "perspectives.note.saved": "Saved",
       "perspectives.note.error": "Could not save — retry",
-      "perspectives.d.lastRed": "Most recent failure",
-      "perspectives.d.changedSince": "Changes since the last run",
       "perspectives.d.whyVerdict": "Why this verdict",
+      "perspectives.d.contents": "What this case does",
+      "perspectives.finding.loadFailed": "Could not load the finding's detail \u2014 open the run to read it",
       "perspectives.result.openRun": "Open this run in the hub",
       "perspectives.result.ci": "CI",
       "perspectives.rerun.state.needsRepair": "Needs repair",
@@ -21082,26 +21273,26 @@ const CLIENT_JS = `
       "perspectives.rerun.vsDeploy": "judged against deploy",
       "perspectives.rerun.noDeployHead": "no deploy recorded for this profile",
       "perspectives.rerun.changedByDeploy": "deploy {sha} changed files matched to this case",
-      "perspectives.rerun.changesSome": "yes (as of deploy {sha})",
-      "perspectives.rerun.changesNone": "none (as of deploy {sha})",
+      "perspectives.rerun.changesSome": "changes matched to this case since the last run (as of deploy {sha})",
+      "perspectives.rerun.changesNone": "no changes matched to this case since the last run (as of deploy {sha})",
       "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.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.heldHint": "an audit, auto-fix or run job is working on this case — dismissing or attesting is unavailable until it finishes",
+      "perspectives.rerun.repair.testDrift": "the audit judged the generated test code older than the implementation — auto-fix re-records it, so nothing is needed yet",
+      "perspectives.rerun.repair.specChange": "the audit judged that the behaviour this test assumes is gone from the code — fix or delete the test, or dismiss the finding via “{dismissButton}” if it is wrong",
+      "perspectives.rerun.repair.auditUndecided": "the audit could not tell whether the test has drifted — review the finding, then fix the test or dismiss it via “{dismissButton}”",
+      "perspectives.rerun.repair.runFailed": "the latest run failed — this verdict will not change until the failure's cause is addressed",
+      "perspectives.rerun.why.noSelectionInRange": "a deploy in range carries no impact judgement, so this case runs to be safe",
+      "perspectives.rerun.why.selectionUnknown": "the latest deploy could not be judged as affecting this case or not, so it runs to be safe",
       "perspectives.rerun.why.noDeployLog": "no deploy log for this profile",
       "perspectives.rerun.why.unknownDeployedSha": "the last run's deployed commit is unknown",
       "perspectives.rerun.why.ambiguousDeployedSha": "a deploy landed while the last run was executing",
       "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.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.noSelectionInRange": "A deploy was recorded without an impact judgement, so whether it affected this case is unknown. This happens when the judgement did not finish in time, or was disabled, at record. The next run and audit retake the result.",
+      "perspectives.rerun.fix.selectionUnknown": "A deploy could not be judged as affecting this case or not, so the next run retakes the result.",
       "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.",
       "perspectives.rerun.fix.unknownDeployedSha": "The last run did not record which commit the environment was running, so it cannot be positioned in the deploy log. Runs record it once this profile has a deploy log.",
       "perspectives.rerun.fix.ambiguousDeployedSha": "A deploy landed while the last run was executing, so which commit it exercised is not knowable. Re-run this case to get a clean baseline.",
@@ -21113,10 +21304,8 @@ const CLIENT_JS = `
       "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.graded": "confirmed",
-      "perspectives.manual.attestButton": "Mark as manually verified",
       "perspectives.manual.revokeButton": "Revoke manual verification",
-      "perspectives.manual.promptBy": "Who is verifying this?",
-      "perspectives.manual.promptNote": "Note (optional)",
+      "perspectives.manual.envButton": "If the environment issue is resolved, use this",
       "perspectives.manual.confirmRevoke": "Revoke the manual verification for this case?",
       "perspectives.manual.error": "Could not save — retry",
       "perspectives.manual.verifiedBy": "{by} manually verified this ({at})",
@@ -21126,6 +21315,18 @@ const CLIENT_JS = `
       "perspectives.manual.lapsed.specEdited": "the manual verification lapsed when the spec was edited",
       "perspectives.manual.lapsed.newerRed": "the manual verification lapsed after a later run failed",
       "perspectives.manual.lapsed.unrecognized": "the manual verification lapsed for a reason this UI does not recognise",
+      "perspectives.dismiss.offerButton": "If the test spec was fine, use this",
+      "perspectives.dismiss.revokeButton": "Undo the dismissal",
+      "perspectives.dismiss.confirmRevoke": "Undo the dismissal for this case?",
+      "perspectives.dismiss.activeNote": "Audit finding “{headline}” was dismissed by {by} as a false positive ({at}) — “{note}”. The next run will settle it.",
+      "perspectives.dismiss.priorNote": "This finding was previously dismissed by {by} ({at}) — “{note}”.",
+      "perspectives.override.byLabel": "Verified by",
+      "perspectives.override.reasonLabel": "Reason (required)",
+      "perspectives.override.noteLabel": "What was resolved, and how you checked (required)",
+      "perspectives.override.submit": "Record",
+      "perspectives.override.cancel": "Never mind",
+      "perspectives.override.dismissHint": "Withdraws the audit finding and puts this case back among the runnable. The verdict moves to “re-run needed”, and the next run's result settles it.",
+      "perspectives.override.envHint": "The failure stays on record; only the verdict becomes “manually verified”. It lapses once a deploy reaches this case, and normal runs resume.",
       "prompt.card.record": "Recording browser actions",
       "prompt.card.live": "Live run (AI-driven)",
       "prompt.card.playwright": "Playwright test generation",
@@ -21242,16 +21443,15 @@ const CLIENT_JS = `
       "perspectives.mode.deterministic": "決定的", "perspectives.mode.live": "ライブ",
       "perspectives.ov.cases": "ケース", "perspectives.ov.features": "機能",
       "perspectives.d.preconditions": "前提条件", "perspectives.d.startScreen": "開始画面",
-      "perspectives.d.testCondition": "実行条件", "perspectives.d.spec": "spec",
-      "perspectives.d.steps": "手順", "perspectives.d.stepInclude": "ブロック: {name}",
+      "perspectives.d.testCondition": "実行条件", "perspectives.d.steps": "手順", "perspectives.d.stepInclude": "ブロック: {name}",
       "perspectives.d.stepExpected": "期待結果:",
-      "perspectives.note.label": "note",
+      "perspectives.note.label": "メモ",
       "perspectives.note.placeholder": "このケースについてのメモ…",
       "perspectives.note.saved": "保存しました",
       "perspectives.note.error": "保存に失敗しました — 再試行してください",
-      "perspectives.d.lastRed": "直近の失敗",
-      "perspectives.d.changedSince": "前回実行以降の変更",
       "perspectives.d.whyVerdict": "この判定の理由",
+      "perspectives.d.contents": "テストの内容",
+      "perspectives.finding.loadFailed": "詳細を読み込めませんでした。実行のページで確認してください",
       "perspectives.result.openRun": "ハブでこの実行を開く",
       "perspectives.result.ci": "CI",
       "perspectives.rerun.state.needsRepair": "修正待ち",
@@ -21261,27 +21461,27 @@ const CLIENT_JS = `
       "perspectives.rerun.state.verified": "検証済み",
       "perspectives.rerun.vsDeploy": "判定基準: デプロイ",
       "perspectives.rerun.noDeployHead": "このプロファイルにはデプロイの記録がありません",
-      "perspectives.rerun.changedByDeploy": "デプロイ {sha} がこのケースに一致するファイルを変更",
-      "perspectives.rerun.changesSome": "あり（デプロイ {sha} 時点）",
-      "perspectives.rerun.changesNone": "なし（デプロイ {sha} 時点）",
-      "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.noSelectionInRange": "対象範囲に判定を伴わないデプロイがあります",
-      "perspectives.rerun.why.selectionUnknown": "影響の有無を判定できませんでした",
+      "perspectives.rerun.changedByDeploy": "デプロイ {sha} が、このケースに関係するファイルを変更しています",
+      "perspectives.rerun.changesSome": "前回の実行より後に、このケースに関係する変更があります（デプロイ {sha} 時点）",
+      "perspectives.rerun.changesNone": "前回の実行より後に、このケースに関係する変更はありません（デプロイ {sha} 時点）",
+      "perspectives.rerun.touchedCount": "前回の実行より後のデプロイが、このケースに関係する変更を {n} 件含んでいます",
+      "perspectives.rerun.touchedUnknown": "前回の実行より後のデプロイが、このケースに関係する変更を含んでいます",
+      "perspectives.rerun.inProgressHint": "監査または実行のジョブが作業中か、最新デプロイに対する監査がまだ走っていません",
+      "perspectives.rerun.heldHint": "監査・自動修正・実行のいずれかのジョブが、このケースを処理中です。終わるまで、このケースへの操作（棄却・手動確認）はできません",
+      "perspectives.rerun.repair.testDrift": "監査が、生成済みのテストコードは実装より古いと判定しました。自動修正が録り直すので、まず対応は不要です",
+      "perspectives.rerun.repair.specChange": "監査が、このテストの前提とする振る舞いは実装から無くなったと判定しました。テストを直すか削除するかを決めてください。指摘のほうが誤りなら、「{dismissButton}」から棄却できます",
+      "perspectives.rerun.repair.auditUndecided": "テストが実装とズレているかどうか、監査では判断できませんでした。指摘の内容を確認して、テストを直すか、「{dismissButton}」から棄却してください",
+      "perspectives.rerun.repair.runFailed": "直近の実行が失敗しています。失敗の原因に対処するまで、この判定は変わりません",
+      "perspectives.rerun.why.noSelectionInRange": "影響判定なしで記録されたデプロイがあるため、念のため実行対象になっています",
+      "perspectives.rerun.why.selectionUnknown": "直近のデプロイがこのケースに影響するかどうか判断できなかったため、念のため実行対象になっています",
       "perspectives.rerun.why.noDeployLog": "このプロファイルのデプロイ記録がありません",
       "perspectives.rerun.why.unknownDeployedSha": "前回実行時にデプロイされていたcommitが不明です",
       "perspectives.rerun.why.ambiguousDeployedSha": "前回実行の途中でデプロイが発生しました",
-      "perspectives.rerun.why.deployedShaNotInLog": "前回実行のcommitが保持中のデプロイログより古いです",
+      "perspectives.rerun.why.deployedShaNotInLog": "前回の実行が古く、どのデプロイに対して実行した結果か特定できません",
       "perspectives.rerun.why.gapInRange": "対象範囲のデプロイ記録が欠けています",
       "perspectives.rerun.why.unrecognized": "このUIが認識できない理由がハブから返されました",
-      "perspectives.rerun.fix.noSelectionInRange": "対象範囲に判定を伴わないデプロイがあり、このケースに影響したかどうかを示すものがありません。デプロイジョブで ccqa select-specs を実行し、判定をデプロイと一緒に送ってください。",
-      "perspectives.rerun.fix.selectionUnknown": "対象範囲のデプロイは判定されましたが、このケースについては判断がつきませんでした。再実行して基準を取り直してください。",
+      "perspectives.rerun.fix.noSelectionInRange": "影響判定なしで記録されたデプロイがあり、このケースに影響したかどうか分かりません。デプロイの記録時に影響判定が時間内に終わらなかったか、無効化されていたときに起きます。次の実行と監査で結果を取り直します。",
+      "perspectives.rerun.fix.selectionUnknown": "デプロイがこのケースに影響するかどうか判断できなかったため、次の実行で結果を取り直します。",
       "perspectives.rerun.fix.noDeployLog": "このプロファイルのデプロイログに記録がありません。何がデプロイされたかをccqaに伝えるため、この環境のデプロイジョブに ccqa hub deploy record を組み込んでください。",
       "perspectives.rerun.fix.unknownDeployedSha": "前回実行は環境で動いていたcommitを記録していないため、デプロイログ上の位置を決められません。このプロファイルにデプロイログができれば、以降の実行では記録されます。",
       "perspectives.rerun.fix.ambiguousDeployedSha": "前回実行の途中でデプロイが発生したため、どのcommitを検証したのか確定できません。基準を取り直すには再実行してください。",
@@ -21293,19 +21493,29 @@ const CLIENT_JS = `
       "perspectives.rerun.noDeployLogBanner": "プロファイル {profile} にデプロイの記録がないため、どのケースも判定できません。この環境のデプロイジョブに ccqa hub deploy record を組み込んでください。",
       "perspectives.rerun.deployHead": "最新デプロイ",
       "perspectives.drift.graded": "人が確認",
-      "perspectives.manual.attestButton": "手動で確認した",
       "perspectives.manual.revokeButton": "手動確認を取り消す",
-      "perspectives.manual.promptBy": "確認者名を入力してください",
-      "perspectives.manual.promptNote": "メモ（任意）",
+      "perspectives.manual.envButton": "環境要因が解消した場合はこちら",
       "perspectives.manual.confirmRevoke": "このケースの手動確認を取り消しますか？",
       "perspectives.manual.error": "保存に失敗しました — 再試行してください",
-      "perspectives.manual.verifiedBy": "{by}さんが手動確認（{at}）",
-      "perspectives.manual.lapsed.deployReached": "手動確認はデプロイの到達により失効",
-      "perspectives.manual.lapsed.deployReachedNamed": "手動確認はデプロイ {sha}（{at}）の到達により失効",
-      "perspectives.manual.lapsed.cannotPlace": "手動確認は基準デプロイをログで特定できず失効",
-      "perspectives.manual.lapsed.specEdited": "手動確認はspecの編集により失効",
-      "perspectives.manual.lapsed.newerRed": "手動確認は直後の実行失敗により失効",
-      "perspectives.manual.lapsed.unrecognized": "このUIが認識できない理由により手動確認が失効",
+      "perspectives.manual.verifiedBy": "{by} さんが手動で動作確認しました（{at}）",
+      "perspectives.manual.lapsed.deployReached": "デプロイがこのケースに届いたため、手動確認は失効しました",
+      "perspectives.manual.lapsed.deployReachedNamed": "デプロイ {sha}（{at}）がこのケースに届いたため、手動確認は失効しました",
+      "perspectives.manual.lapsed.cannotPlace": "基準のデプロイをログで特定できなくなったため、手動確認は失効しました",
+      "perspectives.manual.lapsed.specEdited": "spec が編集されたため、手動確認は失効しました",
+      "perspectives.manual.lapsed.newerRed": "手動確認より後の実行が失敗したため、手動確認は失効しました",
+      "perspectives.manual.lapsed.unrecognized": "この UI が認識できない理由により、手動確認は失効しました",
+      "perspectives.dismiss.offerButton": "テスト仕様に問題がなかった場合はこちら",
+      "perspectives.dismiss.revokeButton": "棄却を取り消す",
+      "perspectives.dismiss.confirmRevoke": "このケースの棄却を取り消しますか？",
+      "perspectives.dismiss.activeNote": "{by} さんが監査指摘「{headline}」を誤検知として棄却しました（{at}・理由: {note}）。次の実行結果が正否を決めます。",
+      "perspectives.dismiss.priorNote": "この指摘は、以前 {by} さんが棄却しています（{at}・理由: {note}）",
+      "perspectives.override.byLabel": "確認した人",
+      "perspectives.override.reasonLabel": "理由（必須）",
+      "perspectives.override.noteLabel": "解消と確認の内容（必須）",
+      "perspectives.override.submit": "記録する",
+      "perspectives.override.cancel": "やめる",
+      "perspectives.override.dismissHint": "監査の指摘を取り下げて、このケースを実行対象に戻します。判定は「要再実行」になり、次の実行結果が正否を決めます。",
+      "perspectives.override.envHint": "失敗の記録は残したまま、判定だけが「手動確認済み」になります。次のデプロイがこのケースに届くと失効し、通常の実行に戻ります。",
       "prompt.card.record": "ブラウザ操作の記録",
       "prompt.card.live": "ライブ実行（AI操作）",
       "prompt.card.playwright": "Playwrightテスト生成",
@@ -21602,7 +21812,6 @@ const CLIENT_JS = `
     return span;
   }
 
-
   // Shared by the runs-list row and the run-detail header — the one place
   // both decide whether a run's own status badge speaks drift's vocabulary.
   function runStatusBadge(run) {
@@ -22212,15 +22421,13 @@ const CLIENT_JS = `
 
   // ── run detail: spec cards ──────────────────────────────────────────
 
-  // The diagnosis card: one surface for everything about a failure's cause.
-  // Verdict (label + confidence), then the cause→fix pair as labelled rows —
-  // headline and recommendation are one causal unit, so they read as one.
-  // subDiagnosis is deliberately NOT shown: it is a machine vocabulary for
-  // accuracy stratification and learning, not for humans. The caller appends
-  // the evidence/reasoning accordions and the grading zone into this box.
-  function analysisSection(runId, r) {
-    var wrap = el("div", "analysis-box");
-    var a = r.analysis;
+  // The diagnosis card's two halves, shared by the run view (analysisSection)
+  // and the perspectives reason card so the two renderings cannot drift:
+  // verdict head (label chip + confidence), then the cause→fix pair as
+  // labelled rows — headline and recommendation are one causal unit, so they
+  // read as one. subDiagnosis is deliberately NOT shown: it is a machine
+  // vocabulary for accuracy stratification and learning, not for humans.
+  function diagnosisHead(a) {
     var head = el("div", "analysis-head");
     head.appendChild(labelChip(a.label));
     // Which repair a SPEC_CHANGE needs — delete the spec, or rewrite it. The
@@ -22230,7 +22437,10 @@ const CLIENT_JS = `
       head.appendChild(el("span", "chip spec-change-chip", t("diag.specChangeKind." + a.specChangeKind)));
     }
     head.appendChild(el("span", "conf", Math.round(a.confidence * 100) + "%"));
-    wrap.appendChild(head);
+    return head;
+  }
+
+  function diagnosisKv(a) {
     var kv = el("div", "analysis-kv");
     // Set only when the verdict blames the test case (TEST_DRIFT/SPEC_CHANGE),
     // on both kinds of row — it names the half that has to be repaired.
@@ -22246,7 +22456,14 @@ const CLIENT_JS = `
       kv.appendChild(el("div", "k", t("diag.fix")));
       kv.appendChild(el("div", "v", a.recommendation));
     }
-    if (kv.childNodes.length > 0) wrap.appendChild(kv);
+    return kv.childNodes.length > 0 ? kv : null;
+  }
+
+  function analysisSection(runId, r) {
+    var wrap = el("div", "analysis-box");
+    wrap.appendChild(diagnosisHead(r.analysis));
+    var kv = diagnosisKv(r.analysis);
+    if (kv) wrap.appendChild(kv);
     return wrap;
   }
 
@@ -23359,9 +23576,10 @@ const CLIENT_JS = `
   // 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). Only feeds the audit
-  // column's "audited at" line now; its own finding is superseded by rr.audit.
+  // a failed fetch) — not profile-scoped. It backs the audit column's
+  // "audited at" line and the reason card's finding (runId/label/headline),
+  // so reloadRerun refetches it alongside the rerun report to keep the two
+  // reports of one card equally fresh.
   var perspState = {
     doc: null, q: "", f: "all",
     rerun: null, rerunSupported: null, runUrls: {}, rerunProfiles: [],
@@ -23403,6 +23621,13 @@ const CLIENT_JS = `
       "/attestations?profile=" + encodeURIComponent(state.profile);
   }
 
+  // A person's answer to an audit finding, not an environment: the finding is
+  // about the repository, not a deployed profile, so this carries no
+  // ?profile= (unlike attestationsPath above).
+  function auditDismissalsPath() {
+    return "/api/v1/projects/" + encodeURIComponent(state.project) + "/audit-dismissals";
+  }
+
   // Resolves { report } or { note } and never rejects: a hub that predates
   // 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
@@ -23422,10 +23647,10 @@ const CLIENT_JS = `
 
   // ── perspectives: drift ledger ────────────────────────────────────────
   // Not profile-scoped (see perspState.drift above), so unlike rerunPath this
-  // 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).
+  // takes no ?profile=. The audit AXIS is answered by the /rerun report
+  // (ADR-0014); this ledger supplies what that report does not carry — the
+  // finding's own coordinate and words (runId/at/label/headline), shown in
+  // the audit column's evidence line and the reason card.
 
   function driftPath() {
     return "/api/v1/projects/" + encodeURIComponent(state.project) + "/drift";
@@ -23478,7 +23703,10 @@ const CLIENT_JS = `
   // when it has no entry).
   function rerunReasonText(prefix, reason) {
     var text = t(prefix + reason);
-    return text === prefix + reason ? t(prefix + "unrecognized") : text;
+    if (text === prefix + reason) text = t(prefix + "unrecognized");
+    // Wordings that point at the dismiss control name it by its own label, so
+    // renaming the button cannot silently strand four strings.
+    return text.replace("{dismissButton}", t("perspectives.dismiss.offerButton"));
   }
 
   // Who attested and when, plus their note if they left one — the whole
@@ -23569,7 +23797,6 @@ const CLIENT_JS = `
     return lapse ? why + " · " + lapse : why;
   }
 
-
   // --- pure: rerun composition ---------------------------------------------
   // Self-contained on purpose: no DOM, no closures. rerun-view.test.ts lifts
   // this region out of the rendered page and runs it, because the summary bar
@@ -24011,8 +24238,8 @@ const CLIENT_JS = `
 
   // --- pure: rerun detail labels -------------------------------------------
   // Self-contained on purpose (no DOM, no closures) so rerun-view.test.ts can
-  // 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.
+  // lift this region out of the rendered page and run it: whether the deploy
+  // log answered for this case, and which deploy the reason line names.
 
   // 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
@@ -24022,20 +24249,6 @@ const CLIENT_JS = `
     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
-  // at, so the row is omitted rather than filled with "never failed" — the row
-  // above already carries the last result.
-  function rerunHasFailure(rr) {
-    return !!(rr && rr.lastRed);
-  }
-
   // Which deploy the evidence line names, and how. A "needed" verdict carries
   // the deploy that caused it (touchedByDeploy) when the hub could confirm one,
   // and that is the deploy a reader wants — so it is named, with when it
@@ -24056,51 +24269,81 @@ const CLIENT_JS = `
   }
   // --- end pure: rerun detail labels ----------------------------------------
 
-  // The evidence behind the verdict, as the value of whichever row
-  // rerunEvidenceLabelKey chose. For needed/notNeeded that is what the deploy
-  // log holds since this case last ran, named by rerunChangeLine.
-  // The label already states the timeframe, so the value never repeats it.
-  function rerunEvidenceValue(rr) {
-    var wrap = el("div");
-    if (!rerunHasEvidence(rr)) {
-      wrap.appendChild(el("div", "d-prose", rerunWhyVerdict(rr)));
-      return wrap;
+  // --- pure: audit dismissal reading ----------------------------------------
+  // Self-contained (no DOM, no closures) for the same reason as the regions
+  // above: read rr.auditDismissed against rr.audit, per the schema's own
+  // comment on the field. "clean" means the dismissal is what is holding the
+  // axis there; "drifted"/"undecided" means a later audit re-raised what it
+  // answered, so the old dismissal no longer covers it.
+  // The audit has something outstanding on this spec. Both values mean the
+  // same thing to a reader deciding whether to answer it: the audit read the
+  // code and did not clear the spec (ADR-0019).
+  function auditOpen(rr) {
+    return !!rr && (rr.audit === "drifted" || rr.audit === "undecided");
+  }
+  function auditDismissalActive(rr) {
+    // The hub says whether the dismissal settled the axis. Inferring it from
+    // "clean" would credit the person for a later audit clearing the spec on
+    // its own, which reads identically here.
+    return !!(rr && rr.auditDismissed && rr.auditDismissalApplied);
+  }
+  function auditDismissalReflagged(rr) {
+    return !!(rr && rr.auditDismissed && auditOpen(rr));
+  }
+  // --- end pure: audit dismissal reading -------------------------------------
+
+  // The dismissal's own words, read against the current audit state: active,
+  // it explains why the axis reads clean; re-flagged, it is a fact worth
+  // keeping visible beside the finding that reopened it.
+  function rerunDismissalLine(rr) {
+    if (!rr || !rr.auditDismissed) return null;
+    var d = rr.auditDismissed;
+    if (auditDismissalActive(rr)) {
+      return {
+        muted: false,
+        text: t("perspectives.dismiss.activeNote")
+          .replace("{headline}", d.headline).replace("{by}", d.by).replace("{at}", relTime(d.at)).replace("{note}", d.note),
+      };
     }
-    // Both states require a non-empty deploy log, so a head-less report
-    // contradicts itself; rerunChangeLine then names what is missing rather
-    // than inventing a baseline.
-    var line = rerunChangeLine(rr, perspState.rerun && perspState.rerun.deployHead);
-    var text = t(line.key).replace("{sha}", shortSha(line.sha));
-    if (line.at) text += " · " + relTime(line.at);
-    wrap.appendChild(el("div", "d-prose", text));
-    // A touch the index proved but cannot enumerate leaves no paths to list;
-    // the line above still says a change landed, which is all that is known.
-    if (rr.verdict === "rerunNeeded" && rr.touchedBy && rr.touchedBy.length) {
-      wrap.appendChild(pathCodes(rr.touchedBy));
+    if (auditDismissalReflagged(rr)) {
+      return {
+        muted: true,
+        text: t("perspectives.dismiss.priorNote")
+          .replace("{by}", d.by).replace("{at}", relTime(d.at)).replace("{note}", d.note),
+      };
     }
-    return wrap;
+    return null;
   }
 
-  // The failure: which run it was, then what the analysis concluded. The
-  // headline is model output, already localized server-side, so it is shown as
-  // written. A run made without failure analysis carries neither field, and the
-  // row is then the coordinate alone — what it has always been.
-  function rerunFailureValue(entry) {
+  // The reason card's body when no run-recorded finding is shown: what the
+  // deploy log holds since this case last ran (rerunChangeLine), or why the
+  // verdict landed. The dismissal and lapse notes are the card's own to
+  // append (perspReasonCard), not this value's.
+  function rerunEvidenceValue(rr) {
     var wrap = el("div");
-    wrap.appendChild(ledgerLine(entry));
-    if (entry.label) {
-      var line = el("div", "d-prose", labelText(entry.label));
-      if (entry.headline) line.appendChild(document.createTextNode(" · " + entry.headline));
-      wrap.appendChild(line);
+    if (!rerunHasEvidence(rr)) {
+      wrap.appendChild(el("div", "d-prose", rerunWhyVerdict(rr)));
+    } else {
+      // Both states require a non-empty deploy log, so a head-less report
+      // contradicts itself; rerunChangeLine then names what is missing rather
+      // than inventing a baseline.
+      var line = rerunChangeLine(rr, perspState.rerun && perspState.rerun.deployHead);
+      var text = t(line.key).replace("{sha}", shortSha(line.sha));
+      if (line.at) text += " · " + relTime(line.at);
+      wrap.appendChild(el("div", "d-prose", text));
+      // A touch the index proved but cannot enumerate leaves no paths to
+      // list; the line above still says a change landed, which is all that
+      // is known.
+      if (rr.verdict === "rerunNeeded" && rr.touchedBy && rr.touchedBy.length) {
+        wrap.appendChild(pathCodes(rr.touchedBy));
+      }
     }
     return wrap;
   }
 
-  // Lets a person's own check stand in for the machine's verdict. prompt()/
-  // confirm() rather than a form: the action is rare and the two fields it
-  // needs are short, so a modal would outweigh what it does. reloadRerun()
-  // is the same profile-scoped refresh a profile switch uses — it re-renders
-  // the whole table, so an open detail panel closes along with it.
+  // Lets a person's own check stand in for the machine's verdict. reloadRerun()
+  // is the same refresh a profile switch uses — it re-renders the whole
+  // table, so an open detail panel closes along with it.
   function submitAttestation(method, body) {
     apiFetch(attestationsPath(), {
       method: method,
@@ -24110,17 +24353,16 @@ const CLIENT_JS = `
       .catch(function (err) { window.alert(t("perspectives.manual.error") + ": " + err.message); });
   }
 
-  function manualAttestButton(feature, spec) {
-    var btn = el("button", "btn sm primary", t("perspectives.manual.attestButton"));
-    btn.type = "button";
-    btn.addEventListener("click", function () {
-      var by = window.prompt(t("perspectives.manual.promptBy"), loadAttestBy());
-      if (!by) return;
-      storeAttestBy(by);
-      var note = window.prompt(t("perspectives.manual.promptNote"), "");
-      submitAttestation("PUT", { spec: perspSpecKey(feature, spec), by: by, note: note || undefined });
-    });
-    return btn;
+  // Lets a person say an audit finding was wrong. Same reload contract as
+  // submitAttestation above; a different endpoint (no ?profile=, ADR: a
+  // finding is about the repository).
+  function submitAuditDismissal(method, body) {
+    apiFetch(auditDismissalsPath(), {
+      method: method,
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    }).then(function () { reloadRerun(); })
+      .catch(function (err) { window.alert(t("perspectives.manual.error") + ": " + err.message); });
   }
 
   function manualRevokeButton(feature, spec) {
@@ -24133,16 +24375,251 @@ const CLIENT_JS = `
     return btn;
   }
 
-  // Detail row: a definition list of the case's fields plus the note editor.
-  // Built with createElement/textContent throughout — every field here is
-  // API-derived, so none of it may go through innerHTML.
-  //
-  // The panel shows only what the table row cannot. The row already carries the
-  // title, mode, recorded state, last result and the re-run verdict, so none of
-  // those is repeated: what is left is the case's definition, the evidence the
-  // verdict rests on, and the note.
+  function auditDismissalRevokeButton(feature, spec) {
+    var btn = el("button", "btn ghost sm del", t("perspectives.dismiss.revokeButton"));
+    btn.type = "button";
+    btn.addEventListener("click", function () {
+      if (!window.confirm(t("perspectives.dismiss.confirmRevoke"))) return;
+      submitAuditDismissal("DELETE", { spec: perspSpecKey(feature, spec) });
+    });
+    return btn;
+  }
+
+  // The inline form a "dismiss" or "environment" offer button expands into,
+  // in place of the two window.prompt() calls this replaces. Both kinds ask
+  // for the same two things — who, and why — and differ only in wording and
+  // which endpoint the answer goes to.
+  function buildOverrideForm(kind, feature, spec, onCancel) {
+    var wrap = el("div", "override-form");
+
+    var byRow = el("div", "form-row");
+    byRow.appendChild(el("label", null, t("perspectives.override.byLabel")));
+    var byInput = el("input", "input");
+    byInput.type = "text";
+    byInput.value = loadAttestBy();
+    byRow.appendChild(byInput);
+    wrap.appendChild(byRow);
+
+    var noteRow = el("div", "form-row");
+    noteRow.appendChild(el("label", null, t(kind === "dismiss" ? "perspectives.override.reasonLabel" : "perspectives.override.noteLabel")));
+    var noteInput = el("textarea");
+    noteRow.appendChild(noteInput);
+    wrap.appendChild(noteRow);
+
+    var act = el("div", "of-act");
+    var submitBtn = el("button", "btn sm primary", t("perspectives.override.submit"));
+    submitBtn.type = "button";
+    submitBtn.disabled = true;
+    var cancelBtn = el("button", "btn ghost sm", t("perspectives.override.cancel"));
+    cancelBtn.type = "button";
+    act.appendChild(submitBtn);
+    act.appendChild(cancelBtn);
+    wrap.appendChild(act);
+
+    wrap.appendChild(el("div", "of-hint", t(kind === "dismiss" ? "perspectives.override.dismissHint" : "perspectives.override.envHint")));
+
+    function syncEnabled() {
+      submitBtn.disabled = !(byInput.value.trim() && noteInput.value.trim());
+    }
+    byInput.addEventListener("input", syncEnabled);
+    noteInput.addEventListener("input", syncEnabled);
+    cancelBtn.addEventListener("click", onCancel);
+
+    submitBtn.addEventListener("click", function () {
+      var by = byInput.value.trim();
+      var note = noteInput.value.trim();
+      if (!by || !note) return;
+      storeAttestBy(by);
+      if (kind === "dismiss") submitAuditDismissal("PUT", { spec: perspSpecKey(feature, spec), by: by, note: note });
+      else submitAttestation("PUT", { spec: perspSpecKey(feature, spec), by: by, note: note });
+    });
+
+    return wrap;
+  }
+
+  // A button that expands into buildOverrideForm above in place, rather than
+  // a modal — the action is rare enough that swapping the button for its own
+  // form reads fine without one.
+  function buildOverrideOffer(kind, feature, spec) {
+    var box = el("div", "manual-attest");
+    var openBtn = el("button", "btn sm primary", t(kind === "dismiss" ? "perspectives.dismiss.offerButton" : "perspectives.manual.envButton"));
+    openBtn.type = "button";
+    box.appendChild(openBtn);
+    openBtn.addEventListener("click", function () {
+      box.removeChild(openBtn);
+      var form = buildOverrideForm(kind, feature, spec, function () {
+        box.removeChild(form);
+        box.appendChild(openBtn);
+      });
+      box.appendChild(form);
+    });
+    return box;
+  }
+
+  // The audit-axis override slot: dismiss an open finding, or revoke a
+  // dismissal that is currently the reason the axis reads clean. At most one
+  // of the two ever shows — a finding the axis
+  // itself has cleared, dismissed or not, offers nothing here.
+  // While a job holds the spec, no control shows at all: heldHint promises
+  // the reader that overrides wait for the job, so the buttons must too.
+  function auditOverrideBox(feature, spec, rr) {
+    if (rr.heldBy) return null;
+    if (auditDismissalActive(rr)) {
+      var box = el("div", "manual-attest");
+      box.appendChild(auditDismissalRevokeButton(feature, spec));
+      return box;
+    }
+    if (auditOpen(rr)) return buildOverrideOffer("dismiss", feature, spec);
+    return null;
+  }
+
+  // The execution-axis override slot: revoke a standing attestation, or offer
+  // one for an environment-caused failure — but only when the audit axis has
+  // no open finding of its own, which is auditOverrideBox's problem to answer,
+  // not this one's.
+  function executionOverrideBox(feature, spec, rr) {
+    if (rr.heldBy) return null;
+    if (rr.manual) {
+      var box = el("div", "manual-attest");
+      if (rr.verdict !== "manuallyVerified") box.appendChild(el("div", "d-prose", manualAttestationText(rr.manual)));
+      box.appendChild(manualRevokeButton(feature, spec));
+      return box;
+    }
+    // Only once the audit has actually cleared the spec: while it is still
+    // due, nobody knows yet whether the environment was the only thing wrong.
+    if (rr.audit === "clean" && rr.execution === "failed" && rr.lastRed && rr.lastRed.label === "ENVIRONMENT") {
+      return buildOverrideOffer("environment", feature, spec);
+    }
+    return null;
+  }
+
+  // ── the reason card ──────────────────────────────────────────────────────
+  // One card that answers "why is the verdict what it is". When an axis
+  // stands on a run-recorded finding (an open audit finding, or the failure
+  // the execution axis reports), the card carries that finding in full,
+  // fetched from the run's own report — where cause, fix and evidence
+  // already live. Everything a person may do about the state (dismiss,
+  // attest, revoke) sits in the same card, beside the reason it answers.
+
+  var runReportCache = {};
+  function fetchRunReport(runId) {
+    if (!runReportCache[runId]) {
+      // Same endpoint (and so the same HTTP cache entry) the run view reads.
+      // A failure is not cached: a transient 502 costs one refetch on the
+      // next expand instead of pinning the fallback for the session.
+      runReportCache[runId] = apiFetch("/api/v1/runs/" + encodeURIComponent(runId) + "/report")
+        .catch(function () { delete runReportCache[runId]; return null; });
+    }
+    return runReportCache[runId];
+  }
+
+  function reportRowFor(report, key) {
+    var rows = (report && report.results) || [];
+    for (var i = 0; i < rows.length; i++) {
+      if (rows[i].feature + "/" + rows[i].spec === key) return rows[i];
+    }
+    return null;
+  }
+
+  // Which run-recorded finding the card shows, if any: an open audit finding
+  // wins (it is why nothing runs), else the failure the execution axis stands
+  // on. The ledger's own label/headline are the instant fallback while the
+  // report loads — and the whole content if it never arrives.
+  function reasonFindingSource(rr, driftEntry) {
+    if (auditOpen(rr) && driftEntry && driftEntry.runId && driftEntry.label) return driftEntry;
+    if (rr.execution === "failed" && rr.lastRed && rr.lastRed.runId && rr.lastRed.label) return rr.lastRed;
+    return null;
+  }
+
+  function perspReasonCard(feature, spec, rr, driftEntry) {
+    var card = el("div", "analysis-box");
+    var source = reasonFindingSource(rr, driftEntry);
+
+    if (source) {
+      // The ledger's label/headline render at once; the run's own report
+      // replaces them with the full diagnosis (the same head/kv the run view
+      // builds) when — and if — it arrives.
+      var note = el("span", "p-head-note", rerunWhyVerdict(rr));
+      var slot = el("div");
+      var head = el("div", "analysis-head");
+      head.appendChild(labelChip(source.label));
+      head.appendChild(note);
+      slot.appendChild(head);
+      if (source.headline) {
+        var kv = diagnosisKv({ headline: source.headline });
+        if (kv) slot.appendChild(kv);
+      }
+      card.appendChild(slot);
+
+      // A graded finding is the human's word, not the model's: the ledger
+      // carries the corrected label/headline, while the run's report still
+      // holds the original prediction. Upgrading would show the guess the
+      // person explicitly overwrote, so the card keeps the ledger's version.
+      if (source.graded) return finishReasonCard(card, feature, spec, rr);
+
+      fetchRunReport(source.runId).then(function (report) {
+        var reportRow = reportRowFor(report, perspSpecKey(feature, spec));
+        var a = reportRow && reportRow.analysis;
+        if (!a) {
+          if (!source.headline) slot.appendChild(el("div", "d-prose muted", t("perspectives.finding.loadFailed")));
+          return;
+        }
+        // The ledger's one-liner stands in when the report row lost its own.
+        if (!a.headline) a.headline = source.headline || "";
+        clear(slot);
+        var fullHead = diagnosisHead(a);
+        fullHead.appendChild(note);
+        slot.appendChild(fullHead);
+        var fullKv = diagnosisKv(a);
+        if (fullKv) slot.appendChild(fullKv);
+        var evi = analysisEvidenceSection(reportRow);
+        if (evi.count) slot.appendChild(detailsBlock(t("acc.evidence"), evi.count, evi.node));
+      });
+    } else {
+      // No finding to show: the reason is the deploy-log answer, or the
+      // verdict's own wording.
+      card.appendChild(rerunEvidenceValue(rr));
+    }
+
+    return finishReasonCard(card, feature, spec, rr);
+  }
+
+  // The card's shared tail: the dismissal/lapse notes and the person's
+  // controls, appended after whichever body the card ended up with.
+  function finishReasonCard(card, feature, spec, rr) {
+    var dline = rerunDismissalLine(rr);
+    if (dline) card.appendChild(el("div", "d-prose" + (dline.muted ? " muted" : ""), dline.text));
+    var lapse = rerunManualLapseText(rr);
+    if (lapse) card.appendChild(el("div", "d-prose muted", lapse));
+    var auditBox = auditOverrideBox(feature, spec, rr);
+    if (auditBox) card.appendChild(auditBox);
+    var execBox = executionOverrideBox(feature, spec, rr);
+    if (execBox) card.appendChild(execBox);
+    return card;
+  }
+
+  // Detail row: the case's current state first, then why the verdict is what
+  // it is, then what the case does, then the note — a stack of cards in the
+  // order a reader asks the questions. Built with createElement/textContent
+  // throughout — every field here is API-derived, so none of it may go
+  // through innerHTML.
   function perspDetailContent(feature, spec) {
     var frag = document.createDocumentFragment();
+    var rr = ledgerEntryFor(perspState.rerun, feature, spec);
+    var driftEntry = ledgerEntryFor(perspState.drift, feature, spec);
+
+    // The two axis states stay in the table row only — the panel answers why,
+    // not what, so it opens straight on the reason.
+    if (rr) {
+      var reason = el("div", "p-sect");
+      reason.appendChild(el("div", "p-slabel", t("perspectives.d.whyVerdict")));
+      reason.appendChild(perspReasonCard(feature, spec, rr, driftEntry));
+      frag.appendChild(reason);
+    }
+
+    var contents = el("div", "p-sect");
+    contents.appendChild(el("div", "p-slabel", t("perspectives.d.contents")));
+    var ccard = el("div", "analysis-box");
     var dl = el("dl", "d-grid");
     function row(labelKey, valueNode) {
       dl.appendChild(el("dt", null, t(labelKey)));
@@ -24159,20 +24636,7 @@ const CLIENT_JS = `
     }
     if (spec.startScreen) row("perspectives.d.startScreen", spec.startScreen);
     if (spec.testCondition) row("perspectives.d.testCondition", spec.testCondition);
-    // The spec id stays: it is what a user types to re-run this case, and the
-    // table shows the title, never the id.
-    row("perspectives.d.spec", el("code", null, spec.specName));
-
-    var rr = ledgerEntryFor(perspState.rerun, feature, spec);
-    if (rr) {
-      row(rerunEvidenceLabelKey(rr), rerunEvidenceValue(rr));
-      if (rerunHasFailure(rr)) row("perspectives.d.lastRed", rerunFailureValue(rr.lastRed));
-    }
-    frag.appendChild(dl);
-
     if (spec.steps && spec.steps.length) {
-      var stepsBox = el("div", "steps-box");
-      stepsBox.appendChild(el("div", "slabel", t("perspectives.d.steps")));
       var stepsList = el("ol", "d-steps");
       spec.steps.forEach(function (step) {
         var li = el("li");
@@ -24186,30 +24650,14 @@ const CLIENT_JS = `
         }
         stepsList.appendChild(li);
       });
-      stepsBox.appendChild(stepsList);
-      frag.appendChild(stepsBox);
-    }
-
-    // A standing attestation always offers revoke — even when it changed
-    // nothing (a held or machine-verified spec), it exists and must stay
-    // findable. A lapsed one is named right here, beside the attest button
-    // the reader is deciding whether to press.
-    var manualBtn = null;
-    if (rr && rr.manual) manualBtn = manualRevokeButton(feature, spec);
-    else if (rr && (rr.verdict === "needsRepair" || rr.verdict === "rerunNeeded")) manualBtn = manualAttestButton(feature, spec);
-    if (manualBtn) {
-      var manualBox = el("div", "manual-attest");
-      if (rr.manual && rr.verdict !== "manuallyVerified") {
-        manualBox.appendChild(el("div", "d-prose", manualAttestationText(rr.manual)));
-      }
-      var lapseLine = rerunManualLapseText(rr);
-      if (lapseLine) manualBox.appendChild(el("div", "d-prose", lapseLine));
-      manualBox.appendChild(manualBtn);
-      frag.appendChild(manualBox);
+      row("perspectives.d.steps", stepsList);
     }
+    ccard.appendChild(dl);
+    contents.appendChild(ccard);
+    frag.appendChild(contents);
 
-    var notebox = el("div", "notebox");
-    notebox.appendChild(el("div", "nlabel", t("perspectives.note.label")));
+    var notebox = el("div", "notebox p-sect");
+    notebox.appendChild(el("div", "p-slabel", t("perspectives.note.label")));
     var ta = el("textarea");
     ta.placeholder = t("perspectives.note.placeholder");
     ta.value = spec.note || "";
@@ -24218,8 +24666,8 @@ const CLIENT_JS = `
     var saveBtn = el("button", "btn primary", t("common.save"));
     saveBtn.type = "button";
     var statusEl = el("span", "nstatus");
-    nact.appendChild(saveBtn);
     nact.appendChild(statusEl);
+    nact.appendChild(saveBtn);
     notebox.appendChild(nact);
     frag.appendChild(notebox);
 
@@ -24275,6 +24723,7 @@ const CLIENT_JS = `
 
         var titleTd = el("td", "c-title");
         titleTd.appendChild(document.createTextNode(spec.title));
+        titleTd.appendChild(el("span", "c-id", perspSpecKey(feature, spec)));
         if (spec.summary) titleTd.appendChild(el("span", "csum", spec.summary));
         row.appendChild(titleTd);
 
@@ -24407,8 +24856,8 @@ const CLIENT_JS = `
           loadRerun().catch(function (err) {
             setPerspNote("persp-rerun-note", t("perspectives.rerun.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.
+          // A failed or unsupported fetch just omits the "audited at" line
+          // and the reason card's finding detail, no banner.
           loadDrift().catch(function () {}),
         ]);
       })
@@ -24547,29 +24996,32 @@ const CLIENT_JS = `
     });
   }
 
-  // Loaded once per project open — never re-run on a profile switch, since
-  // 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.
+  // Loaded on project open and again on every reloadRerun: the reason card
+  // joins rr.audit against this ledger's entry (runId/headline), so the two
+  // must not drift apart after a dismissal or attestation. An older or
+  // unreachable hub degrades to the axis alone — not worth a banner.
   function loadDrift() {
     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;
+        // A transient failure keeps the copy already loaded — blanking it
+        // would drop the audit coordinates and the reason card's finding
+        // for the rest of the session.
+        if (report) perspState.drift = report;
         renderPerspectives();
       });
   }
 
-  // Switching profile re-asks only the profile-scoped question: the
-  // perspectives document itself is project-scoped and does not change, and
-  // neither does the run index loadRerun used to (wastefully) re-fetch.
+  // Re-asks the rerun question and refreshes the drift ledger beside it (the
+  // reason card reads both; see perspState.drift). The perspectives document
+  // itself is project-scoped and does not change, and neither does the run
+  // index loadRerun used to (wastefully) re-fetch.
   function reloadRerun() {
     perspState.rerun = null;
     setPerspNote("persp-rerun-note", "");
     setPerspDeployHead(null);
     renderPerspectives();
+    loadDrift().catch(function () {});
     return loadRerun();
   }
 
@@ -25502,6 +25954,9 @@ function registerRoutes(router, config, queue) {
 	router.get("/api/v1/projects/:project/attestations", createGetAttestationsHandler(storage));
 	router.put("/api/v1/projects/:project/attestations", createPutAttestationHandler(storage));
 	router.delete("/api/v1/projects/:project/attestations", createDeleteAttestationHandler(storage));
+	router.get("/api/v1/projects/:project/audit-dismissals", createGetAuditDismissalsHandler(storage));
+	router.put("/api/v1/projects/:project/audit-dismissals", createPutAuditDismissalHandler(storage));
+	router.delete("/api/v1/projects/:project/audit-dismissals", createDeleteAuditDismissalHandler(storage));
 	router.get("/api/v1/projects/:project/acks/:name", createGetAckHandler(storage));
 	router.put("/api/v1/projects/:project/acks/:name", createPutAckHandler(storage));
 	router.post("/api/v1/projects/:project/spend", createRecordSpendHandler(storage));
@@ -25794,6 +26249,9 @@ function specLocksPath(root, project, profile) {
 function attestationsPath(root, project, profile) {
 	return join(root, "attestations", project, profile, "attestations.json");
 }
+function auditDismissalsPath(root, project) {
+	return join(root, "audit-dismissals", `${project}.json`);
+}
 function ackPath(root, project, profile, name) {
 	return join(root, "acks", project, profile, `${name}.json`);
 }
@@ -25851,6 +26309,22 @@ function createFileAttestationStore(root) {
 	};
 }
 //#endregion
+//#region src/hub/core/storage/file/audit-dismissal-store.ts
+function toDismissals(doc) {
+	const parsed = AuditDismissalsSchema.safeParse(doc);
+	return parsed.success ? parsed.data : { specs: {} };
+}
+function createFileAuditDismissalStore(root) {
+	return {
+		async get(project) {
+			return toDismissals(await readJson(auditDismissalsPath(root, project)));
+		},
+		async update(project, mutate) {
+			return updateJson(auditDismissalsPath(root, project), (current) => mutate(toDismissals(current)));
+		}
+	};
+}
+//#endregion
 //#region src/hub/core/storage/file/artifact-store.ts
 /**
 * Defense-in-depth: `relPath` is expected to already be validated by the
@@ -26335,7 +26809,8 @@ function createFileHubStorage(dataDir) {
 		locks: createFileLockStore(dataDir),
 		acks: createFileAckStore(dataDir),
 		spend: createFileSpendStore(dataDir),
-		attestations: createFileAttestationStore(dataDir)
+		attestations: createFileAttestationStore(dataDir),
+		auditDismissals: createFileAuditDismissalStore(dataDir)
 	};
 }
 //#endregion