tickmarkr 2.7.9 → 2.8.1

package/dist/adapters/codex.d.ts

@@ -5,7 +5,7 @@ export declare function readCodexModelsCache(path?: string): {
     retirements?: Record<string, ModelRetirement | null>;
     hidden?: string[];
 };
-export declare const CODEX_GIT_GRANT = "-c \"sandbox_workspace_write.writable_roots=[$(tkr_common=$(git rev-parse --path-format=absolute --git-common-dir); tkr_gitdir=$(git rev-parse --absolute-git-dir); if [ \"$tkr_gitdir\" != \"$tkr_common\" ]; then printf '\"%s\",' \"$tkr_gitdir\"; fi; printf '\"%s/objects\",\"%s/refs\",\"%s/logs\"' \"$tkr_common\" \"$tkr_common\" \"$tkr_common\")]\"";
+export declare const CODEX_GIT_GRANT = "-c \"sandbox_workspace_write.writable_roots=[$(tkr_common=$(git rev-parse --path-format=absolute --git-common-dir && echo /) && tkr_gitdir=$(git rev-parse --absolute-git-dir && echo /) && tkr_common=${tkr_common%?/} && tkr_gitdir=${tkr_gitdir%?/} && { tkr_head=$(git symbolic-ref -q HEAD); [ $? -le 1 ]; } && case $tkr_head in (refs/heads/*) tkr_leaf=${tkr_head%/*};; (*) tkr_leaf=;; esac && [ \"$(printf %s \"$tkr_common$tkr_gitdir$tkr_leaf\" | LC_ALL=C tr -d '\\0-\\37\\177\"\\\\')\" = \"$tkr_common$tkr_gitdir$tkr_leaf\" ] && { [ \"$tkr_gitdir\" = \"$tkr_common\" ] || printf '\"%s\",' \"$tkr_gitdir\"; } && printf '\"%s/objects\"' \"$tkr_common\" && { [ -z \"$tkr_leaf\" ] || printf ',\"%s/%s\",\"%s/logs/%s\"' \"$tkr_common\" \"$tkr_leaf\" \"$tkr_common\" \"$tkr_leaf\"; })]\"";
 export declare const CODEX_TRUST_DIALOG: TrustDialog;
 export declare const CODEX_INPUT_BOX: import("./types.js").InputBox;
 export declare function seedCodexTrust(repoRoot: string, configPath?: string): TrustVerdict;

package/dist/adapters/codex.js

@@ -106,13 +106,25 @@ function codexRetirement(upgrade) {
 // worktree cwd, for Codex WORKERS only: v2.6.7 T4 (D-1046) — invoke() (the headless worker form, including
 // the interactive size fallback) and interactiveCommand carry it; headlessCommand, which judge, review,
 // consult and the model probe launch, carries no writable_roots at all (those seats never commit).
-// v2.6.6 T9 (K, D-912): the grant is exactly what a linked-worktree branch commit writes — the worktree's
-// own gitdir (only when it differs from the common dir), common/objects, common/refs, common/logs. The
-// shipped [common] grant (and D-910's [common, gitdir]) let a sandboxed seat write <common>/hooks and
-// <common>/config, which unsandboxed git later runs. No common-root fallback: an ordinary checkout gets
-// no gitdir root and its commit fails closed. packed-refs is not granted (packed-ref ops fail closed).
+// v2.6.6 T9 (K, D-912) → v2.8.0 T1 (rows 17/18, D-910): the grant is a LEAF of what a linked-worktree branch
+// commit writes, never the shared hooks/config (the shipped [common] and D-910's [common, gitdir] let a seat
+// write <common>/hooks and <common>/config, which unsandboxed git later runs) and never whole common/refs and
+// common/logs (which let a seat move main, any branch or tag, or the stash). The closed root table, in order:
+//   - the worktree's own gitdir, only when it differs from the common dir (an ordinary checkout gets none);
+//   - <common>/objects;
+//   - only when HEAD is a symbolic ref refs/heads/<B>: <common>/refs/heads/<D> and <common>/logs/refs/heads/<D>,
+//     <D> being <B> without its last slash-separated segment (refs/heads itself when <B> holds no slash);
+//     a detached HEAD gets no refs or reflog root.
+// A directory outside any repository, any failed git read, or any root holding a character of the closed
+// forbidden set (U+0000 to U+001F, U+007F DEL, the double quote, the backslash) yields the EMPTY array `[]`:
+// no git write root, so a commit fails closed — never a partial array, an escaped string or codex's
+// literal-string fallback. Every emitted root is therefore a TOML basic string that parses back to the exact
+// path (git's own trailing newline is stripped through a sentinel, never a path's). No common-root fallback;
+// packed-refs is not granted (packed-ref ops fail closed); stash, tags, notes and branches outside the leaf
+// are denied. Declared: sibling refs in the same leaf (other task branches, the run's integration branch
+// under the default prefix) stay writable until 2.8.1's integration identity.
 // doctor's probe (codex-commit-check.ts) executes these exact bytes; it never rebuilds the grant.
-export const CODEX_GIT_GRANT = `-c "sandbox_workspace_write.writable_roots=[$(tkr_common=$(git rev-parse --path-format=absolute --git-common-dir); tkr_gitdir=$(git rev-parse --absolute-git-dir); if [ "$tkr_gitdir" != "$tkr_common" ]; then printf '"%s",' "$tkr_gitdir"; fi; printf '"%s/objects","%s/refs","%s/logs"' "$tkr_common" "$tkr_common" "$tkr_common")]"`;
+export const CODEX_GIT_GRANT = `-c "sandbox_workspace_write.writable_roots=[$(tkr_common=$(git rev-parse --path-format=absolute --git-common-dir && echo /) && tkr_gitdir=$(git rev-parse --absolute-git-dir && echo /) && tkr_common=\${tkr_common%?/} && tkr_gitdir=\${tkr_gitdir%?/} && { tkr_head=$(git symbolic-ref -q HEAD); [ $? -le 1 ]; } && case $tkr_head in (refs/heads/*) tkr_leaf=\${tkr_head%/*};; (*) tkr_leaf=;; esac && [ "$(printf %s "$tkr_common$tkr_gitdir$tkr_leaf" | LC_ALL=C tr -d '\\0-\\37\\177"\\\\')" = "$tkr_common$tkr_gitdir$tkr_leaf" ] && { [ "$tkr_gitdir" = "$tkr_common" ] || printf '"%s",' "$tkr_gitdir"; } && printf '"%s/objects"' "$tkr_common" && { [ -z "$tkr_leaf" ] || printf ',"%s/%s","%s/logs/%s"' "$tkr_common" "$tkr_leaf" "$tkr_common" "$tkr_leaf"; })]"`;
 // OBS-125: codex 0.144.x gates enabled hooks behind PER-PROJECT-PATH hook trust — a NEW gate distinct
 // from the directory trust seedCodexTrust seeds. Every worker runs in a fresh ephemeral worktree, an
 // untrusted project, so codex re-prompts "Hooks need review" and the interactive worker stalls forever

package/dist/adapters/fake.js

@@ -2,6 +2,40 @@ import { readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { parseWorkerResult } from "./prompt.js";
 import { OPENCODE_BUSY_FRAME_MARKERS, shq, TokenUsageSchema } from "./types.js";
+/**
+ * S23: the first citation of the gate's nonce-framed index — from the LAST line exactly `CITABLE_LINES_BEGIN <nonce>`
+ * to the next line exactly `CITABLE_LINES_END <nonce>`. Every entry must be a JSON object with a string path and a
+ * non-empty array of non-negative safe-integer lines before any is used; otherwise (no block, no END, an empty or
+ * invalid entry anywhere) there is no citation. Never throws.
+ */
+function firstCitation(prompt, nonce) {
+    if (!nonce)
+        return undefined;
+    const lines = prompt.split("\n");
+    const begin = lines.lastIndexOf(`CITABLE_LINES_BEGIN ${nonce}`);
+    const end = begin < 0 ? -1 : lines.indexOf(`CITABLE_LINES_END ${nonce}`, begin + 1);
+    if (end < 0)
+        return undefined;
+    const entries = [];
+    for (const line of lines.slice(begin + 1, end)) {
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            return undefined;
+        }
+        if (!entry || typeof entry !== "object" || Array.isArray(entry))
+            return undefined;
+        const { path, lines: cited } = entry;
+        if (typeof path !== "string" || !Array.isArray(cited) || cited.length === 0
+            || !cited.every((n) => Number.isSafeInteger(n) && n >= 0))
+            return undefined;
+        entries.push({ path, lines: cited });
+    }
+    const first = entries[0];
+    return first ? { path: first.path, line: first.lines[0] } : undefined;
+}
 // ponytail: deterministic scripted adapter — the whole integration suite runs on it, zero tokens.
 export class FakeAdapter {
     scriptPath;
@@ -77,13 +111,15 @@ export class FakeAdapter {
                     val = { ...verdict, criteria: items.map((criterion) => ({ criterion, met: true, reason: "scripted fake pass" })) };
                 }
             }
+            // S23: a scripted row without evidence cites the first line of the first entry of the gate's own citable
+            // index — never a string. An invalid or unterminated index yields no evidence (the gate then fails closed).
             if (key === "judge" && isJudge && val && typeof val === "object" && !Array.isArray(val)) {
                 const verdict = val;
-                const line = /```diff\n([\s\S]*?)```/.exec(prompt)?.[1].split("\n").find((candidate) => candidate.trim());
-                if (line && Array.isArray(verdict.criteria)) {
+                const evidence = firstCitation(prompt, nonce);
+                if (evidence && Array.isArray(verdict.criteria)) {
                     val = {
                         ...verdict,
-                        criteria: verdict.criteria.map((row) => row && typeof row === "object" && !("evidence" in row) ? { ...row, evidence: line } : row),
+                        criteria: verdict.criteria.map((row) => row && typeof row === "object" && !("evidence" in row) ? { ...row, evidence } : row),
                     };
                 }
             }
@@ -152,10 +188,12 @@ export class FakeAdapter {
     }
     // the run nonce lives in the prompt writePrompt handed us; echo a matching trailer so
     // parseWorkerResult(output, nonce) succeeds exactly as before the nonce existed
+    // S23: the verdict nonce is the LAST whole `VERDICT_NONCE: <hex>` line — the gate writes its own after the goal,
+    // criteria and diff, so a nonce line quoted in any of them never binds.
     nonceFor(promptFile) {
         try {
             const prompt = readFileSync(promptFile, "utf8");
-            return /VERDICT_NONCE:\s*([0-9a-f]+)/i.exec(prompt)?.[1]
+            return prompt.split("\n").map((line) => /^VERDICT_NONCE: ([0-9a-f]+)$/.exec(line)?.[1]).filter(Boolean).at(-1)
                 ?? /TICKMARKR_RESULT_([0-9a-z]+)/.exec(prompt)?.[1]
                 ?? "";
         }

package/dist/cli/commands/approve.js

@@ -5,6 +5,7 @@ import { allAdapters } from "../../adapters/registry.js";
 import { channelKey } from "../../adapters/types.js";
 import { loadConfig } from "../../config/config.js";
 import { integrationBranch } from "../../run/merge.js";
+import { integrationAnchor } from "../../run/daemon.js";
 import { separabilityErrors, surfaceErrors, taskBudgetErrors } from "../../compile/collateral.js";
 import { GATE_NAMES } from "../../graph/schema.js";
 import { applyScopeAmendments, bindingToken, captureOwedCheck, engagementComparable, engagementReleased, failedGateBeforePark, parseBindingToken, physicalLine, ATTEMPT_CAP_RELEASE, GATE_SATISFIED_RELEASE, Journal, RECHECK_RELEASE, REVIEW_UPHELD_RELEASE } from "../../run/journal.js";
@@ -168,6 +169,11 @@ export async function approve(argv, cwd = process.cwd()) {
     const serialization = await acquireApprovalSerialization(cwd, runId);
     try {
         const journal = Journal.open(cwd, runId);
+        // 2.8.1 T3 (ANL-023 §7.3): a marked run's recheck counts against its journal anchor; an unreadable one admits nothing.
+        const anchor = integrationAnchor(journal.read());
+        if (recheck && anchor && "unreadable" in anchor) {
+            throw new Error(`refusing to recheck ${taskId} in ${runId}: its journal names no readable published tip (${anchor.unreadable})`);
+        }
         const status = journal.replayStatuses().get(taskId);
         if (status === undefined) {
             throw new Error(`task ${taskId} has no events in run ${runId} — unknown task or never dispatched`);
@@ -308,12 +314,12 @@ export async function approve(argv, cwd = process.cwd()) {
             // daemon's boundary never observes the decision without its obligation (or a second write).
             // The seats a review discharge may resolve to are this repository's declared channels, recorded on
             // the row so every later fold reads the same table whatever process or checkout it runs in.
-            let integrationRef = "unknown";
+            let byName = "unknown";
             let declared;
             let owedTask;
             try {
                 const cfg = loadConfig(cwd);
-                integrationRef = integrationBranch(cfg, runId);
+                byName = integrationBranch(cfg, runId);
                 declared = allAdapters().flatMap((a) => a.channels(cfg)).map((c) => ({ key: channelKey(c), vendor: c.vendor }));
             }
             catch { /* an unreadable config binds no range and declares no seat: unknown */ }
@@ -321,11 +327,15 @@ export async function approve(argv, cwd = process.cwd()) {
                 owedTask = loadGraph(cwd).tasks.find((t) => t.id === taskId);
             }
             catch { /* recorded as unknown criteria and scope */ }
-            const obligation = captureOwedCheck({
+            const integration = integrationBase(journal.read(), () => byName);
+            const owed = captureOwedCheck({
                 cwd, runId, taskId, gate: failedGate, events, acceptance: owedTask?.acceptance, files: owedTask?.files, declared,
                 cause: reason ?? `operator waived failed ${failedGate} gate`, // the row's own park field binds the park
-                taskRef: `${integrationRef}--${taskId}`, integrationRef,
+                taskRef: `${integration.branch}--${taskId}`, integrationRef: integration.base,
             });
+            // An unreadable anchor still records the waive, its obligation unknown: the debt is never silently known.
+            const obligation = integration.unreadable === undefined ? owed
+                : { ...owed, known: false, unknownReason: `its journal names no readable published tip (${integration.unreadable})` };
             journal.append("task-approved", taskId, {
                 by,
                 ...(reason ? { reason } : {}),
@@ -370,6 +380,20 @@ export async function approve(argv, cwd = process.cwd()) {
         serialization.release();
     }
 }
+/**
+ * 2.8.1 T3 (ANL-023 §7.3): the integration branch and base a decision reads. A marked run (run-start
+ * `integrationAnchor: "journal"`) takes its branch from run-start, never the current config, and its base is the
+ * journal anchor A (`unreadable` when the journal names none); an unmarked run reads the branch by name, as before.
+ */
+function integrationBase(events, byName) {
+    const anchor = integrationAnchor(events);
+    if (!anchor) {
+        const branch = byName();
+        return { branch, base: branch };
+    }
+    const branch = String(events.find((e) => e.event === "run-start").data.branch);
+    return "anchor" in anchor ? { branch, base: anchor.anchor } : { branch, base: "unknown", unreadable: anchor.unreadable };
+}
 /** The row a decision on this task answers right now: its newest failure when failed, else its newest park. */
 function openDecision(journal, taskId) {
     const { events, sourceIndexes } = readJournalEvents(journal);
@@ -391,11 +415,12 @@ function requireBound(runId, taskId, bound, open, what) {
  * OBS-1022: what a failed task has landed. A preserved snapshot is authoritative only when it contains
  * the current task-branch tip; an older preservation can remain in the journal after a later retry has
  * advanced/rebuilt the branch. Missing task branches may still recover from a preserved ref. The selected
- * ref is counted against the run's integration branch; unreadable refs count as zero and fail closed.
+ * ref is counted against the run's integration base (integrationBase); unreadable refs count as zero and fail closed.
+ * `base` names the branch the text prints; the count reads `integration.base`.
  */
 function failedTaskCommitsAhead(cwd, journal, runId, taskId) {
-    const cfg = loadConfig(cwd);
-    const base = integrationBranch(cfg, runId);
+    const integration = integrationBase(journal.read(), () => integrationBranch(loadConfig(cwd), runId));
+    const base = integration.branch;
     const taskRef = `${base}--${taskId}`;
     const preserved = [...journal.read()].reverse().find((e) => e.taskId === taskId && e.event === "worktree-preserved" && typeof e.data.ref === "string");
     const preservedRef = preserved?.data.ref;
@@ -416,7 +441,7 @@ function failedTaskCommitsAhead(cwd, journal, runId, taskId) {
         }
     }
     try {
-        const out = execFileSync("git", ["rev-list", "--count", `${base}..${ref}`], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+        const out = execFileSync("git", ["rev-list", "--count", `${integration.base}..${ref}`], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
         return { ref, base, count: Number.parseInt(out.trim(), 10) || 0 };
     }
     catch {

package/dist/cli/commands/doctor.js

@@ -22,7 +22,7 @@ import { sh } from "../../run/git.js";
 import { auditNamedTestOracles, listVitestTests } from "../../gates/acceptance.js";
 import { readReviewNoVerdictHistory, reviewNoVerdictRows } from "../../run/journal.js";
 import { checkModelDiscovery } from "../../adapters/model-discovery-check.js";
-import { recordLaunchServices } from "../../run/launchservices-check.js";
+import { LAUNCHSERVICES_PORT_ADVISORY, probeLaunchServicesPorts, recordLaunchServices } from "../../run/launchservices-check.js";
 /** Where a newer `table_<date>.csv` is discovered — the deployed site builds filenames by
  *  concatenation and publishes no index, so the release listing is the only enumerable surface. */
 export const LIVEBENCH_RELEASES_URL = "https://api.github.com/repos/LiveBench/livebench.github.io/contents/public";
@@ -670,7 +670,8 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     const discovery = await checkModelDiscovery({ cwd, cfg, adapters, health, catalog, resolved: resolvedIdentitySnapshot, mayRefresh: !opts.catalog && !catalogRefreshLine && catalogRefreshAllowed, fetcher: opts.catalogFetcher, now: opts.catalogNow });
     catalog = discovery.catalog;
     aliasDriftFindings.push(...discovery.findings);
-    const launchServices = await recordLaunchServices(readDoctor(cwd), health);
+    const portProbe = await probeLaunchServicesPorts();
+    const launchServices = await recordLaunchServices(readDoctor(cwd), health, portProbe.observation);
     writeDoctor(cwd, launchServices.health);
     const rows = adapters.map((a) => {
         const h = health[a.id];
@@ -680,6 +681,14 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
         const healthy = h.installed && (a.id !== kimi.id || h.authed) && !(a.id === codex.id && h.codexCommit === "escape");
         return alignedStatusRow(healthy ? "pass" : "fail", a.id, state);
     });
+    const ports = portProbe.ports;
+    const portLine = ports.status === "non-darwin" ? "launchservicesd ports: not applicable"
+        : ports.status === "read" ? `launchservicesd pid ${ports.pid}: ${ports.count} ports`
+            : `launchservicesd pid ${ports.status === "unknown" ? ports.pid ?? "unknown" : "unknown"}: ports unknown`;
+    if (ports.status !== "skipped") {
+        rows.push(alignedStatusRow(ports.status === "read" && ports.count < LAUNCHSERVICES_PORT_ADVISORY || ports.status === "non-darwin"
+            ? "pass" : "warn", "launchservicesd", portLine));
+    }
     const reviewDemotions = recentReviewDemotions(cwd);
     if (reviewDemotions.length) {
         rows.push(legend("recent review-seat demotions:"));

package/dist/cli/commands/verify.js

@@ -13,11 +13,11 @@ import { runGates } from "../../gates/run-gates.js";
 import { getTask, loadGraph } from "../../graph/graph.js";
 import { GATE_NAMES } from "../../graph/schema.js";
 import { executionSignal } from "../../run/execution-budget.js";
-import { addDetachedWorktree, linkNodeModules, removeWorktree, shGit, shGitOk } from "../../run/git.js";
+import { addDetachedWorktree, linkNodeModules, reflogWitness, removeWorktree, shGit, shGitOk } from "../../run/git.js";
 import { foldOwedChecks, integrationMapped, owedCriteria, Journal, OWED_DISCHARGE_EVENT } from "../../run/journal.js";
 import { describeLeaseWait, withRepositoryLease } from "../../run/lease.js";
 import { isPidLive } from "../../run/lock.js";
-import { recordLaunchServices } from "../../run/launchservices-check.js";
+import { LAUNCHSERVICES_PORT_STOP, probeLaunchServicesPorts, recordLaunchServices } from "../../run/launchservices-check.js";
 /**
  * tickmarkr verify — the gate battery as a standalone command (OPERATING-MODEL-2026-08-11 item 3).
  *
@@ -184,6 +184,14 @@ export async function verify(argv, cwd = process.cwd(), options = {}) {
         },
         allowPositionals: false,
     });
+    const portProbe = await probeLaunchServicesPorts({ requireTop: true });
+    const ports = portProbe.ports;
+    if (ports.status === "read" || ports.status === "unknown") {
+        console.error(`verify: ports ${ports.status === "read" ? ports.count : "unknown"}`);
+    }
+    if (ports.status === "read" && ports.count >= LAUNCHSERVICES_PORT_STOP) {
+        return { out: `verify refused: launchservicesd has ${ports.count} ports (threshold ${LAUNCHSERVICES_PORT_STOP}); log out or restart to reset launchservicesd before verifying`, code: 1 };
+    }
     const stateRoot = await verifyStateRoot(cwd);
     const fileRoot = (file) => existsSync(join(cwd, ".tickmarkr", file)) ? cwd : stateRoot;
     if (resolve(stateRoot) !== resolve(cwd)) {
@@ -192,16 +200,24 @@ export async function verify(argv, cwd = process.cwd(), options = {}) {
     }
     const cfg = loadConfig(fileRoot("config.yaml"));
     const head = (await shGitOk("git rev-parse HEAD", cwd)).trim();
-    // Git appends every move of HEAD to its reflog — one a gate command makes and undoes itself included —
-    // so the log as of this capture is the subject's witness: any later difference is a move (fail closed).
-    const headLogPath = resolve(cwd, (await shGitOk("git rev-parse --git-path logs/HEAD", cwd)).trim());
-    const headLog = () => { try {
-        return readFileSync(headLogPath, "utf8");
+    // The latch reads HEAD's reflog through git as a validated witness, refuses before capture when it
+    // is absent or invalid, and compares it line for line at every subject check.
+    const witnessFault = (witness, commit) => {
+        if (witness.code !== 0)
+            return `exit ${witness.code}`;
+        const newest = witness.lines[0];
+        if (newest === undefined)
+            return "no reflog";
+        if (newest !== commit)
+            return `newest is ${newest.slice(0, 12)}`;
+        return undefined;
+    };
+    const capturedWitness = await reflogWitness(cwd, "HEAD");
+    const fault = witnessFault(capturedWitness, head);
+    if (fault) {
+        throw new Error(`verify refused: HEAD's reflog cannot witness the candidate (${fault}) — record HEAD moves in this checkout, then verify again`);
     }
-    catch {
-        return "";
-    } };
-    const headLogAtCapture = headLog();
+    const headReflogAtCapture = capturedWitness.lines.join("\n");
     const baseTip = (await shGitOk(`git rev-parse '${values.base}'`, cwd).catch(() => {
         throw new Error(`--base ${values.base} is not a resolvable ref — pass --base <ref> naming the branch this diff targets`);
     })).trim();
@@ -493,9 +509,13 @@ export async function verify(argv, cwd = process.cwd(), options = {}) {
     let subjectLatch;
     const subjectChange = async () => {
         const now = await shGitOk("git rev-parse HEAD", cwd).then((out) => out.trim(), () => undefined);
+        // The latch reads HEAD's reflog through git as a validated witness, refuses before capture when it
+        // is absent or invalid, and compares it line for line at every subject check.
+        const witness = now === head ? await reflogWitness(cwd, "HEAD") : undefined;
+        const reflogMoved = witness !== undefined && (witness.code !== 0 || witness.lines.join("\n") !== headReflogAtCapture || witness.lines[0] !== head);
         const why = now === undefined ? "HEAD is unreadable"
             : now !== head ? `HEAD moved from ${head.slice(0, 12)} to ${now.slice(0, 12)}`
-                : headLog() !== headLogAtCapture ? `HEAD moved and was restored to ${head.slice(0, 12)} (its reflog recorded the move)`
+                : reflogMoved ? `HEAD moved and was restored to ${head.slice(0, 12)} (its reflog recorded the move)`
                     : await candidateDirt();
         if (why)
             subjectLatch ??= why;

package/dist/gates/acceptance.d.ts

@@ -12,7 +12,7 @@ export interface JudgeVerdict {
         criterion: string;
         met: boolean;
         reason: string;
-        evidence: string | EvidenceCitation;
+        evidence: EvidenceCitation;
     }>;
     comments?: Array<{
         path: string;