@ai-dossier/sched 0.49.0 → 0.50.0

package/README.md

@@ -1040,7 +1040,9 @@ import {
                          //   runBatchCapability — #523)
   createSpawnDeps,       // real detached-spawn process I/O
   createExecGroundTruth, // runstate/gh/git ground truth via subprocesses (injectable exec);
-                         //   since #468 also gh pr view PR state + setup info from comments
+                         //   since #468 also gh pr view PR state + setup info from comments;
+                         //   since #789 also mergedPrForBranch when constructed with a
+                         //   verified `repo` (resolveProjectRepo)
   resolveDispatch,       // config → resolved command/prompt/report-prompt/tier-models/timers/
                          //   per-tier spawn specs (tiers — #527)
   buildTierCommand,      // resolved dispatch + tier + issue → argv, using that tier's OWN
@@ -1068,6 +1070,12 @@ import {
   prOfMilestone,         // a milestone's pr= key as a positive integer
   parsePrViewJson,       // gh pr view --json → PR truth (mergedAt/mergeable/blocked label)
   parseOpenPrListJson,   // gh pr list --head <b> --state open → the open PR we opened (#596)
+  parseMergedPrListJson, // gh pr list --head <b> --base <base> --state merged → MergedPrLookup
+                         //   found/none/ambiguous — a hand-opened batch PR the ledger never
+                         //   recorded (#789)
+  type MergedPrLookup,   // { kind: 'found', pr, mergedAt } | { kind: 'none' } |
+                         //   { kind: 'ambiguous', matches } — GroundTruth.mergedPrForBranch's
+                         //   own return type (#789)
   parseSetupInfo,        // gh issue view --json comments → teardown inputs
   runTeardown,           // #468 script teardown for a merged unit (pool return / worktree remove)
   isSafeWorktree,        // worktree-path containment check (CWE-22)
@@ -1138,7 +1146,7 @@ import {
   issueCloseReader, parseIssueCloseTruthJson, parseRepoName,
   resolveProjectRepo,    // #768 owner/name of the cwd repo only when it IS the project's
   hasLabel,              // case-insensitive label match (#768)
-  validateState,         // strict persisted-state validation (1.0.0-1.13.0 files migrate)
+  validateState,         // strict persisted-state validation (1.0.0-1.23.0 files migrate)
   DEFAULT_ISSUE_PRIORITY, DEFAULT_BATCH_PRIORITY, // priority defaults (0 / 10, #565)
   IllegalTransitionError, EnqueueError, CorruptStateError, LockTimeoutError,
   SchedNotFoundError,
@@ -1306,8 +1314,9 @@ after-the-fact recovery, not a missing-data bug.
   queue data.
 - **Schema**: state/config files from #460 (schema 1.0.0), #464 (1.1.0), #468 (1.2.0),
   #472 (1.3.0), #500 (1.4.0), #505 (1.5.0), #504 (1.6.0), #523 (1.7.0) and #524 (1.8.0)
-  load and migrate to the current schema (1.24.0 — #810: no backfill, `kind`/`branch`
-  optional, absent = an `evicted` record with no branch) automatically (slot `branch`/`last_head`/`pid_start`, slot `role` (inferred from the
+  load and migrate to the current schema (1.25.0 — 1.24.0 was #810: no backfill,
+  `kind`/`branch` optional, absent = an `evicted` record with no branch) automatically
+  (slot `branch`/`last_head`/`pid_start`, slot `role` (inferred from the
   unit's queue entry, with the persisted `phase` as a fallback — #500), entry
   `pr`/`cleanup`/`failure_evidence`, batch `anchor`/`branch`/`run_id`/`eviction_groups`/
   `evictions`/`fix_attempts`/`rebase_attempts`, state-level `last_pr_poll_at` backfill to
@@ -1320,7 +1329,10 @@ after-the-fact recovery, not a missing-data bug.
   `consecutive_dispatch_api_errors`/`dispatch_pause_reset_at` backfill to `0`/`null` —
   #629; batch `anchor_closed_at` and `anchor_close_failed_reason`/`_since`/`_ticks`
   backfill to `null`/`null`/`null`/`0` — #768, schema 1.22.0; batch `member_dispatch`/`member_runs`
-  backfill to `null`/`[]` — #809, schema 1.23.0 — a null mode past `ready` runs serially).
+  backfill to `null`/`[]` — #809, schema 1.23.0 — a null mode past `ready` runs serially;
+  `IssueStatus` gains `handed-back`, `EvictionRecord`/`FailureEvidence` gain optional
+  `kind`/`branch` — #810, schema 1.24.0; batch `pr_detect_ambiguous_reason`/`_since`/`_ticks`
+  backfill to `null`/`null`/`0` — #789, schema 1.25.0).
 - **`max_slots`** bounds live units (`assigned | running | recovering`); dependency
   edges gate readiness — an issue with an unmerged dependency, and a batch behind an
   unmerged batch, are never runnable.
@@ -1413,6 +1425,31 @@ predicate in `anchor-close.ts`) over `blocked`/`done` batches touched within the
   the journal line says the worktree was kept, and `sched status` then raises a
   `kept-worktree` warning for it on every run until the ledger field clears — see
   above and `reconcileKeptWorktrees` (#791).
+- **PR-detection evidence (#789).** When `batch.pr` was never recorded at all — a PR
+  opened by hand, e.g. imboard#4255 — the stale-blocked reconcile also looks for
+  exactly one MERGED pull request whose head is the batch branch, based against
+  `batch.base_branch`, created at or after the batch's own `created_at`, and not from a
+  fork (`GroundTruth.mergedPrForBranch`: `gh pr list -R <repo> --head <branch> --base
+  <base> --state merged`, gated on the same verified `resolveProjectRepo` #768 uses —
+  absent entirely without one). Positive evidence only: zero candidates records
+  nothing and falls through to the branch/members evidence below; two or more is
+  `ambiguous` — no PR is recorded, and only when no OTHER evidence reconciles the
+  batch that same tick is the ambiguity journaled (`pr-detect-ambiguous`, deduped like
+  `pr-watch-failed`: once per `blocked` stretch, re-announced every
+  `JOURNAL_DEDUP_REANNOUNCE_TICKS`; a batch that leaves `blocked` any way — this
+  reconcile's own success, `sched resume --batch`, `sched abandon` — clears the marker,
+  so a later re-block never inherits a stale streak). A batch that still reconciles via
+  `commits-in-base`/`members-closed` does so without a PR and finishes inline, same as
+  before #789. On a match, `batch.pr` is recorded as part of the SAME `blocked →
+  merged` transition (the `stale-failure-reconciled` line then also carries
+  `pr_detected: true`), so the ordinary `deployed` machinery (item 6, "Report dispatch",
+  under "The PR watcher + tail work (#468)" below — shared infrastructure, not
+  per-issue-only despite the section's origin) dispatches the report agent exactly as if the
+  fleet had opened the PR itself, and `sched status`'s existing `pr` column shows it.
+  Recording `batch.pr` never closes the anchor by itself — that stays #768's own
+  evidence-gated `reconcileAnchorClosure`, unchanged. An ambiguous match with no
+  explicit way to resolve it today (#824 tracks a `sched attach-pr` verb) still lets the
+  batch reconcile via its other evidence, or falls to `sched abandon --batch`.
 
 Everything else is surfaced, never closed: `sched status --anchors` (opt-in; `status`
 makes no GitHub call without it) lists each still-open anchor of a batch no longer in

package/dist/batch-dispatch.d.ts

@@ -61,6 +61,7 @@
  * before returning, so a member's first command is never the one that
  * discovers `node_modules` is missing (`env-cold`, `docs/agent-traps.md`).
  */
+import { type CommitInBase, type IssueCloseReader } from './anchor-close';
 import { type ResolvedDispatch, type SpawnDeps } from './dispatch';
 import { type GroundTruth } from './groundtruth';
 import { type Journal } from './journal';
@@ -237,6 +238,63 @@ export declare function resumeBlockedGate(deps: BatchDispatchDeps, config: Sched
     blockedBy?: 'inconclusive' | 'unevidenced-failure';
     detail?: string;
 };
+/**
+ * #686: reconcile a `blocked` batch whose work demonstrably shipped anyway.
+ * `reconcilePrWatch` above only watches `awaiting-merge` batches, and
+ * `resumeBlockedGate` only re-runs the gate — so a batch blocked on a stale
+ * verdict (the concrete case: `gate-inconclusive:test.focused`, itself often
+ * a #690-declined gate TIMEOUT) whose PR merged out of band — or whose every
+ * member commit is already in the base — stayed blocked FOREVER: no report,
+ * no teardown, an operator-visible `blocked` row, and members stuck
+ * `in-work`. Sibling of the per-issue `reconcileStaleFailedParks`
+ * (engine.ts) under the same principle: ground truth beats the ledger, for
+ * ANY stale verdict — the blocked_reason is deliberately not examined.
+ *
+ * Evidence (cheapest first): the batch PR is MERGED with a real timestamp (a
+ * merged batch PR contains the whole batch branch) — including one
+ * `batch.pr` never recorded at all (#789): when `pr === null`, before falling
+ * through to the weaker branch/members evidence below, look for exactly one
+ * MERGED PR whose head is the batch branch (`imboard#4255`, a hand-opened PR
+ * the ledger never saw). Positive evidence only — zero candidates changes
+ * nothing, more than one is `ambiguous` and journaled rather than guessed —
+ * or the batch branch has fully landed in the base branch. A survivability
+ * guard applies to every path (see `everySurvivingMemberDispatched`) — a
+ * batch with a surviving member that was never dispatched is not
+ * reconcilable.
+ *
+ * On reconcile the batch joins the SAME rail a normally-merged batch takes:
+ * `blocked → merged → deployed` (the `blocked → merged` edge exists for
+ * exactly this caller), surviving members walked to `done` along legal
+ * edges, and — when the batch now carries a PR (recorded before or detected
+ * here) — the ordinary `deployed` machinery dispatches the report agent next
+ * tick, with teardown after `batch-report done`. With no PR at all no report
+ * agent can be prompted (it names the PR), so the same lock continues
+ * `deployed → reported → done` and the worktree is torn down here instead;
+ * the journal line says why no report agent was dispatched rather than
+ * leaving the gap silent.
+ *
+ * Bounded by construction: only `blocked` batches within the window are
+ * examined, the PR check is one `gh` call, git runs only when PR evidence
+ * didn't already reconcile, and a reconciled batch leaves `blocked` — the
+ * one journal line fires on the one-way transition, never per-tick (the
+ * #632 lesson: no journal inside a loop that doesn't terminate the unit).
+ */
+export declare function reconcileStaleBlockedBatches(deps: BatchDispatchDeps, now: Date, result: BatchTickResult, anchorCtx: AnchorTickContext | undefined): void;
+/**
+ * #768: what one tick's anchor work reads GitHub and git through — built once
+ * per tick so the stale-blocked reconcile and the anchor close never read the
+ * same issue twice in a tick. `undefined` when the tick cannot verify anything
+ * (no issue-closure ground truth, or no verified `anchorRepo`): then neither
+ * pass acts at all.
+ */
+interface AnchorTickContext {
+    repo: string;
+    /** Cached for the tick — the verdict passes. */
+    read: IssueCloseReader;
+    /** Uncached — the re-read immediately before an irreversible close. */
+    readFresh: IssueCloseReader;
+    commitInBase: CommitInBase;
+}
 /**
  * How a batch should dispatch its members (#809) — decided once, at the
  * `ready → executing` claim, and persisted on `BatchEntry.member_dispatch`.

package/dist/batch-dispatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"batch-dispatch.d.ts","sourceRoot":"","sources":["../src/batch-dispatch.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"batch-dispatch.d.ts","sourceRoot":"","sources":["../src/batch-dispatch.ts"],"names":[],"mappings":"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"}

package/dist/batch-dispatch.js

@@ -99,6 +99,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.memberBranchFor = memberBranchFor;
 exports.evictMemberAndContinue = evictMemberAndContinue;
 exports.resumeBlockedGate = resumeBlockedGate;
+exports.reconcileStaleBlockedBatches = reconcileStaleBlockedBatches;
 exports.memberDispatchModeFor = memberDispatchModeFor;
 exports.runBatchTick = runBatchTick;
 const fs = __importStar(require("node:fs"));
@@ -2655,18 +2656,44 @@ function reconcileReportSlot(deps, batchId, slot, now, result) {
 }
 // --- PR watch for `awaiting-merge` batches (mirrors `pollParkedPrs`/`reconcileParked`) ---
 /**
- * Reset a batch's `pr-watch-failed` dedup marker (#630/#633). A no-op when no
- * streak is recorded, so it is safe to call on every non-`awaiting-merge`
- * batch every tick.
+ * Clear one `<prefix>_reason`/`_since`/`_ticks` batch dedup marker — a no-op
+ * when no streak is recorded (`currentReason === null`), so every caller is
+ * safe to invoke unconditionally, every tick, on a batch that may or may not
+ * have an open streak. Shared by `pr-watch-failed` (#630/#633),
+ * `anchor-close-failed` (#768) and `pr-detect-ambiguous` (#789) — each
+ * family previously carried its own copy of this exact body (#789 review).
  */
-function clearPrWatchFailed(deps, batch, now) {
-    if (batch.pr_watch_failed_reason === null)
+function clearBatchDedupMarker(deps, batch, currentReason, clearedFields, now) {
+    if (currentReason === null)
         return;
     deps.store.withLock((s) => ({
-        state: (0, state_1.patchBatch)(s, batch.id, state_1.CLEARED_PR_WATCH_FIELDS, now, false),
+        state: (0, state_1.patchBatch)(s, batch.id, clearedFields, now, false),
         result: undefined,
     }));
 }
+/**
+ * Advance one `<prefix>_reason`/`_since`/`_ticks` batch dedup marker by one
+ * tick and decide whether THIS tick should journal — the streak's first tick,
+ * or every `JOURNAL_DEDUP_REANNOUNCE_TICKS` after, never every tick
+ * (#610/#630/#632/#768/#789's shared shape). Pure — the caller still owns
+ * building its own journal payload (each family logs different extra fields)
+ * and the `deps.store.withLock` persistence write; this only computes
+ * `since`/`ticks`/whether to announce.
+ */
+function advanceBatchDedupStreak(priorReason, priorSince, priorTicks, reason, now) {
+    const isNewStreak = priorReason !== reason || priorSince === null;
+    const ticks = isNewStreak ? 1 : priorTicks + 1;
+    const since = isNewStreak || priorSince === null ? now.toISOString() : priorSince;
+    return { since, ticks, announce: isNewStreak || ticks % types_1.JOURNAL_DEDUP_REANNOUNCE_TICKS === 0 };
+}
+/**
+ * Reset a batch's `pr-watch-failed` dedup marker (#630/#633). A no-op when no
+ * streak is recorded, so it is safe to call on every non-`awaiting-merge`
+ * batch every tick.
+ */
+function clearPrWatchFailed(deps, batch, now) {
+    clearBatchDedupMarker(deps, batch, batch.pr_watch_failed_reason, state_1.CLEARED_PR_WATCH_FIELDS, now);
+}
 function reconcilePrWatch(deps, now, result) {
     const state = deps.store.load();
     for (const batch of state.batches) {
@@ -2715,9 +2742,6 @@ function reconcilePrWatch(deps, now, result) {
         }
         if (truth.blocked || truth.mergeable === 'CONFLICTING') {
             const reason = truth.blocked ? 'auto-merge-blocked' : 'pr-conflicting';
-            const isNewStreak = batch.pr_watch_failed_reason !== reason;
-            const ticks = isNewStreak ? 1 : batch.pr_watch_failed_ticks + 1;
-            const since = isNewStreak ? now.toISOString() : batch.pr_watch_failed_since;
             // #630: journal on the streak's first tick, then again only every
             // `JOURNAL_DEDUP_REANNOUNCE_TICKS` — never every tick — mirrors #610's
             // `stale_milestone_ignored_for` dedup for the "distinct condition"
@@ -2729,7 +2753,8 @@ function reconcilePrWatch(deps, now, result) {
             // of its own); `since` is the streak's onset, and is what makes the
             // duration legible — `ticks_persisted` is a tick count against an
             // operator-tunable `reconcile_interval_ms`, not a fixed wall-clock.
-            if (isNewStreak || ticks % types_1.JOURNAL_DEDUP_REANNOUNCE_TICKS === 0) {
+            const { since, ticks, announce } = advanceBatchDedupStreak(batch.pr_watch_failed_reason, batch.pr_watch_failed_since, batch.pr_watch_failed_ticks, reason, now);
+            if (announce) {
                 journalEvent(deps, 'pr-watch-failed', unit(batch.id), {
                     reason,
                     pr,
@@ -2872,6 +2897,51 @@ function branchMergedIntoBase(deps, batch) {
     const baseTip = deps.exec('git', ['rev-parse', base], deps.repoDir);
     return branchTip !== null && baseTip !== null && branchTip.trim() !== '' && branchTip !== baseTip;
 }
+/**
+ * The ambiguity condition stopped qualifying (the branch resolved to zero or
+ * exactly one candidate), or the batch left `blocked` some other way (this
+ * reconcile's own success, `sched resume --batch`, `sched abandon`, or the
+ * batch aging out of the reconcile window): end any `pr-detect-ambiguous`
+ * streak, so a future ambiguity episode — even a re-block of the SAME batch
+ * with the SAME candidates — journals its own first line instead of silently
+ * continuing a streak from a previous `blocked` stretch (#789 review). A
+ * no-op (no write) when no streak is recorded.
+ */
+function clearPrDetectAmbiguous(deps, batch, now) {
+    clearBatchDedupMarker(deps, batch, batch.pr_detect_ambiguous_reason, state_1.CLEARED_PR_DETECT_AMBIGUOUS_FIELDS, now);
+}
+/**
+ * #789: more than one MERGED PR matches `batch.branch` — positive evidence
+ * only, so the caller records nothing. Journal it on the streak's first tick
+ * and every `JOURNAL_DEDUP_REANNOUNCE_TICKS` after — never every tick — the
+ * same dedup shape `recordAnchorCloseFailed`/`reconcilePrWatch` use.
+ */
+function recordPrDetectAmbiguous(deps, batch, matches, now) {
+    const { since, ticks, announce } = advanceBatchDedupStreak(batch.pr_detect_ambiguous_reason, batch.pr_detect_ambiguous_since, batch.pr_detect_ambiguous_ticks, state_1.PR_DETECT_AMBIGUOUS_REASON, now);
+    if (announce) {
+        journalEvent(deps, 'pr-detect-ambiguous', unit(batch.id), {
+            reason: state_1.PR_DETECT_AMBIGUOUS_REASON,
+            branch: batch.branch ?? undefined,
+            matches: matches.join(','),
+            at: now.toISOString(),
+            since,
+            ticks_persisted: ticks,
+            // #789 review: neither "record it explicitly" (no command exists) nor
+            // "close the extras" (a MERGED PR cannot be closed, so it never leaves
+            // `gh pr list --state merged`) was ever an actionable remedy — state
+            // what actually resolves it instead. #824 tracks the missing verb.
+            detail: `${matches.length} MERGED PRs match head=${batch.branch ?? '?'} (#${matches.join(', #')}) — refusing to guess which is ours; nothing recorded. The batch still reconciles via commits-in-base/members-closed evidence if either holds; otherwise inspect and \`sched abandon --batch ${batch.id}\`, or use \`sched attach-pr\` once #824 ships it`,
+        });
+    }
+    deps.store.withLock((s) => ({
+        state: (0, state_1.patchBatch)(s, batch.id, {
+            pr_detect_ambiguous_reason: state_1.PR_DETECT_AMBIGUOUS_REASON,
+            pr_detect_ambiguous_since: since,
+            pr_detect_ambiguous_ticks: ticks,
+        }, now, false),
+        result: undefined,
+    }));
+}
 /**
  * #686: reconcile a `blocked` batch whose work demonstrably shipped anyway.
  * `reconcilePrWatch` above only watches `awaiting-merge` batches, and
@@ -2884,21 +2954,28 @@ function branchMergedIntoBase(deps, batch) {
  * (engine.ts) under the same principle: ground truth beats the ledger, for
  * ANY stale verdict — the blocked_reason is deliberately not examined.
  *
- * Evidence (either suffices, cheapest first): the batch PR is MERGED with a
- * real timestamp (a merged batch PR contains the whole batch branch), or the
- * batch branch has fully landed in the base branch. A survivability guard
- * applies to BOTH paths (see `everySurvivingMemberDispatched`) — a batch with
- * a surviving member that was never dispatched is not reconcilable.
+ * Evidence (cheapest first): the batch PR is MERGED with a real timestamp (a
+ * merged batch PR contains the whole batch branch) — including one
+ * `batch.pr` never recorded at all (#789): when `pr === null`, before falling
+ * through to the weaker branch/members evidence below, look for exactly one
+ * MERGED PR whose head is the batch branch (`imboard#4255`, a hand-opened PR
+ * the ledger never saw). Positive evidence only — zero candidates changes
+ * nothing, more than one is `ambiguous` and journaled rather than guessed —
+ * or the batch branch has fully landed in the base branch. A survivability
+ * guard applies to every path (see `everySurvivingMemberDispatched`) — a
+ * batch with a surviving member that was never dispatched is not
+ * reconcilable.
  *
  * On reconcile the batch joins the SAME rail a normally-merged batch takes:
  * `blocked → merged → deployed` (the `blocked → merged` edge exists for
  * exactly this caller), surviving members walked to `done` along legal
- * edges, and — when `batch.pr` is set — the ordinary `deployed` machinery
- * dispatches the report agent next tick, with teardown after `batch-report
- * done`. With `pr === null` no report agent can be prompted (it names the
- * PR), so the same lock continues `deployed → reported → done` and the
- * worktree is torn down here instead; the journal line says why no report
- * agent was dispatched rather than leaving the gap silent.
+ * edges, and — when the batch now carries a PR (recorded before or detected
+ * here) — the ordinary `deployed` machinery dispatches the report agent next
+ * tick, with teardown after `batch-report done`. With no PR at all no report
+ * agent can be prompted (it names the PR), so the same lock continues
+ * `deployed → reported → done` and the worktree is torn down here instead;
+ * the journal line says why no report agent was dispatched rather than
+ * leaving the gap silent.
  *
  * Bounded by construction: only `blocked` batches within the window are
  * examined, the PR check is one `gh` call, git runs only when PR evidence
@@ -2910,19 +2987,48 @@ function reconcileStaleBlockedBatches(deps, now, result, anchorCtx) {
     const state = deps.store.load();
     const nowMs = now.getTime();
     for (const batch of state.batches) {
-        if (batch.status !== 'blocked')
+        if (batch.status !== 'blocked') {
+            // #789 review: the marker is scoped to ONE `blocked` stretch, exactly
+            // like `pr_watch_failed_*`'s own `awaiting-merge` scoping (#633) — the
+            // batch left `blocked` (this reconcile's own success below, `sched
+            // resume --batch`, or `sched abandon`), so a LATER re-block — even of
+            // the SAME batch with the SAME candidate PRs — must journal a fresh
+            // first line, never silently continue a stale streak from before.
+            clearPrDetectAmbiguous(deps, batch, now);
             continue;
+        }
         if (nowMs - Date.parse(batch.updated_at) >= STALE_BLOCKED_RECONCILE_WINDOW_MS)
             continue;
         if (!everySurvivingMemberDispatched(state, batch))
             continue;
         let evidence = null;
+        // #789 review: one outer variable for the whole lookup outcome (rather
+        // than three separate booleans/values re-deriving pieces of it) — the
+        // resolution block below reads `lookup.kind` directly instead of a
+        // parallel flag that has to be kept in sync with it by hand.
+        let lookup;
         if (batch.pr !== null) {
             const truth = deps.groundTruth.prState(batch.pr);
             if (truth !== undefined && truth.state === 'MERGED' && truth.mergedAt !== null) {
                 evidence = { kind: 'pr-merged', pr: batch.pr, mergedAt: truth.mergedAt };
             }
         }
+        else if (batch.branch !== null) {
+            // #789: batch.pr was never recorded — a hand-opened or manually
+            // recovered PR the ledger never saw (the imboard#4255 shape). Look for
+            // exactly one MERGED PR whose head is the batch branch before falling
+            // through to the weaker branch/members evidence below. Positive
+            // evidence only: `undefined` (unreachable) touches nothing, and
+            // `ambiguous` (more than one candidate) is journaled, never guessed.
+            lookup = deps.groundTruth.mergedPrForBranch?.(batch.branch, batch.base_branch, batch.created_at);
+            if (lookup?.kind === 'found') {
+                evidence = { kind: 'pr-merged', pr: lookup.pr, mergedAt: lookup.mergedAt };
+            }
+        }
+        // Set only when THIS tick's automatic lookup found the PR — never when
+        // `batch.pr` was already recorded (that PR is reported via `evidence.pr`
+        // as before, and there is nothing new to persist).
+        const detectedPr = lookup?.kind === 'found' ? lookup.pr : null;
         if (evidence === null && branchMergedIntoBase(deps, batch)) {
             evidence = { kind: 'commits-in-base' };
         }
@@ -2940,12 +3046,20 @@ function reconcileStaleBlockedBatches(deps, now, result, anchorCtx) {
             }).kind === 'closable') {
             evidence = { kind: 'members-closed' };
         }
+        // #789: resolve the ambiguity streak exactly once per tick. An ambiguous
+        // lookup records only when the batch ISN'T reconciling by other evidence
+        // this same tick; any evidence at all (including a `found`/`none` lookup
+        // result) clears a stale or same-tick streak — reconciling via ANY
+        // evidence means the batch is leaving `blocked`, so a same-tick ambiguity
+        // is moot too.
+        if (lookup?.kind === 'ambiguous' && evidence === null) {
+            recordPrDetectAmbiguous(deps, batch, lookup.matches, now);
+        }
+        else if (evidence !== null || lookup?.kind === 'found' || lookup?.kind === 'none') {
+            clearPrDetectAmbiguous(deps, batch, now);
+        }
         if (evidence === null)
             continue;
-        // A members-closed reconcile has no merged batch PR for a report agent to
-        // report on, whatever `batch.pr` recorded — finish the rail inline, as
-        // for `pr === null`.
-        const finishInline = batch.pr === null || evidence.kind === 'members-closed';
         // ...but never tear its worktree down: the members shipped OUTSIDE the
         // batch branch, so the blocked integration worktree may hold an
         // operator's unpushed repair work. It is left in place, inert, and the
@@ -2955,6 +3069,12 @@ function reconcileStaleBlockedBatches(deps, now, result, anchorCtx) {
         const failedAt = batch.updated_at;
         let reconciled = false;
         let unwalkable = [];
+        // #789 review: what the lock ACTUALLY applied, not what the outer
+        // snapshot predicted — re-derived from `b` (read under the lock) below,
+        // since `batch.pr` could in principle have changed between the snapshot
+        // above and the lock acquiring (e.g. a future `sched attach-pr`, #824).
+        let effectivePr = null;
+        let prWasRecorded = false;
         deps.store.withLock((s) => {
             const b = (0, state_1.findBatch)(s, batch.id);
             // Re-check under the lock: `sched resume --batch` (a passing recheck)
@@ -2962,7 +3082,19 @@ function reconcileStaleBlockedBatches(deps, now, result, anchorCtx) {
             // snapshot this pass started from.
             if (!b || b.status !== 'blocked')
                 return { state: s, result: undefined };
-            let n = (0, state_1.transitionBatch)(s, batch.id, 'merged', {}, now);
+            // #789: record the auto-detected PR as part of the SAME transition that
+            // leaves `blocked` — a batch whose ledger never had one now does. Only
+            // when `b.pr` is STILL null under the lock — never overwrite a PR
+            // something else recorded between the snapshot and here.
+            prWasRecorded = detectedPr !== null && b.pr === null;
+            effectivePr = prWasRecorded ? detectedPr : b.pr;
+            let n = (0, state_1.transitionBatch)(s, batch.id, 'merged', {
+                // The ambiguity streak (this tick's own, or a stale one) is moot
+                // the instant the batch reconciles by any evidence — fold the
+                // clear into this same transition instead of a separate lock write.
+                ...state_1.CLEARED_PR_DETECT_AMBIGUOUS_FIELDS,
+                ...(prWasRecorded ? { pr: detectedPr } : {}),
+            }, now);
             n = (0, state_1.transitionBatch)(n, batch.id, 'deployed', {}, now);
             unwalkable = [];
             for (const issue of b.members) {
@@ -2986,7 +3118,11 @@ function reconcileStaleBlockedBatches(deps, now, result, anchorCtx) {
                     entry = (0, state_1.findEntry)(n, issue);
                 }
             }
-            if (finishInline) {
+            // The batch now carries a PR — recorded before, recorded just above,
+            // or still null — only when one exists does the ordinary `deployed`
+            // machinery have anything to hand the report agent. A members-closed
+            // reconcile has no merged batch PR to report on regardless.
+            if (effectivePr === null || evidence.kind === 'members-closed') {
                 // No (merged) PR → no report agent is possible (its prompt names the
                 // PR). Finish the terminal rail and let teardown run below.
                 n = (0, state_1.transitionBatch)(n, batch.id, 'reported', {}, now);
@@ -2997,14 +3133,19 @@ function reconcileStaleBlockedBatches(deps, now, result, anchorCtx) {
         });
         if (!reconciled)
             continue;
+        const finishInline = effectivePr === null || evidence.kind === 'members-closed';
         journalEvent(deps, 'stale-failure-reconciled', unit(batch.id), {
-            pr: batch.pr ?? undefined,
+            pr: effectivePr ?? undefined,
             reason: blockedReason,
             failedAt,
             evidence: evidence.kind,
             ...(evidence.kind === 'pr-merged' ? { mergedAt: evidence.mergedAt } : {}),
+            ...(prWasRecorded ? { pr_detected: true } : {}),
             detail: (evidence.kind === 'pr-merged'
-                ? `PR #${evidence.pr} is MERGED — ledger reconciled blocked (${blockedReason}) to the merged rail (blocked at ${failedAt}); report and teardown will now dispatch`
+                ? (prWasRecorded
+                    ? `batch.pr was never recorded — detected PR #${evidence.pr} MERGED with head=${batch.branch} (gh pr list --state merged), recorded batch.pr=${evidence.pr}`
+                    : `PR #${evidence.pr} is MERGED`) +
+                    ` — ledger reconciled blocked (${blockedReason}) to the merged rail (blocked at ${failedAt}); report and teardown will now dispatch`
                 : evidence.kind === 'members-closed'
                     ? `every member issue is CLOSED as completed on GitHub with no failure trail — ledger reconciled blocked (${blockedReason}) to shipped (blocked at ${failedAt})`
                     : `every member commit is an ancestor of ${batch.base_branch} — ledger reconciled blocked (${blockedReason}) to shipped (blocked at ${failedAt})`) +
@@ -3221,12 +3362,7 @@ function recordAnchorClosed(deps, batchId, now) {
  * stale streak's count. A no-op (no write) when no streak is recorded.
  */
 function clearAnchorCloseFailed(deps, batch, now) {
-    if (batch.anchor_close_failed_reason === null)
-        return;
-    deps.store.withLock((s) => ({
-        state: (0, state_1.patchBatch)(s, batch.id, state_1.CLEARED_ANCHOR_CLOSE_FAILED_FIELDS, now, false),
-        result: undefined,
-    }));
+    clearBatchDedupMarker(deps, batch, batch.anchor_close_failed_reason, state_1.CLEARED_ANCHOR_CLOSE_FAILED_FIELDS, now);
 }
 /**
  * A close that qualified but failed: journal it on the streak's first tick and
@@ -3234,11 +3370,8 @@ function clearAnchorCloseFailed(deps, batch, now) {
  * exactly `reconcilePrWatch`'s `pr-watch-failed` dedup.
  */
 function recordAnchorCloseFailed(deps, batch, outcome, shipped, now) {
-    const priorSince = batch.anchor_close_failed_since;
-    const isNewStreak = batch.anchor_close_failed_reason !== outcome || priorSince === null;
-    const ticks = isNewStreak ? 1 : batch.anchor_close_failed_ticks + 1;
-    const since = isNewStreak || priorSince === null ? now.toISOString() : priorSince;
-    if (isNewStreak || ticks % types_1.JOURNAL_DEDUP_REANNOUNCE_TICKS === 0) {
+    const { since, ticks, announce } = advanceBatchDedupStreak(batch.anchor_close_failed_reason, batch.anchor_close_failed_since, batch.anchor_close_failed_ticks, outcome, now);
+    if (announce) {
         journalEvent(deps, 'anchor-close-failed', unit(batch.id), {
             issue: batch.anchor ?? undefined,
             reason: outcome,