@uchibeke/gallivant 0.2.1 → 0.3.0

package/lib/tick.mjs

@@ -1,3 +1,9 @@
+import { createHash } from "node:crypto";
+import { PUBLICATION_POLICY_VERSION, publicationPolicyOf, workArtifactViolations, workArtifactError } from "./work_artifacts.mjs";
+import { gitDiffChangedPaths } from "./git_diff.mjs";
+import { hosts, completionAdapter } from "./hosts.mjs";
+import { assertRepositoryAccess, observedIdentityProblem, terminalIdentityProblem } from "./host_contract.mjs";
+import { hostApi } from "./hosts.mjs";
 // The tick: the one actor that changes state. Every `poll_seconds` it walks the registry once, in the order PRD 6.8
 // lays out: settle finished runs, fetch, terminal states, events, dispatch, ready, silence.
 //
@@ -11,12 +17,15 @@
 // on, so a push after that reopens it; `checks_sha` is the head whose failing checks were already dispatched;
 // `receipt_hash` is the completion receipt when the last run started.
 import { STATES, handleFor, prdIdOf, advanceCursor } from "./state.mjs";
-import { deriveEvents, makeTrust, reviewerVerdict, reviewerClock, isGreen, addedLines, hasOwnComment, eventKey, isFixCommand } from "./events.mjs";
+import { repositoryReviewConfig } from "./review_policy.mjs";
+import { readFeedback, requiredFeedback, deriveEvents, makeTrust, reviewerVerdict, exactReviewerVerdict, reviewerClock, isGreen, addedLines, hasOwnComment, eventKey, isFixCommand } from "./events.mjs";
+import { legacyReviewPolicy, policyConfig, reviewBinding, reviewVerdict, needsFirstParty, needsExternal, reviewDigest } from "./review_policy.mjs";
+import { findingsPrompt } from "./review_evidence.mjs";
 import { fixPrompt, registerPrompt } from "./prompt.mjs";
 import { parsePrd, verifyCommands, criteriaFromPrd, briefDivergence, divergenceReason, renderDivergence, retakePrdSnapshot } from "./prd.mjs";
 import { gate, denialsPrompt, receiptInstructions, receiptHash, receiptHashes } from "./deliverable.mjs";
 import { normalizePublicBody } from "./block.mjs";
-import { ROUND_MARKER, NUDGE_MARKER, READY_LABEL, NEEDS_LABEL, actor, normalizeLogin } from "./gh.mjs";
+import { ROUND_MARKER, NUDGE_MARKER, READY_LABEL, NEEDS_LABEL, actor, normalizeLogin } from "./host_contract.mjs";
 import { publicPrViolations, publicCommentViolations, publicCorrection, publicReviewHash } from "./public_output.mjs";
 import { hasLegacyStatusLabels } from "./public-format.mjs";
 import { adapterFor, buildRun, capabilitiesFor } from "./harness.mjs";
@@ -24,7 +33,8 @@ import { executionRunner, reserveExecutionEpoch, unsubmittedInitialDispatch } fr
 import { reconcileExecutionResult, executionResultCheckpoint, requireVerificationSandbox } from "./execution_result.mjs";
 import { readJson } from "./fs.mjs";
 import { join } from "node:path";
-import { runEnv, prdIdFromBranch } from "./git.mjs";
+import { isDeepStrictEqual } from "node:util";
+import { runSessionEnv, prdIdFromBranch } from "./git.mjs";
 import { resolveCredentialFor } from "./credential.mjs";
 import { requireIdentity } from "./identity.mjs";
 import { resolveContextPaths, resolveTimeout } from "./config.mjs";
@@ -38,6 +48,7 @@ import { hash as learningHash } from "./learning_data.mjs";
 import { boundedCall } from "./execution_io.mjs";
 import { networkFailure, validNetworkRetry, NETWORK_RETRY_DELAYS, NETWORK_RECOVERY_WINDOW } from "./network_recovery.mjs";
 import { completionStopsAutomation } from "./task_completion.mjs";
+import { withReviewState } from "./review_state.mjs";
 
 const CONCURRENCY = 4;
 
@@ -85,6 +96,7 @@ export const READY_LABEL_REMOVAL = "ready label removal";
 export const READY_LABEL_WRITE = "ready label write";
 export const ROUND_COMMENT = "round comment";
 export const COMPLETION_GATE = "completion gate";
+export const REVIEW_CAPTURE = "review evidence capture";
 export const PUBLIC_METADATA = "public metadata write";
 export const REGULAR_PR = "regular PR conversion";
 
@@ -97,7 +109,8 @@ const fetchFrom = iso => (iso ? new Date(Date.parse(floorSecond(iso)) - 1000).to
 export function makeTick(deps) {
   // `writePrd` is here for one caller: the re-snapshot of a brief edited outside its contract. It is the only write to
   // the snapshot the tick makes, and it is not the tick overruling the operator, it is the tick following them.
-  const { config, state, gh, git, notify, log, clock = Date, ownLogin, readPrd, writePrd = () => {}, fetch = globalThis.fetch, aportApiKey = null, credential: ctxCredential = null, identity: ctxIdentity = null } = deps;
+  const { config, state, git, notify, log, clock = Date, ownLogin, readPrd, writePrd = () => {}, fetch = globalThis.fetch, aportApiKey = null, credential: ctxCredential = null, identity: ctxIdentity = null } = deps;
+  const host = hostApi(deps);
   const runnerFor = id => executionRunner(deps, id);
   const completed = (id, entry) => {
     if (!completionStopsAutomation(entry)) return false;
@@ -109,29 +122,48 @@ export function makeTick(deps) {
   const startupReconciliation = new Set(deps.startupReconciliation === false ? [] : state.entries().map(([id]) => id));
   // Embedders may restore the canonical cadence after a bounded wake.
   let nextChainAt = deps.nextChainAt ?? 0;
-  const trust = makeTrust(config, ownLogin);
+  const ownLogins = new Map();
+  const loginFor = entry => ownLogins.get(entry.repo) || ownLogin;
+  const reviewConfigFor = entry => policyConfig(config, entry);
+  const trustFor = entry => makeTrust(reviewConfigFor(entry), loginFor(entry));
   const learning = deps.learning || deps.learningFor?.(ownLogin);
   const observationQueue = [];
   let observationOffset = 0, observationSelection = null;
   const now = () => nowIso(clock);
 
-  const save = (id, patch) => state.update(id, { ...patch, updated_at: now() });
+  // Progress polling is not itself a task change. Preserve the UI timestamp
+  // and let state.update skip the write when every proposed field is unchanged.
+  const save = (id, patch) => state.update(id, current =>
+    Object.entries(patch).some(([key, value]) => !isDeepStrictEqual(current[key], value))
+      ? { ...patch, updated_at: now() } : {});
+  const reviewDispositionPatch = (id, entry, key, patch) => {
+    if (!key) return {};
+    const current = entry.firstPartyReview?.key === key;
+    const record = current ? entry.firstPartyReview : state.reviewHistoryRecord ? state.reviewHistoryRecord(id, key) : (entry.reviewHistory || []).findLast(r => r.key === key);
+    if (record?._gallivantReviewArchive) throw new Error("historical review must be integrity-checked before updating its disposition");
+    if (!record) return {};
+    const updated = { ...record, disposition: { ...record.disposition, ...patch } };
+    return { ...(current ? { firstPartyReview: updated } : {}), reviewHistory: [...(entry.reviewHistory || []), updated] };
+  };
+  const externalVerdict = (entry, input) => entry.reviewPolicy?.version === 1
+    ? exactReviewerVerdict(input, host.refSha ? sha => host.refSha(entry.repo, sha) : null)
+    : reviewerVerdict(input);
 
   const recoveryIdentity = (entry, session = entry.session) => ({ prd: entry.prd, harness: entry.harness, session, branch: entry.branch });
 
   // Keep this boundary separate from the event cursor: an uncorrected own reply must not disappear after a dispatch.
   const ownPublicComments = (entry, comments) => comments.filter(c => {
-    const author = actor(c.user ?? c.author);
-    return !author.bot && author.login === normalizeLogin(ownLogin)
+    const author = actor(c.actor ?? c.user ?? c.author);
+    return !author.bot && author.login === normalizeLogin(loginFor(entry))
       && !isFixCommand(c.body)
-      && Date.parse(c.updated_at ?? c.updatedAt ?? c.submitted_at ?? c.created_at ?? c.createdAt) >= Date.parse(entry.public_since);
+      && Date.parse(c.updatedAt ?? c.updated_at ?? c.at ?? c.submitted_at ?? c.createdAt ?? c.created_at) >= Date.parse(entry.public_since);
   });
 
   async function currentPublicComments(entry) {
     const [comments, inline, reviews] = await Promise.all([
-      gh.issueComments(entry.repo, entry.pr, fetchFrom(entry.public_since)),
-      gh.inlineComments(entry.repo, entry.pr, fetchFrom(entry.public_since)),
-      gh.reviews(entry.repo, entry.pr),
+      host.issueComments(entry.repo, entry.pr, fetchFrom(entry.public_since)),
+      host.inlineComments(entry.repo, entry.pr, fetchFrom(entry.public_since)),
+      host.reviews(entry.repo, entry.pr),
     ]);
     return ownPublicComments(entry, [...comments, ...inline, ...reviews.map(r => ({ ...r, public_kind: "review" }))]);
   }
@@ -172,9 +204,9 @@ export function makeTick(deps) {
     // reachable at all is the same question for both writes, and `addLabel` is the one that must land, so that is
     // what the retry tracks. A removal that fails for any other reason is retried with it on the next tick.
     let removed = true;
-    try { await gh.removeLabel(e.repo, e.pr, READY_LABEL); }
+    try { await host.removeLabel(e.repo, e.pr, READY_LABEL); }
     catch (err) { removed = false; log.warn(`${id}: ready label not removed (${err.message})`); }
-    try { await gh.addLabel(e.repo, e.pr, NEEDS_LABEL); }
+    try { await host.addLabel(e.repo, e.pr, NEEDS_LABEL); }
     catch (err) { log.warn(`${id}: needs-human label not written (${err.message}); retrying next tick`); return false; }
     if (!removed) log.warn(`${id}: retrying the ready-label removal next tick`);
     return removed;
@@ -275,6 +307,7 @@ export function makeTick(deps) {
 
   /** The checkout, recreated from the PR branch when it is gone (a lost disk, a cleaned worktrees folder). */
   const ensureWorktree = async (id, entry) => {
+    assertRepositoryAccess(capabilitiesFor(entry.harness), (deps.hosts ?? hosts).select(entry).repository);
     if (!git.exists(entry.worktree)) {
       await git.fromBranch({ nameWithOwner: entry.repo, prdId: prdIdFromBranch(entry.branch) ?? prdIdOf(id), branch: entry.branch, path: entry.worktree });
       restoreSources(id, entry);
@@ -317,7 +350,11 @@ export function makeTick(deps) {
     if (!entry.base || !git.mergeBase) return null;
 
     let r;
-    try { await git.ensureHttpsRemote?.(entry.worktree); r = await git.mergeBase(entry.worktree, entry.base); }
+    try {
+      const hook = git.installHooks?.(entry.worktree, publicationPolicyOf(prdFor(id), { sources: entry.sources || [], base: entry.base }));
+      if (hook && !hook.installed) log.warn(`${id}: the commit-msg hook could not be written into ${entry.worktree} (${hook.why}); local commit checks are unavailable; coordinator publication checks remain mandatory`);
+      await git.ensureHttpsRemote?.(entry.worktree, entry.repo); r = await git.mergeBase(entry.worktree, entry.base);
+    }
     catch (e) {
       // The fetch or a rev-parse failed, so no merge was attempted and the tree is untouched. Same shape as a conflict
       // to the caller, because the outcome for this round is the same: it does not start, and the operator is told which
@@ -337,9 +374,9 @@ export function makeTick(deps) {
    * registry is saved, so a crash in between leaves a comment, not a lost one; the check makes the retry harmless.
    */
   async function commentOnce(entry, body, marker, sinceIso) {
-    const own = await gh.issueComments(entry.repo, entry.pr, sinceIso);
-    if (hasOwnComment(own, ownLogin, marker, sinceIso)) return false;
-    await gh.comment(entry.repo, entry.pr, body);
+    const own = await host.issueComments(entry.repo, entry.pr, sinceIso);
+    if (hasOwnComment(own, loginFor(entry), marker, sinceIso)) return false;
+    await host.comment(entry.repo, entry.pr, body);
     return true;
   }
 
@@ -362,7 +399,12 @@ export function makeTick(deps) {
    */
   async function reopen(id, entry) {
     if (entry.state !== STATES.ready) return;
-    await gh.removeLabel(entry.repo, entry.pr, READY_LABEL);
+    if (entry.reviewPolicy?.version === 1) {
+      save(id, { state: STATES.prOpen, review_readiness: null, review_label_pending: true,
+        ...(entry.completionEvidence?.delivery ? { completionEvidence: { ...entry.completionEvidence, delivery: { ...entry.completionEvidence.delivery, invalidatedAt: now(), invalidationReason: "review readiness reopened" } } } : {}) });
+    }
+    await host.removeLabel(entry.repo, entry.pr, READY_LABEL);
+    if (entry.reviewPolicy?.version === 1) save(id, { review_label_pending: false });
     // `gate_skipped` describes the ready state it was recorded with, so it goes as the ready state goes. Left behind,
     // `status` and `why` would keep warning about a gate that did not run for a head nobody is being asked to merge.
     if (entry.gate_skipped) save(id, { gate_skipped: null });
@@ -417,7 +459,7 @@ export function makeTick(deps) {
 
   function assertProviderHealth(entry) {
     const health = deps.providerHealth?.get(entry.harness, config.harness[entry.harness]?.account || "operator");
-    if (health && !health.ok) throw Object.assign(new Error(`provider health unavailable: ${health.detail}; ${health.fix || "restore this provider account"}`), { code: "PROVIDER_UNAVAILABLE" });
+    if (health && !health.ok) throw Object.assign(new Error(`provider health unavailable: ${health.detail}; ${health.fix || "restore this provider account"}`), { code: "PROVIDER_UNAVAILABLE", retryableProviderPending: health.pending === true });
   }
 
   /**
@@ -433,7 +475,7 @@ export function makeTick(deps) {
    * to push, which is money spent for work nobody can reach. The throw is caught by the caller, which stops the entry
    * with `no-credential` and the fix, so the operator is told rather than left reading a dead run's log.
    */
-  async function startRun(id, entry, { name, prompt, ownership = null, paths = [], dispatchDeadline = null }) {
+  async function startRun(id, entry, { name, prompt, ownership = null, paths = [], dispatchDeadline = null, beforeDispatch = null }) {
     const assertDispatchOpen = () => {
       if (dispatchDeadline != null && clock.now() >= dispatchDeadline) throw Object.assign(new Error("network recovery window expired before dispatch"), { code: "NETWORK_RECOVERY_EXPIRED" });
       const current = state.get(id);
@@ -442,9 +484,20 @@ export function makeTick(deps) {
       if (stopped) throw Object.assign(new Error(`dispatch stopped: ${stopped}`), { code: "EXECUTION_STOPPED" });
     };
     assertDispatchOpen();
+    const selected = (deps.hosts ?? hosts).select(entry);
+    assertRepositoryAccess(capabilitiesFor(entry.harness), selected.repository);
+    repositoryReviewConfig(config, entry.repo, selected.adapter);
+    if (selected.adapter.features?.strictIdentity && entry.pr) {
+      const current = await host.prView(entry.repo, entry.pr);
+      const problem = observedIdentityProblem(entry, current) || (current.state !== "OPEN" ? "PR is no longer open; reconcile its terminal identity before resuming" : null);
+      if (problem) {
+        await needsHuman(id, "pr-identity", { last: { ...entry.last, at: now(), event: problem } });
+        throw Object.assign(new Error(problem), { code: "PR_IDENTITY" });
+      }
+    }
     assertProviderHealth(entry);
     if (capabilitiesFor(entry.harness).transport === "remote") await requireVerificationSandbox();
-    await git.ensureHttpsRemote?.(entry.worktree);
+    await git.ensureHttpsRemote?.(entry.worktree, entry.repo);
     if (entry.brief_changes?.length && name !== "resume") {
       // A prior manual resnapshot may have failed after updating daemon state but before copying into the checkout.
       const brief = readPrd(id);
@@ -473,7 +526,7 @@ export function makeTick(deps) {
     let spec = remote ? null : buildRun({ harness: entry.harness, config: runConfig, mode, session, prompt, cwd: entry.worktree, contextPaths });
     // The host comes from this entry's own checkout, so an enterprise remote asks `gh` for that host's token rather
     // than sending it a github.com one.
-    const credential = await resolveCredentialFor({ config, git, credential: ctxCredential }, { worktree: entry.worktree });
+    const credential = await resolveCredentialFor({ config, git, hosts: deps.hosts, credential: ctxCredential }, { worktree: entry.worktree, repo: entry.repo });
     if (!credential.token) throw Object.assign(new Error(credential.why), { code: "NO_CREDENTIAL" });
     // The identity the session commits as, resolved per run for the reason lib/identity.mjs gives: the daemon is
     // long-lived and an operator may change theirs under it. This is the path `resume` and every fix round take.
@@ -485,8 +538,8 @@ export function makeTick(deps) {
     // every checkout made before the hook existed. Found on a live resume: the session dropped the attribution trailer
     // because the prompt told it to, and `.git/hooks/commit-msg` had never been written, so the half meant to enforce
     // it was absent. Idempotent and never fatal, so this costs a stat and cannot fail a run.
-    const hook = git.installHooks?.(entry.worktree);
-    if (hook && !hook.installed) log.warn(`${id}: the commit-msg hook could not be written into ${entry.worktree} (${hook.why}); the prompt still forbids attribution but nothing enforces it this run`);
+    const hook = git.installHooks?.(entry.worktree, publicationPolicyOf(prdFor(id), { sources: entry.sources || [], base: entry.base }));
+    if (hook && !hook.installed) log.warn(`${id}: the commit-msg hook could not be written into ${entry.worktree} (${hook.why}); local commit checks are unavailable; coordinator publication checks remain mandatory`);
     const initialDispatch = remote && !session ? unsubmittedInitialDispatch(entry, execution) : null;
     const dispatchInput = { operationId: initialDispatch?.operationId ?? `${entry.last?.run || "initial"}:${entry.iteration}:${name}${entry.learning_continuity?.status === "prepared" ? ":fresh" : ""}`, sessionId: entry.session, inputHead: git.head ? await git.head(entry.worktree) : null, workflow: ownership || { state: entry.pr ? STATES.prOpen : STATES.running, reason: null, lastEvent: `recovered ${name} dispatch` } };
     if (entry.learning_continuity?.status === "prepared") dispatchInput.workflow = { ...dispatchInput.workflow,
@@ -507,6 +560,7 @@ export function makeTick(deps) {
       if (initialDispatch) save(id, { initial_dispatch: { ...initialDispatch, status: "dispatching" }, reason: "dispatch-intent" });
       try { job = await learningDispatch({ ...deps, learning }, id, managed, () => {
         assertDispatchOpen();
+        beforeDispatch?.();
         return session && ["native-session", "successor-task"].includes(execution.capabilities.continuation) ? execution.continue(input) : execution.submit({ ...input, sessionId: null });
       }); }
       catch (error) {
@@ -515,16 +569,17 @@ export function makeTick(deps) {
       }
     } else job = await learningDispatch({ ...deps, learning }, id, managed, () => {
       assertDispatchOpen();
-      return execution.start(name, spec.cmd, spec.args, { cwd: entry.worktree, runtimeSettings: spec.runtimeSettings, env: { ...runEnv(config, credential, identity, entry.worktree), ...spec.env }, execution: { ...dispatchInput, ...(entry.learning_continuity?.status === "prepared" ? { recordedSessionId: session } : {}), ...(managed.learning ? { learning: managed.learning, managedInputDigest: managed.managedInputDigest } : {}) } });
+      beforeDispatch?.();
+      return execution.start(name, spec.cmd, spec.args, { cwd: entry.worktree, runtimeSettings: spec.runtimeSettings, env: runSessionEnv(spec.env, config, credential, identity, entry.worktree), execution: { ...dispatchInput, ...(entry.learning_continuity?.status === "prepared" ? { recordedSessionId: session } : {}), ...(managed.learning ? { learning: managed.learning, managedInputDigest: managed.managedInputDigest } : {}) } });
     });
     return { job, session: job.execution?.sessionId || session, managed };
   }
 
   /** When a head was pushed, from GitHub, or `fallback` when GitHub cannot say. */
-  const headPushedAt = (entry, sha, fallback) => gh.commitDate(entry.repo, sha).then(d => d || fallback).catch(() => fallback);
+  const headPushedAt = (entry, sha, fallback) => host.commitDate(entry.repo, sha).then(d => d || fallback).catch(() => fallback);
 
   /** The reviewer clock for this entry and this head. The rule itself is `events.mjs`; `reconcile` uses the same one. */
-  const askedAt = (entry, pushedAt) => reviewerClock({ config, pushedAt, previousAsk: entry.rereview?.at ?? null, floorAt: now() });
+  const askedAt = (entry, pushedAt) => reviewerClock({ config: policyConfig(config, entry), pushedAt, previousAsk: entry.rereview?.at ?? null, floorAt: now() });
 
   /**
    * The round comment: the announcement of a round that has already been counted. Called on the settle tick that
@@ -551,7 +606,7 @@ export function makeTick(deps) {
   async function postRoundComment(id, entry) {
     const owed = entry.round_comment;
     if (!owed) return false;
-    const body = owed.kind === "round" ? roundComment(config) : owed.kind === "public-text" ? `Review text updated.\n\n${ROUND_MARKER}` : receiptRoundComment();
+    const body = owed.kind === "round" ? roundComment(reviewConfigFor(entry)) : owed.kind === "public-text" ? `Review text updated.\n\n${ROUND_MARKER}` : receiptRoundComment();
     try { await commentOnce(entry, body, ROUND_MARKER, owed.since); }
     catch (err) {
       // The session is not re-saved here: the count above already persisted it, so there is nothing a retry could
@@ -599,7 +654,7 @@ export function makeTick(deps) {
    * (`last.run`) is settled; a leftover run from before a reset or a recovery is ignored. Returns true when the
    * entry should wait.
    */
-  async function settleRun(id, entry) {
+  async function settleRun(id, entry, refreshIdentity) {
     const runner = runnerFor(id);
     const cur = runner.current();
     if (!cur) return false;
@@ -610,8 +665,14 @@ export function makeTick(deps) {
     // leftover process outliving a reset is a separate problem from this entry's state, and it does not get to borrow
     // this entry's reason.
     if (entry.last?.run !== cur.id) return false;
-    if (cur.execution?.quarantined) {
-      save(id, { last: { ...entry.last, exit: cur.exit ?? 1, event: "late provider result quarantined after stop" } });
+    const stoppedByMessage = !entry.dispatch_stopped && entry.control?.action === "message" &&
+      entry.control.interrupt === true && entry.control.stop_run === cur.id;
+    const interrupted = stoppedByMessage && entry.control.status === "queued";
+    if (cur.execution?.quarantined && !interrupted) {
+      if (cur.running) return true;
+      save(id, { last: { ...entry.last, exit: cur.exit ?? 1, event: "late provider result quarantined after stop" },
+        ...(stoppedByMessage ? { state: STATES.needsHuman, reason: "operator-interrupted", network_retry: null } : {}),
+      });
       return false;
     }
     if (cur.running) {
@@ -662,13 +723,17 @@ export function makeTick(deps) {
     if (entry.last?.exit != null) return false;
 
     const lines = runner.outcome && runner.sessionFrom ? [] : runner.lines(cur.id);
-    const outcome = runner.outcome ? runner.outcome(cur.id) : adapterFor(entry.harness).outcome(lines);
+    // Intentional local stops quarantine late results too. Settle the owned
+    // interruption through the normal PR-discovery path without collecting or
+    // trusting that result, so a pre-PR task becomes resumable as well.
+    const outcome = cur.execution?.quarantined
+      ? { ok: false, finished: true, cost: cur.execution.costUsd ?? null, denials: [] }
+      : runner.outcome ? runner.outcome(cur.id) : adapterFor(entry.harness).outcome(lines);
     const job = runner.settle(cur.id, () => (outcome.ok ? 0 : 1));
     const session = entry.session || (runner.sessionFrom ? runner.sessionFrom(cur.id) : adapterFor(entry.harness).sessionFrom(lines));
-    if (runner.collect && outcome.finished && !cur.execution?.collected) await runner.collect();
+    if (runner.collect && outcome.finished && !cur.execution?.collected && !cur.execution?.quarantined) await runner.collect();
     const last = { at: now(), run: cur.id, exit: job.exit, event: entry.last?.event || "start", cost: outcome.cost, denials: outcome.denials };
 
-    const interrupted = entry.control?.status === "queued" && entry.control.stop_run === cur.id;
     if (interrupted && entry.state !== STATES.running) {
       // An intentional interruption is not a failed review round or a completion.
       // Account for it once, then let the normal control path resume the saved session.
@@ -716,8 +781,11 @@ export function makeTick(deps) {
     // streak. Never let old deadlines silently restart a later stopped task.
     if (entry.network_retry && !recoverableNetwork) entry = save(id, { network_retry: null });
 
+    // Process exit and stop accounting above are local. Host-dependent settlement
+    // below needs a verified actor, but an identity outage must not delay a stop.
+    await refreshIdentity();
     if (entry.state === STATES.running) {
-      const prs = await gh.prListByHead(entry.repo, entry.branch);
+      const prs = await host.prListByHead(entry.repo, entry.branch);
       let pr = (prs || []).find(p => !p.isCrossRepository);
       if (!pr) {
         if (await scheduleNetworkRecovery()) return false;
@@ -737,7 +805,17 @@ export function makeTick(deps) {
         const left = tree && (tree.modified || tree.untracked)
           ? `; ${[tree.modified && `${tree.modified} modified`, tree.untracked && `${tree.untracked} untracked`].filter(Boolean).join(" and ")} file${tree.modified + tree.untracked === 1 ? "" : "s"} are uncommitted in ${entry.worktree}`
           : "";
-        await needsHuman(id, "no-pr", { session, last: { ...last, event: `${last.event}${left}` }, ...(tree ? { tree } : {}) });
+        const failed = !outcome.finished || !outcome.ok || job.exit !== 0;
+        await needsHuman(id, failed ? "harness-error" : "no-pr", {
+          session, last: { ...last, event: `${last.event}${left}`,
+            ...(failed ? { error: outcome.finished ? "Worker failed before opening a PR; inspect the owned run log for the provider or tool failure" : "Worker ended without a terminal task result; inspect the owned run log" } : {}) },
+          ...(tree ? { tree } : {}),
+        });
+        return false;
+      }
+      const identityProblem = observedIdentityProblem(entry, pr);
+      if (identityProblem) {
+        await needsHuman(id, "pr-identity", { session, last: { ...last, event: identityProblem } });
         return false;
       }
       // The identity block is a precondition of leaving `running`, not a best-effort extra. It is what reconciliation
@@ -762,7 +840,7 @@ export function makeTick(deps) {
       try {
         const identity = recoveryIdentity(entry, session);
         if (normalizePublicBody(pr.body, { identity, taskId: id }) !== pr.body) {
-          pr = await gh.setRecoveryMetadata(entry.repo, pr.number, identity, { taskId: id });
+          pr = await host.setRecoveryMetadata(entry.repo, pr.number, identity, { taskId: id });
         }
       }
         catch (err) {
@@ -787,7 +865,9 @@ export function makeTick(deps) {
     }
 
     // A fix run ended. Progress is the head moving or the receipt changing; anything else is a stop.
-    const pr = await gh.prView(entry.repo, entry.pr);
+    const pr = await host.prView(entry.repo, entry.pr);
+    const identityProblem = observedIdentityProblem(entry, pr);
+    if (identityProblem) { await needsHuman(id, "pr-identity", { session, last: { ...last, event: identityProblem } }); return false; }
     const pushed = pr.headRefOid !== entry.cursor.fixed_sha;
     const hash = receiptHash(pr.body);
     const rewrote = !pushed && hash !== null && !receiptHashes(pr.body).includes(entry.cursor.receipt_hash);
@@ -885,7 +965,7 @@ export function makeTick(deps) {
    * again next tick and dispatched then; the ones already handled are recognised by key and skipped.
    */
   async function dispatch(id, entry, pr, spec, deferredDispatches = null) {
-    const { name, events, denials = null, summary, since, publicFix = null } = spec;
+    const { name, events, denials = null, summary, since, publicFix = null, reviewKey = null } = spec;
     if (entry.dispatch_stopped) return;
     const health = deps.providerHealth?.get(entry.harness, config.harness[entry.harness]?.account || "operator");
     if (health && !health.ok) {
@@ -942,8 +1022,8 @@ export function makeTick(deps) {
       ? `The operator switched this PR from ${previousHarness || "a previous harness"} to ${entry.harness}. This is a new provider session; the previous conversation is unavailable. Before editing, read the approved brief${entry.prd ? ` at ${entry.prd}` : " if one is recorded"}, its carried files, the PR and review threads, and the local checkout's status and unpushed commits. Preserve existing work and review unresolved feedback. The brief's original harness field records its starting route; this explicit PR reset selected ${entry.harness} for subsequent work.`
       : null;
     const prompt = entry.session
-      ? fixPrompt({ ...fix, verify: verifyFor(id) })
-      : `${registerPrompt({ repo: entry.repo, pr: entry.pr })}${handoff ? `\n\n${handoff}` : ""}\n\n${fixPrompt({ ...fix, verify: [] })}`;
+      ? fixPrompt({ host: (deps.hosts ?? hosts).select(entry).adapter.prompts, ...fix, verify: verifyFor(id) })
+      : `${registerPrompt({ host: (deps.hosts ?? hosts).select(entry).adapter.prompts, repo: entry.repo, pr: entry.pr })}${handoff ? `\n\n${handoff}` : ""}\n\n${fixPrompt({ host: (deps.hosts ?? hosts).select(entry).adapter.prompts, ...fix, verify: [] })}`;
     // The invariant: a spawned run must be recorded before anything else can fail. Everything that can throw goes
     // above the spawn, and the state that owns the run is saved immediately below it with no await in between. A
     // process running that the registry does not know about is the worst state this function can leave: `settleRun`
@@ -973,9 +1053,16 @@ export function makeTick(deps) {
     let started;
     const ownership = { state: STATES.prOpen, reason: null, public_fix: publicFix, lastEvent: summary,
       cursor: { ...advanceCursor(entry.cursor, since, events.filter(e => e.id != null && sameInstant(e.at, since)).map(eventKey)), fixed_sha: pr.headRefOid, receipt_hash: receiptHash(pr.body), ...(events.some(e => e.kind === "check") ? { checks_sha: pr.headRefOid } : {}) } };
-    try { started = await startRun(id, entry, { name, prompt, ownership, paths: events.map(e => e.path).filter(Boolean) }); }
+    try { started = await startRun(id, entry, { name, prompt, ownership, paths: events.map(e => e.path).filter(Boolean),
+      beforeDispatch: reviewKey ? () => {
+        const current = state.get(id);
+        if (current.firstPartyReview?.key !== reviewKey) throw new Error("review findings changed before dispatch; re-evaluate the current input");
+        save(id, reviewDispositionPatch(id, current, reviewKey, { status: "dispatch-intent", at: now(), round: entry.iteration + 1 }));
+      } : null }); }
     catch (e) {
+      if (e.code === "PR_IDENTITY") return;
       if (e.dispatchNotSent === true) {
+        if (reviewKey) save(id, reviewDispositionPatch(id, state.get(id), reviewKey, { status: "pending", round: null }));
         await needsHuman(id, "dispatch-refused", { last: { ...entry.last, at: now(), event: "managed dispatch refused before any provider request; repair prerequisites and explicitly resume" } });
         return;
       }
@@ -983,7 +1070,10 @@ export function makeTick(deps) {
       // holding it: `settleRun` now ignores such a run rather than waiting on it, which is right, but it means the
       // dispatch can arrive while the runner is still busy. That is a wait, not an error, and it resolves when the
       // leftover ends. The cursor is not moved, so the same feedback is dispatched on the tick that finds it free.
-      if (e.code === "BUSY") { log.info(`${id}: ${e.message}; dispatching ${summary} once it is free`); return; }
+      if (e.code === "BUSY") {
+        if (reviewKey) save(id, reviewDispositionPatch(id, state.get(id), reviewKey, { status: "pending", round: null }));
+        log.info(`${id}: ${e.message}; dispatching ${summary} once it is free`); return;
+      }
       if (e.code === "PROVIDER_UNAVAILABLE") { log.info(`${id}: dispatch waiting for its provider/account health`); return; }
       // No credential is an operator problem, not a transient one: retrying every tick would spend nothing but would
       // also never resolve, and the entry would sit `pr-open` with feedback nobody is acting on. Stop it and say so.
@@ -1005,6 +1095,7 @@ export function makeTick(deps) {
     const dispatchedChecks = events.some(e => e.kind === "check");
     state.update(id, current => ({
       ...learningDeliveryPatch(current, managed, job), updated_at: now(),
+      ...reviewDispositionPatch(id, current, reviewKey, { status: "dispatched", at: now(), run: job.id }),
       state: STATES.prOpen, session, brief_changes: null, public_fix: publicFix,
       // The cursor and the keys handled at it move together: everything dispatched in the boundary second is
       // remembered, so an event sharing that second is still read next tick but never sent a second time.
@@ -1017,6 +1108,11 @@ export function makeTick(deps) {
 
   /** A fix round, or a stop when the round budget is spent. */
   async function fixOrStop(id, entry, pr, spec, deferredDispatches = null) {
+    if (entry.reviewPolicy?.version === 1 && entry.state === STATES.ready) {
+      try { await reopen(id, entry); entry = state.get(id); }
+      catch (error) { await retryFailed(id, state.get(id), READY_LABEL_REMOVAL, error, { action: "readiness invalidated; retrying label removal" }); return; }
+    }
+    if (needsFirstParty(entry.reviewPolicy) && deps.reviewService?.cancel) await deps.reviewService.cancel(id, "author feedback dispatched; prior review input invalidated");
     if (entry.iteration >= config.max_iterations) { await needsHuman(id, "iterations", { last: { at: now(), event: spec.summary } }); return; }
     await dispatch(id, entry, pr, spec, deferredDispatches);
   }
@@ -1026,7 +1122,9 @@ export function makeTick(deps) {
    * before any workflow is queued. A young head with nothing reported is not green, it is not reported yet.
    */
   async function checksSettled(entry, pr) {
-    if ((pr.statusCheckRollup || []).length) return isGreen(pr.statusCheckRollup);
+    const required = reviewConfigFor(entry).required_checks;
+    if (required.length || (pr.statusCheckRollup || []).length) return isGreen(pr.statusCheckRollup, required);
+    if (entry.reviewPolicy?.version === 1) return entry.reviewPolicy.zeroChecks === true;
     const pushedAt = await headPushedAt(entry, pr.headRefOid, entry.cursor.since);
     return clock.now() - Date.parse(pushedAt) > minutes(config.checks_grace_minutes);
   }
@@ -1036,7 +1134,7 @@ export function makeTick(deps) {
   // changed head/receipt/review cannot convert an unqualified delivery to done.
   async function terminalCompletion(entry, pr) {
     if (!entry.task?.completion) return {};
-    const terminal = { adapter: "github-pull-request", state: pr.state, repository: entry.repo, pr: entry.pr,
+    const terminal = { adapter: completionAdapter(entry.repo, deps.hosts ?? hosts), state: pr.state, repository: entry.repo, pr: entry.pr,
       head: pr.headRefOid, base: pr.baseRefName || null, observedAt: now(), mergedAt: pr.mergedAt || null, mergeCommit: pr.mergeCommit?.oid || null };
     const evidence = { ...entry.completionEvidence, terminal };
     if (pr.state === "MERGED") {
@@ -1046,15 +1144,14 @@ export function makeTick(deps) {
       if (entry.state === STATES.ready && !entry.dispatch_stopped && delivery?.gate?.allow === true && !delivery.invalidatedAt &&
           delivery.head === pr.headRefOid && delivery.base === pr.baseRefName && delivery.receiptHash === receiptHash(pr.body) &&
           Number.isFinite(readyAt) && Number.isFinite(mergedAt) && mergedAt >= readyAt && terminal.mergeCommit) {
-        const [reviews, inline, comments] = await Promise.all([
-          gh.reviews(entry.repo, entry.pr),
-          gh.inlineComments(entry.repo, entry.pr, fetchFrom(earlier(entry.rereview.at, entry.public_since))),
-          gh.issueComments(entry.repo, entry.pr, fetchFrom(earlier(entry.rereview.at, entry.public_since))),
-        ]);
-        const verdict = reviewerVerdict({ reviews, inline, comments, config, trust, sinceIso: entry.rereview.at, headSha: pr.headRefOid, dispatched: entry.cursor.dispatched });
-        const pending = deriveEvents({ pr, reviews, inline, comments, entry, trust }).events;
+        const [reviews, inline, comments] = await readFeedback(host, entry.repo, pr, fetchFrom(earlier(entry.rereview.at, entry.public_since)), fetchFrom(earlier(entry.rereview.at, entry.public_since)));
+        const external = await externalVerdict(entry, { reviews, inline, comments, config: reviewConfigFor(entry), trust: trustFor(entry), sinceIso: entry.rereview.at, headSha: pr.headRefOid, dispatched: entry.cursor.dispatched });
+        const verdict = reviewVerdict(entry.reviewPolicy, external, entry.firstPartyReview, reviewBinding(pr, entry.reviewPolicy));
+        const pending = deriveEvents({ pr, reviews, inline, comments, entry, trust: trustFor(entry) }).events;
         const publicIssues = [...publicPrViolations(pr), ...publicCommentViolations(ownPublicComments(entry, [...comments, ...inline, ...reviews.map(r => ({ ...r, public_kind: "review" }))]))];
-        qualified = await checksSettled(entry, pr) && ["clear", "none"].includes(verdict.verdict) && !pending.length && !publicIssues.length;
+        qualified = await checksSettled(entry, pr) && ["clear", "none"].includes(verdict.verdict) && !pending.length && !publicIssues.length &&
+          !requiredFeedback({ reviews, inline, trust: trustFor(entry), headSha: pr.headRefOid }).length &&
+          (!entry.reviewPolicy || entry.reviewPolicy.version === 0 || entry.reviewBinding === reviewBinding(pr, entry.reviewPolicy));
         reason = qualified ? null : "Integration was observed after checks, reviewer feedback or public delivery evidence changed.";
       }
       evidence.integration = { ...terminal, qualified, reason };
@@ -1133,8 +1230,13 @@ export function makeTick(deps) {
     const health = deps.providerHealth?.get(entry.harness, config.harness[entry.harness]?.account || "operator");
     if (health && !health.ok) return true; // The one-hour deadline still bounds an unavailable probe.
     if (entry.pr) {
-      const pr = await gh.prView(entry.repo, entry.pr);
-      if (pr.state !== "OPEN") { save(id, { state: STATES.done, network_retry: null }); return true; }
+      const pr = await host.prView(entry.repo, entry.pr);
+      if (pr.state !== "OPEN") {
+        const problem = await terminalIdentityProblem(host, entry, pr);
+        if (problem) await needsHuman(id, "pr-identity", { network_retry: null, last: { at: now(), event: problem } });
+        else save(id, { state: STATES.done, activity_at: now(), network_retry: null, ...await terminalCompletion(entry, pr) });
+        return true;
+      }
     }
     // Fence before any await that might submit input. A crash in this interval
     // requires inspection; guessing whether a paid run started is unsafe.
@@ -1163,10 +1265,29 @@ export function makeTick(deps) {
     return true;
   }
 
-  async function tickEntry(id, entry, { skipReconciliation = false, deferredDispatches = null, settleOnly = false } = {}) {
+  async function tickEntry(id, entry, options = {}) {
+    return withReviewState(deps, id, () => tickEntryOwned(id, state.get(id) || entry, options));
+  }
+
+  async function tickEntryOwned(id, entry, { skipReconciliation = false, deferredDispatches = null, settleOnly = false } = {}) {
+    // Retain the head belonging to the saved binding even if settleRun moves
+    // the author cursor before this tick reaches review invalidation.
+    const reviewedHead = entry.reviewHead ?? entry.cursor?.fixed_sha;
+    await deps.reviewService?.expire?.(id);
+    if (entry.review_label_pending && entry.pr) {
+      try { await host.removeLabel(entry.repo, entry.pr, READY_LABEL); entry = save(id, { review_label_pending: false }); }
+      catch (error) { await retryFailed(id, entry, READY_LABEL_REMOVAL, error, { action: "readiness invalidated; retrying label removal" }); return; }
+    }
+    (deps.hosts ?? hosts).select(entry);
+    let identityRefreshed = false;
+    const refreshIdentity = async () => {
+      if (identityRefreshed) return;
+      if (host.userFor) ownLogins.set(entry.repo, await host.userFor(entry.repo));
+      identityRefreshed = true;
+    };
     if (completed(id, entry)) { await learningDelivered({ ...deps, learning }, id); return; }
     if (!skipReconciliation) await learningDelivered({ ...deps, learning }, id);
-    if (await cancelControl(deps, id)) return;
+    if (await cancelControl(deps, id)) { await deps.reviewService?.cancel?.(id, "task cancelled"); return; }
     if (!settleOnly && await recoverControl(deps, id)) return;
     const execution = runnerFor(id);
     if (execution.ledgerEpoch > 0) reserveExecutionEpoch({ root: execution.root, taskId: id,
@@ -1195,13 +1316,16 @@ export function makeTick(deps) {
       }
     }
     if (entry.state === STATES.done) { if (!settleOnly) await applyControl(deps, id); return; }
+    // Do not migrate a record whose provider result is still contradictory or
+    // unowned. That recovery boundary must remain a strictly read-only failure.
+    if (!entry.reviewPolicy) entry = save(id, { reviewPolicy: legacyReviewPolicy(reviewConfigFor(entry)) });
     if (!entry.public_since) entry = save(id, { public_since: floorSecond(now()) });
     if (interruptControl(deps, id)) {
       await needsHuman(id, "run-stop-unverified");
       return;
     }
     entry = state.get(id);
-    if (await settleRun(id, entry)) return;
+    if (await settleRun(id, entry, refreshIdentity)) return;
     if (completed(id, state.get(id))) return;
     // Phase-bounded live campaigns reuse settlement/publication, but must not
     // authorize another paid review or queued resume in the same observation.
@@ -1211,10 +1335,17 @@ export function makeTick(deps) {
     if (entry && await recoverNetwork(id, entry)) return;
     if (!entry || entry.state === STATES.running || entry.state === STATES.done || !entry.pr) return;
     if (deps.executionFor && entry.review_next_at && clock.now() < entry.review_next_at && !controlPending(entry.control)) return;
+    await refreshIdentity();
     if (deps.executionFor) entry = save(id, { review_next_at: clock.now() + config.poll_seconds * 1000 });
 
-    let pr = await gh.prView(entry.repo, entry.pr);
-    if (pr.state === "MERGED" || pr.state === "CLOSED") { save(id, { state: STATES.done, ...await terminalCompletion(entry, pr) }); log.info(`${id}: ${pr.state.toLowerCase()}`); return; }
+    let pr = await host.prView(entry.repo, entry.pr);
+    const identityProblem = observedIdentityProblem(entry, pr);
+    if (identityProblem) { await needsHuman(id, "pr-identity", { last: { at: now(), event: identityProblem } }); return; }
+    if (pr.state === "MERGED" || pr.state === "CLOSED") {
+      const problem = await terminalIdentityProblem(host, entry, pr);
+      if (problem) { await needsHuman(id, "pr-identity", { last: { at: now(), event: problem } }); return; }
+      save(id, { state: STATES.done, activity_at: now(), ...await terminalCompletion(entry, pr) }); log.info(`${id}: ${pr.state.toLowerCase()}`); return;
+    }
     // Regular means reviewable, not complete. Registration adopts the same policy as start. Recover only legacy
     // draft-specific stops; no other needs-human reason is cleared by changing this GitHub presentation state.
     if (entry.state === STATES.needsHuman && entry.reason === "draft") {
@@ -1235,7 +1366,7 @@ export function makeTick(deps) {
       if (entry.prd && normalizePublicBody(pr.body, { identity, taskId: id }) !== pr.body) {
         const beforeReceipt = receiptHash(pr.body);
         const sameReceipt = receiptHashes(pr.body).includes(entry.cursor.receipt_hash);
-        pr = await gh.setRecoveryMetadata(entry.repo, entry.pr, identity, { taskId: id });
+        pr = await host.setRecoveryMetadata(entry.repo, entry.pr, identity, { taskId: id });
         if (sameReceipt && receiptHash(pr.body) === beforeReceipt) entry = save(id, { cursor: { ...entry.cursor, receipt_hash: beforeReceipt } });
       }
       if (entry.retry?.op === PUBLIC_METADATA) entry = retryOk(id, entry);
@@ -1244,7 +1375,7 @@ export function makeTick(deps) {
       return;
     }
     if (pr.isDraft) {
-      try { await gh.markReady(entry.repo, entry.pr); }
+      try { await host.markReady(entry.repo, entry.pr); }
       catch (err) {
         await retryFailed(id, entry, REGULAR_PR, err, { action: "retrying regular PR conversion next tick" });
         return;
@@ -1300,11 +1431,7 @@ export function makeTick(deps) {
     // `updated_at` and stamps to the second, so a fetch starting exactly at the cursor can leave out the items
     // `cursor.dispatched` exists to re-examine. Overlap here, deduplicate in `deriveEvents`: reading an item a
     // second time costs nothing, never reading it again is the bug.
-    const [reviews, inline, comments] = await Promise.all([
-      gh.reviews(entry.repo, entry.pr),
-      gh.inlineComments(entry.repo, entry.pr, fetchFrom(inlineSince)),
-      gh.issueComments(entry.repo, entry.pr, fetchFrom(earlier(entry.cursor.since, entry.public_since))),
-    ]);
+    const [reviews, inline, comments] = await readFeedback(host, entry.repo, pr, fetchFrom(inlineSince), fetchFrom(earlier(entry.cursor.since, entry.public_since)));
     if (learning && (!observationSelection || observationSelection.has(id)) && observationQueue.length < 100) {
       try {
         const repo = learning.identityFor(entry.repo);
@@ -1317,7 +1444,7 @@ export function makeTick(deps) {
       await fixOrStop(id, entry, pr, { name: "public-text", events: [], denials: publicCorrection(publicViolations), summary: `public text correction: ${publicViolations.join("; ")}`, since: entry.cursor.since, publicFix: publicReviewHash(pr, ownComments) }, deferredDispatches);
       return;
     }
-    const { events, newest } = deriveEvents({ pr, reviews, inline, comments, entry, trust });
+    const { events, newest } = deriveEvents({ pr, reviews, inline, comments, entry, trust: trustFor(entry) });
 
     if (events.length) {
       const summary = events.map(e => e.kind === "check" ? `check ${e.name}` : `${e.kind} ${e.id ?? ""} by ${e.author}`).join(", ");
@@ -1332,9 +1459,105 @@ export function makeTick(deps) {
     const changed = await headChanged(id, entry, pr);
     if (changed === "declined") return;
     if (changed) entry = changed;
-    const judge = entry.state === STATES.prOpen || Boolean(entry.task?.completion && entry.completionEvidence?.delivery);
-    const verdict = judge ? reviewerVerdict({ reviews, inline, comments, config, trust, sinceIso: entry.rereview.at, headSha: pr.headRefOid, dispatched: entry.cursor.dispatched }) : null;
+    const judge = entry.state === STATES.prOpen || entry.state === STATES.ready || Boolean(entry.task?.completion && entry.completionEvidence?.delivery);
+    const binding = reviewBinding(pr, entry.reviewPolicy);
+    if (entry.reviewPolicy.version === 1 && entry.reviewBinding && entry.reviewBinding !== binding) {
+      const headMoved = reviewedHead && reviewedHead !== pr.headRefOid;
+      entry = save(id, { reviewBinding: binding, reviewHead: pr.headRefOid, firstPartyReview: null, review_readiness: null,
+        ...(entry.completionEvidence?.delivery ? { completionEvidence: { ...entry.completionEvidence, delivery: { ...entry.completionEvidence.delivery, invalidatedAt: now(), invalidationReason: "review input changed" } } } : {}),
+        reviewHistory: [...(entry.reviewHistory || []), ...(entry.firstPartyReview ? [entry.firstPartyReview] : [])],
+        rereview: headMoved ? entry.rereview : { at: now(), nudged: false } });
+      if (entry.state === STATES.ready) {
+        await reopen(id, entry);
+        entry = save(id, { state: STATES.prOpen, gate_skipped: null });
+      }
+      // A new head already has a push-based window from headChanged or round
+      // settlement. Same-head evidence edits need a new answer after this observation.
+      if (!headMoved && needsExternal(entry.reviewPolicy)) {
+        await commentOnce(entry, roundComment(reviewConfigFor(entry)), ROUND_MARKER, entry.rereview.at);
+      }
+      if (!headMoved) return;
+    }
+    if (!entry.reviewBinding || entry.reviewPolicy.version === 1 && !entry.reviewHead) entry = save(id, {
+      reviewBinding: binding, ...(entry.reviewPolicy.version === 1 ? { reviewHead: pr.headRefOid } : {}),
+    });
+    const external = judge ? await externalVerdict(entry, { reviews, inline, comments, config: reviewConfigFor(entry), trust: trustFor(entry), sinceIso: entry.rereview.at, headSha: pr.headRefOid, dispatched: entry.cursor.dispatched }) : null;
+    const blockers = requiredFeedback({ reviews, inline, trust: trustFor(entry), headSha: pr.headRefOid });
+    if (blockers.length) {
+      await needsHuman(id, "reviewer-blocking", { last: { at: now(), event: `Resolve required/unbound feedback on ${pr.url}: ${blockers.map(b => b.url || b.eventId).join(", ")}` } });
+      return;
+    }
     const green = judge && await checksSettled(entry, pr);
+    if (judge && entry.reviewPolicy.version === 1 && !(pr.statusCheckRollup || []).length && !entry.reviewPolicy.zeroChecks) {
+      await needsHuman(id, "missing-ci", { last: { at: now(), event: "No checks reported; explicit review.zero_checks policy is required for a repository with zero required checks" } }); return;
+    }
+    let publicationDiff = null;
+    const checkPublication = async ({ force = false } = {}) => {
+      let violations, policy, publicationBinding;
+      try {
+        policy = publicationPolicyOf(prdFor(id), { sources: entry.sources || [], base: entry.base });
+        publicationBinding = createHash("sha256").update(JSON.stringify([PUBLICATION_POLICY_VERSION, entry.repo, entry.pr, pr.headRefOid, pr.baseRefOid, pr.baseRefName, policy])).digest("hex");
+        if (!force && entry.publication_check?.binding === publicationBinding) return true;
+        publicationDiff = await host.prDiff(entry.repo, entry.pr);
+        violations = workArtifactViolations(gitDiffChangedPaths(publicationDiff), policy);
+        // prDiff is a live PR endpoint. Do not cache a diff fetched while either
+        // branch moved against the review identity observed at the start of the tick.
+        const current = await host.prView(entry.repo, entry.pr);
+        if (!current || current.state !== "OPEN" || current.headRefOid !== pr.headRefOid || current.baseRefOid !== pr.baseRefOid || current.baseRefName !== pr.baseRefName) throw new Error("PR head/base changed while reading publication paths");
+      } catch (error) {
+        await retryFailed(id, entry, COMPLETION_GATE, new Error(`publication diff unreadable: ${error.message}`), { action: "retrying the publication check next tick" });
+        return false;
+      }
+      if (violations.length) {
+        await fixOrStop(id, entry, pr, { name: "publication-cleanup", events: [], denials: workArtifactError(violations), summary: `remove ${violations.length} task work artifact(s) from the PR`, since: readAt }, deferredDispatches);
+        return false;
+      }
+      entry = save(id, { publication_check: { binding: publicationBinding, checkedAt: now() } });
+      return true;
+    };
+    // Reject scratch before expensive evidence capture/review. Persist only a
+    // clean head/base/policy binding, never diff bytes; review polls reuse it.
+    if (judge && green && !pr.isDraft && !await checkPublication()) return;
+    if (judge && green && !pr.isDraft && needsFirstParty(entry.reviewPolicy) && external.verdict !== "blocking") {
+      try {
+        const divergence = divergenceFor(id, entry), reason = divergenceReason(divergence);
+        if (reason) { await needsHuman(id, reason, { prd_divergence: { at: now(), why: divergence.why, diff: divergence.diff } }); return; }
+        if (divergence.verdict === "same" && divergence.repoText !== readPrd(id)) {
+          retakePrdSnapshot({ log, writePrd, state }, { id, divergence });
+          prds.set(id, divergence.repo); entry = state.get(id);
+        }
+        if (!deps.reviewService) throw new Error("qualified first-party reviewer service is unavailable; restore the selected route");
+        const record = await deps.reviewService.reconcile(id, entry, pr);
+        entry = save(id, { firstPartyReview: record });
+        if (entry.retry?.op === REVIEW_CAPTURE) entry = retryOk(id, entry);
+        if (record.status === "failed" || record.status === "incomplete") { await needsHuman(id, record.status === "incomplete" ? "review-incomplete" : "first-party-review-failed", { last: { at: now(), event: record.error } }); return; }
+        if (record.status === "completed" && record.result.verdict === "findings") {
+          const previous = (entry.reviewHistory || []).findLast(r => r.key === record.key);
+          const previouslyDispatched = ["dispatched", "dispatch-intent"].includes(previous?.disposition?.status);
+          if (previouslyDispatched || ["dispatched", "dispatch-intent"].includes(record.disposition?.status) || needsExternal(entry.reviewPolicy) && external.verdict === "clear") {
+            await needsHuman(id, previouslyDispatched || record.disposition ? "repeated-review-findings" : "review-disagreement"); return;
+          }
+          const exhausted = entry.iteration >= config.max_iterations;
+          const disposition = { status: exhausted ? "rounds-exhausted" : "pending", at: now(), round: null, findingsDigest: reviewDigest(record.result.findings) };
+          // Pre-dispatch waits remain retryable. The shared launch boundary
+          // records durable intent immediately before provider I/O or local start.
+          entry = save(id, reviewDispositionPatch(id, entry, record.key, disposition));
+          await fixOrStop(id, entry, pr, { name: "fix", events: [], denials: findingsPrompt(record), summary: "first-party review findings", since: readAt, reviewKey: record.key }, deferredDispatches);
+          return;
+        }
+      } catch (error) {
+        if (error.retryableReviewCapture === true) {
+          await retryFailed(id, state.get(id), REVIEW_CAPTURE, error, { action: "retrying the current PR evidence read next tick" }); return;
+        }
+        await needsHuman(id, ["REVIEW_INCOMPLETE", "BB_INCOMPLETE", "BB_OVERSIZED"].includes(error.code) ? "review-incomplete" : "first-party-review-failed", { firstPartyReview: { status: "incomplete", binding, error: error.message, errorCode: error.code }, last: { at: now(), event: error.message } }); return;
+      }
+    }
+    const verdict = judge ? reviewVerdict(entry.reviewPolicy, external, entry.firstPartyReview, binding) : null;
+    if (entry.state === STATES.ready && entry.reviewPolicy.version === 1 && (!green || verdict.verdict !== "clear")) {
+      try { await reopen(id, entry); }
+      catch (error) { await retryFailed(id, state.get(id), READY_LABEL_REMOVAL, error, { action: "readiness invalidated; retrying label removal" }); }
+      return;
+    }
     if (entry.state === STATES.ready && entry.task?.completion && entry.completionEvidence?.delivery) {
       const delivery = entry.completionEvidence?.delivery;
       const bindingChanged = !delivery || delivery.invalidatedAt || delivery.head !== pr.headRefOid || delivery.base !== pr.baseRefName || delivery.receiptHash !== receiptHash(pr.body);
@@ -1352,7 +1575,7 @@ export function makeTick(deps) {
       }
     }
     if (entry.state === STATES.ready && hasLegacyStatusLabels(pr.labels)) {
-      try { await gh.addLabel(entry.repo, entry.pr, READY_LABEL); }
+      try { await host.addLabel(entry.repo, entry.pr, READY_LABEL); }
       catch (err) {
         await retryFailed(id, entry, READY_LABEL_WRITE, err, { action: "retrying the neutral ready label next tick" });
         return;
@@ -1401,13 +1624,19 @@ export function makeTick(deps) {
       } else if (entry.prd_divergence) {
         entry = save(id, { prd_divergence: null });
       }
+      // The immutable path proof is reusable; the optional content scan still
+      // needs diff text if this tick did not fetch it before review.
+      if (!await checkPublication({ force: Boolean(config.deliverable?.scan_output && publicationDiff === null) })) return;
       // The completion gate: the last step before a human is asked to look. Only for entries with a PRD.
       const prd = config.deliverable ? prdFor(id) : null;
       // An entry with no snapshot reaches ready on the checks and the reviewer alone, with nothing about what the PR
       // was supposed to deliver ever read. That used to be one line in `errors.log` and nothing anywhere else:
       // `status`, `why`, the ntfy message and the PR all said what they say for a PR that passed the gate. So it is
       // carried on the entry, where the three of them can say it.
-      const gateSkipped = config.deliverable && !prd ? "no PRD snapshot" : null;
+      const gateSkipped = !config.deliverable ? "completion gate disabled" : !prd ? "no PRD snapshot" : null;
+      if (entry.reviewPolicy.version === 1 && (!config.deliverable || !prd)) {
+        await needsHuman(id, "completion-gate-skipped", { gate_skipped: !config.deliverable ? "completion gate disabled" : "no PRD snapshot" }); return;
+      }
       let completionGate = null;
       if (gateSkipped) log.warn(`${id}: ${gateSkipped}, completion gate skipped`);
       if (prd) {
@@ -1415,21 +1644,10 @@ export function makeTick(deps) {
         // The output scan needs the whole diff. A diff that cannot be read is not an empty diff: `addedLines(null)`
         // is the empty string, which passes the blocked-pattern scan trivially, so a transient `gh pr diff` failure
         // would let a PR through the very check it is meant to face. A diff too large to hold is the same fail-open
-        // one step further on, and `gh.prDiff` throws for it rather than returning a prefix that looks whole. No
+        // one step further on, and `host.prDiff` throws for it rather than returning a prefix that looks whole. No
         // decision either way: retry with the shared bound, then stop with the cause if it still cannot be read.
         let diff = null;
-        if (config.deliverable.scan_output) {
-          let raw;
-          try { raw = await gh.prDiff(entry.repo, entry.pr); }
-          catch (e) { raw = e; }
-          // Anything that is not diff text is unreadable, a thrown error and an absent diff alike, so no future
-          // caller can reintroduce the fail-open by handing the scan a value that merely looks empty.
-          if (typeof raw !== "string") {
-            await retryFailed(id, entry, COMPLETION_GATE, new Error(`diff unreadable: ${raw instanceof Error ? raw.message : `gh pr diff returned ${raw}`}`), { action: "reviewer clear; retrying the output scan next tick" });
-            return;
-          }
-          diff = addedLines(raw);
-        }
+        if (config.deliverable.scan_output) diff = addedLines(publicationDiff);
         // `framework` is the harness that did the work, carried as self-reported provenance in the decision's
         // context so a machine running two harnesses can tell their decisions apart afterwards.
         const g = await gate({ taskId: id, prBody: pr.body, criteria, checksGreen: true, diff, framework: entry.harness, limits: config.deliverable, apiKey: aportApiKey, fetch, log });
@@ -1459,7 +1677,7 @@ export function makeTick(deps) {
       // the other three, because every readiness condition had already passed: `status` said the entry was waiting on
       // the reviewer, which the reviewer had already answered, and the completion gate was re-evaluated (and, with a
       // hosted evaluator, re-paid for) on every poll for a decision that was already made.
-      try { await gh.addLabel(entry.repo, entry.pr, READY_LABEL); }
+      try { await host.addLabel(entry.repo, entry.pr, READY_LABEL); }
       catch (err) {
         await retryFailed(id, entry, READY_LABEL_WRITE, err, { action: "staying in pr-open and trying again next tick" });
         return;
@@ -1468,9 +1686,10 @@ export function makeTick(deps) {
       // entry's label, and a stale count there would outrank the ready row in `status` and hide the one thing the
       // operator is being asked to act on.
       entry = retryOk(id, entry);
-      const e = save(id, { state: STATES.ready, gate_skipped: gateSkipped, retry: null,
+      const e = save(id, { state: STATES.ready, activity_at: now(), gate_skipped: gateSkipped, retry: null,
+        review_readiness: { binding, note: verdict.note, verdict: verdict.verdict, checks: (pr.statusCheckRollup || []).length ? "settled" : entry.reviewPolicy.version === 1 ? "explicit zero-check policy" : "no checks reported (legacy grace policy)", completion: completionGate ? "accepted" : "skipped" },
         ...(entry.task?.completion && completionGate ? { completionEvidence: { delivery: {
-          adapter: "github-pull-request", repository: entry.repo, pr: entry.pr, head: pr.headRefOid,
+          adapter: completionAdapter(entry.repo, deps.hosts ?? hosts), repository: entry.repo, pr: entry.pr, head: pr.headRefOid,
           base: pr.baseRefName || entry.base || null, receiptHash: receiptHash(pr.body), observedAt: now(),
           gate: completionGate, checks: { settled: true, count: (pr.statusCheckRollup || []).length }, reviewer: { verdict: verdict.verdict },
         } } } : {}),
@@ -1513,11 +1732,11 @@ export function makeTick(deps) {
     // that has just asked. The two markers stay separate because they answer different questions on different
     // passes: a round announces a push, a nudge chases a reviewer that has said nothing since one. `nudged` stays
     // false here, so a reviewer that really does go quiet is still chased on the next tick.
-    if (verdict.verdict === "waiting" && entry.rereview.at && !asked) {
+    if (verdict.verdict === "waiting" && needsExternal(entry.reviewPolicy) && entry.rereview.at && !asked) {
       const waited = clock.now() - Date.parse(entry.rereview.at);
       if (waited > hours(config.stall_hours)) { await needsHuman(id, "reviewer-silent"); return; }
       if (waited > minutes(config.rereview_minutes) && !entry.rereview.nudged) {
-        const posted = await commentOnce(entry, nudgeComment(config), NUDGE_MARKER, entry.rereview.at);
+        const posted = await commentOnce(entry, nudgeComment(reviewConfigFor(entry)), NUDGE_MARKER, entry.rereview.at);
         save(id, { rereview: { ...entry.rereview, nudged: true } });
         log.info(`${id}: ${posted ? "nudged reviewer" : "nudge already posted"}`);
       }
@@ -1551,12 +1770,18 @@ export function makeTick(deps) {
       }
     };
     await Promise.all(Array.from({ length: Math.min(config.execution?.concurrency || CONCURRENCY, entries.length) }, recoverWorker));
+    const entryPolls = new Map(entries.map(([id]) => {
+      let finish;
+      const done = new Promise(resolve => { finish = resolve; });
+      return [id, { done, finish }];
+    }));
     const worker = async () => {
       for (let next = queue.shift(); next; next = queue.shift()) {
         const [id, entry] = next;
-        if (recovered.has(id)) { results.push({ id, ok: true }); continue; }
+        if (recovered.has(id)) { results.push({ id, ok: true }); entryPolls.get(id).finish(); continue; }
         try { await tickEntry(id, state.get(id) || entry, { skipReconciliation: Boolean(deps.executionFor), deferredDispatches }); results.push({ id, ok: true }); }
         catch (e) { log.error(`${id}: ${e.message}`); results.push({ id, ok: false, error: e.message }); }
+        finally { entryPolls.get(id).finish(); }
       }
     };
     const progressWorker = async () => {
@@ -1582,10 +1807,38 @@ export function makeTick(deps) {
       }
     };
     const concurrency = Math.min(config.execution?.concurrency || CONCURRENCY, entries.length);
-    // Independent bounded lanes: provider I/O cannot occupy every GitHub worker.
+    // Local reviewer progress does not need another Git-host snapshot per
+    // piece. Advance only previously running captures between host polls.
+    // A terminal result wakes the ordinary host lane; only that lane can clear
+    // readiness after rereading the current PR binding.
+    const reviewQueue = entries.filter(([, entry]) => entry.firstPartyReview?.status === "running" && entry.review_next_at > clock.now());
+    const reviewWorker = async () => {
+      for (let next = reviewQueue.shift(); next; next = reviewQueue.shift()) {
+        const [id] = next;
+        try {
+          if (!deps.reviewService?.progress) continue;
+          // The same entry's quick between-poll checks must release its lock;
+          // other entries and the provider lane can remain in flight.
+          await entryPolls.get(id).done;
+          await withReviewState(deps, id, async () => {
+            const entry = state.get(id);
+            if (![STATES.prOpen, STATES.ready].includes(entry?.state) || controlPending(entry.control) || entry.firstPartyReview?.status !== "running" || runnerFor(id).current()?.running) return;
+            const record = await deps.reviewService.progress(id, entry);
+            if (record) save(id, { firstPartyReview: record, ...(record.status !== "running" ? { review_next_at: 0 } : {}) });
+          });
+        } catch (error) {
+          if (state.get(id)?.firstPartyReview?.status === "running") save(id, { review_next_at: 0 });
+          log.warn(`${id}: reviewer progress failed (${error.code || "review failed"})`);
+        }
+      }
+    };
+    // Independent bounded lanes: slow host/provider I/O must not delay
+    // settlement of a captured local review. Per-task review locks still
+    // exclude simultaneous decisions; only the host lane can clear readiness.
     await Promise.all([
       ...Array.from({ length: concurrency }, worker),
       ...(deps.executionFor ? Array.from({ length: concurrency }, progressWorker) : []),
+      ...Array.from({ length: Math.min(concurrency, reviewQueue.length) }, reviewWorker),
     ]);
     // Pending health cannot occupy review workers. Retry these dispatches once
     // in this tick after their existing scoped probe has saved its observation.
@@ -1594,10 +1847,13 @@ export function makeTick(deps) {
         const { id, entry, pr, spec, refreshed } = next;
         try {
           await refreshed;
-          const current = state.get(id);
-          if (!current || completed(id, current) || ![STATES.prOpen, STATES.ready].includes(current.state) || current.pr !== entry.pr ||
-            current.harness !== entry.harness || current.last?.run !== entry.last?.run || JSON.stringify(current.cursor) !== JSON.stringify(entry.cursor)) continue;
-          await fixOrStop(id, current, pr, spec);
+          await withReviewState(deps, id, async () => {
+            const current = state.get(id);
+            if (!current || completed(id, current) || ![STATES.prOpen, STATES.ready].includes(current.state) || current.pr !== entry.pr ||
+              current.harness !== entry.harness || current.last?.run !== entry.last?.run || JSON.stringify(current.cursor) !== JSON.stringify(entry.cursor) ||
+              spec.reviewKey && current.firstPartyReview?.key !== spec.reviewKey) return;
+            await fixOrStop(id, current, pr, spec);
+          });
         } catch (e) {
           log.error(`${id}: ${e.message}`);
           Object.assign(results.find(result => result.id === id), { ok: false, error: e.message });