create-agent-rig 0.6.1 → 0.7.0

package/templates/agent-os/universal/.claude/scripts/lib/revalidation-evidence.mjs

@@ -0,0 +1,56 @@
+/** Resolution indexes shared by selection and the aggregate report. */
+export const typedResolutionsOf = (events = []) => {
+  const resolutions = new Map();
+  for (const event of events) {
+    const actionRequired = event.data?.actionRequired ?? event.data?.actionChanged;
+    if (
+      event.kind !== 'revalidation-outcome' ||
+      typeof event.data?.detectionId !== 'string' ||
+      typeof actionRequired !== 'boolean'
+    ) {
+      continue;
+    }
+    const resolvedAt = Date.parse(event.data?.resolvedAt ?? event.at);
+    if (!Number.isFinite(resolvedAt)) continue;
+    const matching = resolutions.get(event.data.detectionId) ?? [];
+    matching.push({ resolvedAt, data: event.data });
+    resolutions.set(event.data.detectionId, matching);
+  }
+  return resolutions;
+};
+
+export const typedResolutionOf = (resolutions, event) => {
+  const detectionAt = Date.parse(event.at);
+  if (typeof event.data?.id !== 'string' || !Number.isFinite(detectionAt)) return null;
+  return (
+    (resolutions.get(event.data.id) ?? [])
+      .filter((resolution) => resolution.resolvedAt >= detectionAt)
+      .sort((left, right) => left.resolvedAt - right.resolvedAt)[0]?.data ?? null
+  );
+};
+
+/** The newest blocking detection in one run that no typed outcome resolves. */
+export const unresolvedBlockingDetectionOf = (events = []) => {
+  const resolutions = typedResolutionsOf(events);
+  for (const event of [...events].reverse()) {
+    if (event.kind !== 'revalidation') continue;
+    const result = event.data?.result;
+    if (!['CHANGED', 'CONFLICT', 'UNVERIFIABLE'].includes(result)) continue;
+    if (typedResolutionOf(resolutions, event)) continue;
+    if (
+      typeof event.data?.id !== 'string' ||
+      typeof event.data?.ticket !== 'string' ||
+      typeof (event.data?.checkpoint ?? event.data?.point) !== 'string'
+    ) {
+      continue;
+    }
+    return {
+      kind: 'revalidation-hold',
+      ticket: event.data.ticket,
+      checkpoint: event.data.checkpoint ?? event.data.point,
+      result,
+      detectionId: event.data.id,
+    };
+  }
+  return null;
+};

package/templates/agent-os/universal/.claude/scripts/lib/shell-tools.mjs

@@ -0,0 +1,81 @@
+/**
+ * The shell-executing tools this rulebook's Never-tier guards must see.
+ *
+ * ONE list, because two spellings of the same fact disagree eventually and the
+ * copy nobody is looking at is the one that is wrong (`.claude/rules/invariants.md`,
+ * "One mechanism, one implementation"). `.claude/settings.json` cannot import
+ * this — it is data, not code — so the correspondence is held by a test rather
+ * than by generation: `test/template/shell-tools.test.ts` reads both and refuses
+ * a tool named here that some shell guard's matcher omits, or a tool in that
+ * matcher this file does not name. That test lives in the generator and is
+ * absent in a generated rig.
+ *
+ * 🔴 **Wiring is not behaviour, and certifying only the wiring is how the gap
+ * this file was written to close survived its own PR.** The matcher was widened
+ * while both guards still opened with a literal `tool_name !== 'Bash'` and
+ * returned allow, so every Never-tier rule and the kill switch stayed
+ * bypassable on the other surface — with the configuration tests green.
+ * The guards therefore IMPORT this list rather than restating it, and the same
+ * test file now spawns them. It is absent in a generated rig, like the one
+ * above: `test/template/shell-tools.test.ts`
+ * › "guard-bash reaches its verdict on every shell tool, not just the one it
+ * was written for" and
+ * › "block-no-verify reaches its verdict on every shell tool"
+ * run one refusal and one positive control per entry below, so a surface added
+ * here without being honoured goes red.
+ *
+ * ── Why this exists (RP-65) ─────────────────────────────────────────────────
+ *
+ * `settings.json` wired `block-no-verify` and `guard-bash` under the matcher
+ * `Bash` alone. Measured on the live harness: `git commit --no-verify --dry-run`
+ * was BLOCKED through the `Bash` tool and RAN through the `PowerShell` tool, in
+ * the same session and the same checkout. On that surface the Never tier and the
+ * kill switch were prose.
+ *
+ * ── Why an enumerated list and not a wildcard ───────────────────────────────
+ *
+ * A matcher that admitted anything would hand these guards tools that execute
+ * nothing — and a guard that fires on a non-shell tool is one somebody turns
+ * off. Adding a surface is a deliberate edit here, which is also where the
+ * reason for each entry is written down.
+ *
+ * ── What widening the matcher does NOT buy ──────────────────────────────────
+ *
+ * 🔴 The same RULES now run on both surfaces; the PARSING is not thereby
+ * identical. `guard-bash` tokenises POSIX shell — quoting, separators, wrappers
+ * — and PowerShell's syntax is its own. A command whose danger is visible only
+ * after PowerShell-specific parsing can read differently there.
+ *
+ * 🔴 **And the kill switch is narrower than it sounds.** It matches a command
+ * NAME, so it refuses the operation only when the operation is spelled that
+ * way. Measured with the brake armed: `gh pr merge …` is refused on both
+ * surfaces; `gh.exe pr merge …`, `Start-Process gh -ArgumentList …` and
+ * `Remove-Item -Recurse -Force C:\` are allowed. The `.exe` spelling is
+ * allowed under `Bash` as well, so the bound belongs to the rule set and not
+ * to the widened matcher.
+ *
+ * That gap is also why `guard-bash.mjs` keeps its name. A rename would promise
+ * a parity the parser does not have, and it would break every installed rig's
+ * manifest for a word.
+ */
+
+/**
+ * The tool names KNOWN to run a shell command — a hand-maintained list.
+ *
+ * - `Bash` — the POSIX surface these guards were written for.
+ * - `PowerShell` — the Windows-native surface, measured to bypass them before
+ *   RP-65. A harness that does not expose it simply never matches the name.
+ *
+ * 🔴 **Nothing checks this list against the harness, and that is the direction
+ * the defect came from.** The tests derive their expectations FROM this
+ * constant, so what they guard is list → matcher → verdict. The opposite
+ * direction — harness → list — is guarded by nobody. A harness that gains a
+ * third shell tool leaves every test green and the Never tier inert on it,
+ * which is exactly what `PowerShell` did until somebody measured it by hand.
+ * Over-listing is safe (an unexposed name never matches); under-listing is
+ * the whole bug, and it is invisible until a person edits this file.
+ */
+export const SHELL_TOOLS = Object.freeze(['Bash', 'PowerShell']);
+
+/** The `matcher` value `settings.json` must carry for the shell guards. */
+export const SHELL_TOOL_MATCHER = SHELL_TOOLS.join('|');

package/templates/agent-os/universal/.claude/scripts/preflight.mjs

@@ -11,19 +11,21 @@
 // reason it is safe to script half a checklist. The honest objection to a partial
 // script — "a script that half-checks is worse than a list the run actually
 // reads" — is true exactly while the boundary is invisible. A silent script would
-// let a GO on four items read as a pass on seven.
+// let a GO on the scripted subset read as a pass on the whole checklist.
 //
 // 🔴 **`unknown` never becomes `pass`.** A probe that could not run tells you
 // nothing, and "I could not look" recorded as "it is fine" is the failure this
 // checklist exists to prevent.
 import { execFileSync } from 'node:child_process';
 import { realpathSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 // One implementation of the brake, shared with the hook that enforces it. This
 // file used to carry its own `process.env.AGENT_LOOP_STOP || <default>`, which is
 // the replace-not-add bug — fixed in the hook and left open here for a full review
 // cycle, because preflight is the only scripted brake check and had no test.
 import { brakeIsOn } from './stop-flag.mjs';
+import { readRevalidationContract } from './lib/claim-records.mjs';
 
 /** The items this script cannot check: judgement, or a call worth more than it saves. */
 export const UNCHECKED = [
@@ -120,6 +122,20 @@ export const checkRunDirNotExported = (env = process.env) => {
     : { ok: true, detail: 'not exported' };
 };
 
+export const checkDetectionContract = (projectRoot) => {
+  try {
+    const contract = readRevalidationContract(projectRoot);
+    return {
+      ok: true,
+      detail:
+        `${contract.detection.mode} via ${contract.detection.sources.join(' + ')}, ` +
+        `${contract.detection.acceptedLatency} accepted latency, no push`,
+    };
+  } catch (error) {
+    return { ok: false, detail: error.message };
+  }
+};
+
 /** The last deploy must have concluded successfully — never start on a broken runtime. */
 export const checkLastDeploy = ({ workflow = 'deploy' } = {}) => {
   try {
@@ -195,9 +211,11 @@ const invokedDirectly = () => {
 };
 
 if (invokedDirectly()) {
+  const projectRoot = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
   const checks = {
     killSwitch: checkKillSwitch(),
     runDirNotExported: checkRunDirNotExported(),
+    detectionContract: checkDetectionContract(projectRoot),
     defaultBranchFresh: checkDefaultBranchFresh(),
     lastDeploy: checkLastDeploy(),
   };

package/templates/agent-os/universal/.claude/scripts/queue/core.mjs

@@ -677,7 +677,8 @@ export const selectNext = (
 
 /**
  * Revalidation at SELECT — is the item the run is about to take the item the
- * last take-up saw?
+ * last take-up saw? This is compatibility EVIDENCE only: claim fingerprints
+ * are the sole authority for scope and commentary drift.
  *
  * The snapshot is the ticket's `updatedAt` marker as recorded at the previous
  * take-up in THIS run (`run-state.mjs` › recordTakeUp). One string compare on
@@ -692,74 +693,13 @@ export const selectNext = (
  * marker that moved: a first sight (no snapshot yet) is `false` with the baseline
  * recorded, not a change.
  *
- * `action` says what the run does with it: `hold` — re-read the item before
- * acting; `continue` — nothing moved; `unverifiable` — no marker to compare.
- *
- * ⚠ Limit: the marker moves on the run's OWN claim and comments too. The
- * tracker adapters re-record the take-up after each write they make (AR-140),
- * so a move made THROUGH the adapter is not a hold — one made by any other
- * route (a hand-posted comment, a connector) still is. This function cannot
- * tell who moved it; the re-read can, and the `loop` skill records that
- * conclusion as a separate `revalidation-outcome` event.
+ * It deliberately returns no `source` and no `action`. Adding either would
+ * restore the marker as a second decision engine beside `.rig/claims/`.
  */
-export const revalidationOf = ({ ticket, snapshot = null }) => {
+export const takeUpEvidenceOf = ({ ticket, snapshot = null }) => {
   const to = typeof ticket?.updatedAt === 'string' ? ticket.updatedAt : null;
   const from = typeof snapshot === 'string' ? snapshot : null;
-  // One shape at every point (AR-136): `source` is the list of what moved,
-  // `action` the same three words BEFORE_PR and BEFORE_CLOSE use, and the two
-  // markers sit under `task` — so a reader of the evidence log needs one parser.
-  const base = { ticket: ticket?.id ?? null, point: 'SELECT', task: { from, to } };
-  if (to === null) return { ...base, changed: null, source: [], action: 'unverifiable' };
-  const changed = from !== null && from !== to;
-  return {
-    ...base,
-    changed,
-    source: changed ? ['task:updatedAt'] : [],
-    action: changed ? 'hold' : 'continue',
-  };
-};
-
-/**
- * Revalidation at BEFORE_PR — the aggregate over two sources, pure.
- *
- * `task` is what {@link revalidationOf} returned for the ticket against the
- * take-up snapshot; `mainChanged` is the list of cited paths the default branch
- * changed since the branch forked (`revalidate.mjs` computes it from git). One
- * source name per finding — `task:updatedAt`, `main:<path>` — so a hold names
- * exactly what moved, never "something changed".
- *
- * `changed` keeps the three values of the SELECT point: `true` when any source
- * moved; `null` when nothing moved but the task could not be checked (no
- * snapshot, no marker, no run) — a blind spot on one side is not a clean pass
- * on both; `false` only when both sides were compared and neither moved.
- */
-export const beforePrRevalidationOf = ({ ticket, task = { changed: null }, mainChanged = [] }) => {
-  const source = [
-    ...(task?.changed === true ? ['task:updatedAt'] : []),
-    ...mainChanged.map((path) => `main:${path}`),
-  ];
-  const changed = source.length > 0 ? true : task?.changed === null ? null : false;
-  const action = changed === true ? 'hold' : changed === null ? 'unverifiable' : 'continue';
-  return { ticket, point: 'BEFORE_PR', changed, source, action };
-};
-
-/**
- * Revalidation at BEFORE_CLOSE — the aggregate over the item's marker and its
- * state, pure. `task` is what {@link revalidationOf} returned against the last
- * validation; `state` is the item's neutral state now. At close the item is
- * expected `in-progress`: `closed` means someone else published it, `open`
- * means someone moved it back, and either is a change the close must not
- * paper over. Same three-valued `changed` and the same actions as BEFORE_PR;
- * `task:updatedAt` is named before `task:state`.
- */
-export const beforeCloseRevalidationOf = ({ ticket, task = { changed: null }, state = null }) => {
-  const source = [
-    ...(task?.changed === true ? ['task:updatedAt'] : []),
-    ...(state !== 'in-progress' ? ['task:state'] : []),
-  ];
-  const changed = source.length > 0 ? true : task?.changed === null ? null : false;
-  const action = changed === true ? 'hold' : changed === null ? 'unverifiable' : 'continue';
-  return { ticket, point: 'BEFORE_CLOSE', changed, source, action };
+  return { changed: to === null ? null : from !== null && from !== to, task: { from, to } };
 };
 
 /**
@@ -933,6 +873,7 @@ export const stopConditionOf = ({
   lastDeployVerdict = null,
   consecutiveEscalations = 0,
   killSwitch = false,
+  revalidationHold = null,
   budgetExhausted = false,
   queueReadable = true,
 } = {}) => {
@@ -966,6 +907,16 @@ export const stopConditionOf = ({
         'in-flight work is not what stopping cleanly means.',
     };
   }
+  if (revalidationHold) {
+    return {
+      kind: 'revalidation-hold',
+      success: false,
+      why:
+        `${revalidationHold.ticket} stopped at ${revalidationHold.checkpoint}: ` +
+        `${revalidationHold.result} (${revalidationHold.detectionId}). Resolve that ` +
+        'detection before selecting more work in this run.',
+    };
+  }
   if (consecutiveEscalations >= 2) {
     return {
       kind: 'repeated-escalation',

package/templates/agent-os/universal/.claude/scripts/queue/github-issues.mjs

@@ -17,8 +17,10 @@ import { execFileSync } from 'node:child_process';
 import { duplicateOf, fingerprintOf, lifecycleOf, ownerOfLabels, validateProposal } from './core.mjs';
 import { withAsOf } from './as-of.mjs';
 import { recordEscalation, recordTakeUp } from '../run-state.mjs';
+import { recordClaimTransition } from '../lib/claim-records.mjs';
 
 export const name = 'github-issues';
+export const claimedState = 'in-progress';
 
 /**
  * A dependency line, and everything after the keyword on it.
@@ -56,6 +58,7 @@ export const blockerIdsOf = (issue) => {
 export const toTicket = (issue, states = {}) => {
   const labels = labelNames(issue);
   const priorityLabel = labels.map((label) => PRIORITY.exec(label)).find(Boolean);
+  const comments = Array.isArray(issue.comments) ? issue.comments : [];
 
   return {
     id: String(issue.number),
@@ -76,10 +79,7 @@ export const toTicket = (issue, states = {}) => {
     blocks: [],
     priority: priorityLabel ? Number(priorityLabel[1]) : 999,
     createdAt: issue.createdAt ?? null,
-    // The take-up marker for revalidation at SELECT: the tracker's own
-    // last-modified field, whose contract (moves on edits, comments and state
-    // changes) is assumed and not checked here. `null` when the listing did not
-    // carry it.
+    // Compatibility evidence only; `.rig/claims/` fingerprints decide drift.
     updatedAt: issue.updatedAt ?? null,
     // The body travels on the neutral shape so the hygiene checks live in one
     // place (core.mjs) instead of once per adapter. This adapter also parses it
@@ -87,6 +87,18 @@ export const toTicket = (issue, states = {}) => {
     // purpose: that is exactly the disagreement `body-claims-unlinked-blocker`
     // exists to surface.
     body: typeof issue.body === 'string' ? issue.body : null,
+    commentary: {
+      count: comments.length,
+      ids: comments
+        .map((comment) => comment?.id)
+        .filter((id) => id !== undefined && id !== null)
+        .map(String),
+      // GitHub CLI expands `comments` to `comments(first: 100)` but exposes no
+      // total or pageInfo beside the resulting array. Fewer than 100 proves the
+      // first page was also the last; exactly 100 cannot prove there is no 101st
+      // comment and must fail closed rather than fingerprint a partial thread.
+      complete: Array.isArray(issue.comments) && comments.length < 100,
+    },
     triage: labels.includes('triage'),
     trigger: labels.includes('trigger-auto')
       ? 'auto'
@@ -130,7 +142,7 @@ const ghText = (args) =>
 
 const ghJson = (args) => JSON.parse(ghText(args));
 
-const FIELDS = 'number,title,body,state,labels,url,createdAt,updatedAt';
+const FIELDS = 'number,title,body,state,labels,url,createdAt,updatedAt,comments';
 
 // --- the adapter contract ------------------------------------------------------
 
@@ -176,10 +188,20 @@ const rebaseline = (ticket) => {
   }
 };
 
-export const claim = (ticket) => {
+export const claim = (ticket, { projectRoot = process.cwd() } = {}) => {
   ghText(['issue', 'edit', ticket.id, '--add-label', 'in-progress']);
+  let workflowClaimRecorded = false;
+  try {
+    workflowClaimRecorded =
+      recordClaimTransition({ projectRoot, ticket, claimedState }) !== null;
+  } catch (error) {
+    process.stderr.write(
+      `#${ticket.id}: the workflow claim landed, but its durable acknowledgement was NOT recorded — ` +
+        `${error.message}\n`,
+    );
+  }
   rebaseline(ticket);
-  return { ok: true };
+  return { ok: true, workflowClaimRecorded };
 };
 
 /**

package/templates/agent-os/universal/.claude/scripts/queue/index.mjs

@@ -20,7 +20,6 @@ import {
   citedPathsOf,
   hygieneOf,
   overtakenOf,
-  revalidationOf,
   selectNext,
   stopConditionOf,
 } from './core.mjs';
@@ -30,6 +29,7 @@ import { changedSinceOf, headShaOf } from './as-of.mjs';
 // apart from `state.mjs` so the read path does not drag the tier computation —
 // and `detect-missed-gate.mjs` behind it — into a CLI that never calls either.
 import { checkoutIsShippable, mainCheckoutRoot } from './checkout.mjs';
+import { revalidateClaim, targetShaOf } from '../lib/claim-records.mjs';
 
 const ADAPTERS = {
   'plan-md': './plan-md.mjs',
@@ -317,12 +317,16 @@ const renderNext = (result, stop, revalidation = null) => {
     return `queue: ${label}${stop.success ? '' : ' (needs attention)'}\n  ${stop.why}\n`;
   }
   const lines = [`next: ${result.ticket.id} — ${result.ticket.title} [${result.ticket.tier}]`];
-  // Only a marker that MOVED earns a line: the unchanged case stays quiet and
-  // cheap, and the no-marker case is in the JSON and the event log, not here.
-  if (revalidation?.changed === true) {
+  // CURRENT and BASELINE_CREATED stay quiet. Every blocking claim result is
+  // visible in text mode too; an exit code with no reason is not operable.
+  if (revalidation?.action === 'hold' || revalidation?.action === 'unverifiable') {
+    const detail =
+      revalidation.source.length > 0
+        ? revalidation.source.join(', ')
+        : (revalidation.evidence?.error ?? revalidation.sourcePointer);
     lines.push(
-      `revalidate: ${revalidation.ticket} hold — ${revalidation.source.join(', ')} ` +
-        `(${revalidation.task.from} → ${revalidation.task.to}) — re-read the item before acting`,
+      `revalidate: ${revalidation.ticket} ${revalidation.action} — ${detail} — ` +
+        're-read the item before acting',
     );
   }
   if (result.skipped.length > 0) {
@@ -530,12 +534,21 @@ if (invokedDirectly()) {
   // pattern it matched on. The load lives here; the READ stays behind the
   // declaration, because a session with no run directory has no state to read
   // and must keep working exactly as before.
-  let readState;
+  let readStateForSelection;
   let stopInputsOf;
   let recordTakeUp;
+  let recordRevalidationHold;
   let previousTakeUp;
+  let previousRunEvidence;
   try {
-    ({ readState, stopInputsOf, recordTakeUp, previousTakeUp } = await import('../run-state.mjs'));
+    ({
+      readStateForSelection,
+      stopInputsOf,
+      recordTakeUp,
+      recordRevalidationHold,
+      previousTakeUp,
+      previousRunEvidence,
+    } = await import('../run-state.mjs'));
   } catch (error) {
     process.stderr.write(
       `run state: ${error.message}\n` +
@@ -586,7 +599,46 @@ if (invokedDirectly()) {
   // `invariants.md` forbids. Selection therefore does NOT stop on the brake, and
   // the `loop` skill tells the run to keep checking it between tasks.
   //
-  const runState = process.env.RIG_RUN_DIR ? readState(process.env.RIG_RUN_DIR) : {};
+  let runState;
+  try {
+    runState = process.env.RIG_RUN_DIR
+      ? readStateForSelection(process.env.RIG_RUN_DIR)
+      : {};
+  } catch (error) {
+    const stop = {
+      kind: 'run-state-unreadable',
+      success: false,
+      why: `${error.message}; the run may contain a stop condition, so selection is refused.`,
+    };
+    process.stdout.write(
+      args.json
+        ? `${JSON.stringify({ stop, revalidation: null }, null, 2)}\n`
+        : `queue: ${stop.kind}\n  ${stop.why}\n`,
+    );
+    process.exit(1);
+  }
+  // `state.json` is the fast stop input; the append-only journal is the durable
+  // run evidence that can reconstruct it after an absent or valid-but-empty
+  // state file. Reuse the shared temporal resolution rule rather than growing
+  // a second definition of "unresolved" in selection. A broken journal keeps
+  // its established lost-trace behaviour; a readable unresolved detection can
+  // never be erased merely by deleting the derived state cache.
+  if (process.env.RIG_RUN_DIR && !runState.revalidationHold) {
+    try {
+      const [{ readRun }, { unresolvedBlockingDetectionOf }] = await Promise.all([
+        import('../run-journal.mjs'),
+        import('../lib/revalidation-evidence.mjs'),
+      ]);
+      const recovered = unresolvedBlockingDetectionOf(
+        readRun({ runDir: process.env.RIG_RUN_DIR }).events,
+      );
+      if (recovered) runState = { ...runState, revalidationHold: recovered };
+    } catch {
+      // The journal's read/write failure contract is handled at its existing
+      // call site below. This reconciliation only restores evidence it can
+      // validate; it never guesses a detection from unreadable bytes.
+    }
+  }
   let stopInputs;
   try {
     // Read through the module that owns the vocabulary, never field by field
@@ -726,27 +778,107 @@ if (invokedDirectly()) {
   // a default derived from `projectRoot` would land the trace inside the very
   // template tree this repository publishes.
   const runDir = process.env.RIG_RUN_DIR;
-  // Revalidation at SELECT (AR-133): the selected item against the marker this
-  // run recorded at its last take-up. Computed only under a declared run —
-  // there is no snapshot to compare against anywhere else — and `null` in the
-  // output then, so a reader can tell "not compared" from "compared, unchanged".
+  // Revalidation at SELECT: the selected item against its durable claim
+  // fingerprints. It runs with or without a declared run; only the evidence
+  // log is run-scoped. Otherwise an attended first SELECT would bypass the
+  // cross-harness baseline the next unattended resume requires.
   //
-  // The baseline is this run's take-up when it has one; otherwise the newest
-  // earlier run's (AR-138) — an item taken up yesterday and re-offered today
-  // used to compare against nothing and report a first sight. `baseline` says
-  // which it was (`this-run` | `previous-run` | null), and `baselineRun` names
-  // the earlier run, so the report can tell the three apart. A rig whose
-  // run-state module predates `previousTakeUp` keeps the per-run behaviour.
+  // Take-up markers remain attached as compatibility evidence. `baseline`
+  // says where that evidence came from; neither it nor `updatedAt` contributes
+  // to the claim result or decides whether the first claim may be created.
   let revalidation = null;
-  if (runDir && result.ticket) {
-    const own = runState.takeUps?.[result.ticket.id];
+  const configuredProjectRoot = projectRootOfConfig(configPath);
+  const claimRoot = configuredProjectRoot ?? projectRoot;
+  if (result.ticket && configuredProjectRoot !== null) {
+    const own = runDir ? runState.takeUps?.[result.ticket.id] : undefined;
     const prior =
-      own === undefined && typeof previousTakeUp === 'function'
+      runDir && own === undefined && typeof previousTakeUp === 'function'
         ? previousTakeUp(runDir, result.ticket.id)
         : null;
     const snapshot = own ?? prior?.updatedAt ?? null;
+    // SELECT events are the sole authority for whether this is first sight or
+    // a resume. A take-up may still supply the compatibility snapshot above,
+    // but it never enters this decision. Every sibling journal comes from the
+    // same bounded resolver as the marker lookup so the evidence windows cannot
+    // drift apart.
+    let selectedBefore = false;
+    let resumeEvidenceError = null;
+    if (runDir) {
+      let journal = null;
+      try {
+        journal = await import('../run-journal.mjs');
+      } catch {
+        selectedBefore = true;
+        resumeEvidenceError = 'current run journal module is unreadable or missing';
+      }
+      const selectedIn = (candidateRunDir) =>
+        journal.readRun({ runDir: candidateRunDir }).events.some(
+          (event) =>
+            event.kind === 'revalidation' &&
+            event.data?.point === 'SELECT' &&
+            String(event.data?.ticket) === String(result.ticket.id) &&
+            typeof event.data?.result === 'string' &&
+            typeof event.data?.sourcePointer === 'string',
+        );
+      if (journal) {
+        try {
+          selectedBefore = selectedIn(runDir);
+        } catch {
+          selectedBefore = true;
+          resumeEvidenceError = 'current run journal is unreadable or invalid';
+        }
+      }
+      if (journal && !selectedBefore) {
+        let candidates = [];
+        let complete;
+        try {
+          const previous = previousRunEvidence(runDir);
+          candidates = previous.runDirs;
+          complete = previous.complete;
+        } catch {
+          complete = false;
+        }
+        let unreadablePrior = false;
+        for (const candidateRunDir of candidates) {
+          try {
+            if (selectedIn(candidateRunDir)) {
+              selectedBefore = true;
+              break;
+            }
+          } catch {
+            unreadablePrior = true;
+          }
+        }
+        if (!selectedBefore && (!complete || unreadablePrior)) {
+          selectedBefore = true;
+          resumeEvidenceError = !complete
+            ? 'prior run journal search is incomplete or truncated by its safety limit'
+            : 'prior run journal is unreadable or invalid';
+        }
+      }
+    }
+    let claim = revalidateClaim({
+      projectRoot: claimRoot,
+      ticket: result.ticket,
+      point: 'SELECT',
+      claimedState: adapter.claimedState,
+      targetSha: targetShaOf(claimRoot),
+      allowCreate: true,
+      isResume: selectedBefore,
+    });
+    if (resumeEvidenceError && claim.result === 'UNVERIFIABLE') {
+      claim = {
+        ...claim,
+        evidence: {
+          ...claim.evidence,
+          error: `${resumeEvidenceError}; ${claim.evidence?.error ?? 'claim cannot be verified'}`,
+        },
+      };
+    }
     revalidation = {
-      ...revalidationOf({ ticket: result.ticket, snapshot }),
+      ...claim,
+      observedAt: new Date().toISOString(),
+      task: { from: snapshot, to: result.ticket.updatedAt ?? null },
       baseline: own !== undefined ? 'this-run' : prior ? 'previous-run' : null,
       ...(prior ? { baselineRun: prior.runDir } : {}),
     };
@@ -821,6 +953,9 @@ if (invokedDirectly()) {
   }
 
   if (revalidation) {
+    if (revalidation.action === 'hold' || revalidation.action === 'unverifiable') {
+      recordRevalidationHold(runDir, revalidation);
+    }
     // Its own try, after the journal's: a state file that cannot be written is
     // not the journal failing, and the selection stands either way — the
     // comparison was made and recorded; only the next baseline is lost.
@@ -840,4 +975,5 @@ if (invokedDirectly()) {
       ? `${JSON.stringify({ ticket: result.ticket, skipped: result.skipped, stop, revalidation }, null, 2)}\n`
       : renderNext(result, stop, revalidation),
   );
+  process.exit(revalidation?.action === 'hold' || revalidation?.action === 'unverifiable' ? 2 : 0);
 }