@ai-dossier/sched 0.57.6 → 0.58.0

package/README.md

@@ -1606,14 +1606,32 @@ predicate in `anchor-close.ts`) over `blocked`/`done` batches touched within the
   issue's author can close their own issue. One more path counts for a hand close: a
   PR of the project's repository, MERGED into the base, that GitHub lists as closing
   the issue (`closedByPullRequestsReferences` — `Closes #N` parsed but not acted on,
-  the imboard#4116 shape); that still needs a merge, i.e. write access. That reference must
-  also have merged AFTER the member's last reopen (#799): one merged before it did not finish
-  the issue — that is why it was reopened — so it reads `member-closed-by-hand-ref-pr-<n>-predates-reopen`
-  (or `…-merge-time-unreadable`), and a reopen timeline that cannot be read reads
-  `member-closed-by-hand-reopen-unreadable` — needs-operator either way, never closable. A member
-  never reopened is unaffected. Remedy: a new PR or commit that closes the member, or close the
-  anchor by hand. A member issue that no longer resolves
-  (deleted/transferred) reads `member-missing` — needs-operator, not an outage.
+  the imboard#4116 shape); that still needs a PR merged by someone with write access — though
+  not necessarily by whoever wrote its `Closes #N`. That reference must also have merged inside
+  the member's last open stretch, on every hand close: strictly AFTER the stretch began — the
+  last reopen (#799; one merged before it did not finish the issue, that is why it was
+  reopened: `member-closed-by-hand-ref-pr-<n>-predates-reopen`), or, never reopened, the
+  issue's creation (#850; a PR merged before the issue existed can only have been linked by an
+  edit made after the fact: `…-predates-issue`) — and no later than its close (#850; one merged
+  after the close did not back it: `…-postdates-close`). The bounds are on when the PR merged,
+  not on when its `Closes #N` was written: a reference edited into a PR that merged inside the
+  stretch still vouches (#850 chose the time bound over reading when the link was made). A
+  reopen, creation or close time that cannot be read refuses outright, however long the
+  reference list (`member-closed-by-hand-reopen-unreadable`, `…-created-time-unreadable`,
+  `…-close-time-unreadable`); a reference whose merge time cannot be read never vouches
+  (`…-merge-time-unreadable`). A refusal names only the PRs failing the first bound that
+  applies — merge time unreadable, then merged after the close, then merged before the
+  stretch — so a mixed list does not name every rejected PR. The reference list is read one
+  page (100) deep: a longer list whose first page holds no reference that vouches reads
+  `unknown` (`member-closed-by-hand-refs-truncated`, #850), not a refusal — one may be on a
+  later page — unless another member already makes the anchor needs-operator (the truncated
+  member is then named among its reasons). It does not clear on a re-read: list every reference
+  with `gh api graphql --paginate -f query='query($endCursor:String){repository(owner:"<owner>",name:"<name>"){issue(number:<n>){closedByPullRequestsReferences(first:100,after:$endCursor,includeClosedPrs:true){pageInfo{hasNextPage endCursor} nodes{number merged mergedAt baseRefName}}}}}'`
+  and close the anchor by hand if one merged into the base inside the stretch. Remedy for a
+  refusal: a new PR or commit that closes the member, or close the anchor by hand — reopening
+  and re-closing the member does not help (the reference then predates the reopen). A member
+  issue that no longer resolves (deleted/transferred) reads `member-missing` — needs-operator,
+  not an outage.
 - **Never over a failure trail.** Any evicted member, any member in a failure status
   (`ISSUE_UNIVERSAL_FAILURE_EDGES` + `evicted`/`handed-back`/`requeued`), any member requeued out of
   the batch, a dissolved/stopped batch, or a `decision-pending` label on the anchor or a
@@ -1691,7 +1709,8 @@ predicate in `anchor-close.ts`) over `blocked`/`done` batches touched within the
 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
 flight as `closable`, `needs-operator` or `unknown`, with every member's GitHub and
-ledger state, stopping its reads at the first failed one. A blocked batch milestone now
+ledger state, stopping its reads at the first failed one (a truncated reference list's
+`unknown` is not a failed read and stops nothing, #850). A blocked batch milestone now
 reads `next=operator`, not `next=done`.
 
 Journal: `anchor-closed` (including "found already closed") and `anchor-close-failed`

package/dist/anchor-close.d.ts

@@ -21,7 +21,7 @@
  * Pure verdicts plus one idempotent effect (`closeAnchor`); everything that
  * talks to GitHub or git is injected, so tests never shell out.
  */
-import type { IssueCloseTruth } from './groundtruth';
+import { type IssueCloseTruth } from './groundtruth';
 import type { ExecFn } from './project';
 import type { BatchEntry, BatchStatus, IssueStatus, SchedState } from './types';
 /** Reads one issue's closure record; `undefined` = the poll failed (unreachable). */
@@ -66,19 +66,49 @@ export interface AnchorMemberReport {
 /**
  * The anchor-close predicate's answer. Every open-anchor verdict carries
  * `reasons` (empty for `closable`; for `unknown`, which read failed — ground
- * truth unreachable, so nothing is decided this pass).
+ * truth unreachable — or, #850, which member GitHub answered for without
+ * settling it; either way nothing is decided this pass).
  */
 export type AnchorVerdict = {
     kind: 'anchor-closed';
 } | {
-    kind: 'closable' | 'needs-operator' | 'unknown';
+    kind: 'closable' | 'needs-operator';
     reasons: string[];
     members: AnchorMemberReport[];
+} | {
+    kind: 'unknown';
+    reasons: string[];
+    members: AnchorMemberReport[];
+    /**
+     * #850: `true` when a FAILED read produced it (ground truth unreachable
+     * — a sweep stops reading); `false` when GitHub answered but could not
+     * settle a member (a truncated closing-reference list — a sweep reads
+     * on). Required, so no `unknown` can leave the question open.
+     */
+    unreachable: boolean;
 };
 /** The verdict of an anchor that is still open. */
 export type OpenAnchorVerdict = Exclude<AnchorVerdict, {
     kind: 'anchor-closed';
 }>;
+/**
+ * {@link shippingEvidence}'s answer: `shipped` (by what), `refused` (why), or —
+ * #850 — `unknown` (why GitHub's answer could not settle it).
+ */
+export type ShippingEvidence = {
+    shipped: string;
+} | {
+    refused: string;
+} | {
+    unknown: string;
+};
+/**
+ * #850: the evidence reason for a hand close whose closing-reference list is
+ * longer than the page read and holds no vouching reference on it — `unknown`,
+ * never a refusal. A re-read does not clear it (the README's anchor section
+ * gives the operator's remedy).
+ */
+export declare const REFS_TRUNCATED_REASON = "closed-by-hand-refs-truncated";
 /**
  * The verified shipping evidence for a member closed as completed, or the
  * reason it is not evidence. Only code that landed in `baseBranch` counts:
@@ -87,13 +117,11 @@ export type OpenAnchorVerdict = Exclude<AnchorVerdict, {
  * ({@link closingReferenceEvidence}) — or a commit reachable from it. A hand
  * close with no qualifying reference, an unmerged or other-base PR, and an
  * unverifiable commit are all refusals — anyone who can close the issue could
- * otherwise mint "shipped".
+ * otherwise mint "shipped". `unknown` (#850) is neither: GitHub answered, but
+ * only with the first page of a longer closing-reference list, none of which
+ * vouches — so a refusal could be wrong, and nothing is decided.
  */
-export declare function shippingEvidence(truth: IssueCloseTruth, baseBranch: string, repo: string | undefined, commitInBase: CommitInBase | undefined): {
-    shipped: string;
-} | {
-    refused: string;
-};
+export declare function shippingEvidence(truth: IssueCloseTruth, baseBranch: string, repo: string | undefined, commitInBase: CommitInBase | undefined): ShippingEvidence;
 export interface MembersVerdictOptions {
     /** Read every member even after a disqualifier (the sweep); the engine stops early. */
     exhaustive?: boolean;
@@ -121,9 +149,10 @@ export type OrphanShippingCheckOptions = ShippingCheckOptions & {
  * members-closed evidence, so the two can never disagree about what
  * "shipped" means.
  *
- * `exhaustive: false` (the engine) stops at the first disqualifying fact and
- * skips GitHub entirely when the ledger already disqualifies — a batch that
- * stays blocked is re-checked every tick, so the cheap answer matters there.
+ * `exhaustive: false` (the engine) stops at the first disqualifying fact or
+ * undecided member (#850) and skips GitHub entirely when the ledger already
+ * disqualifies — a batch that stays blocked is re-checked every tick, so the
+ * cheap answer matters there.
  * `exhaustive: true` (the `sched status --anchors` sweep) reads every member
  * so the operator sees each one's state. Either way a failed read stops the
  * reads: GitHub being unreachable is not worth N more timeouts.
@@ -171,10 +200,11 @@ export interface AnchorReportItem {
  * `sched status --anchors`' sweep (#768): every still-open anchor of a batch
  * that is no longer in flight, marked `closable` (the strict condition holds —
  * the engine will close it, within its 7-day window), `needs-operator`
- * (anything else), or `unknown` (a GitHub read failed — nothing decided),
- * with each member's state. Report-only by construction: it takes no exec for
- * writes and has no way to close anything. The first failed read stops the
- * sweep's reads; every later batch is reported `unknown` without a call.
+ * (anything else), or `unknown` (a GitHub read failed, or — #850 — a member's
+ * closing-reference list was truncated; nothing decided), with each member's
+ * state. Report-only by construction: it takes no exec for writes and has no
+ * way to close anything. The first FAILED read stops the sweep's reads; every
+ * later batch is reported `unknown` without a call.
  */
 export declare function sweepAnchors(state: SchedState, read: IssueCloseReader, opts?: ShippingCheckOptions): AnchorReportItem[];
 /**
@@ -245,9 +275,15 @@ export interface OrphanAnchorCandidate {
  * confirm, not the ledger-backed `sweepAnchors`' stronger `closable`.
  */
 export type OrphanAnchorVerdict = {
-    kind: 'orphan-closable-candidate' | 'orphan-needs-operator' | 'orphan-unknown';
+    kind: 'orphan-closable-candidate' | 'orphan-needs-operator';
+    reasons: string[];
+    members: AnchorMemberReport[];
+} | {
+    kind: 'orphan-unknown';
     reasons: string[];
     members: AnchorMemberReport[];
+    /** #850: as on {@link AnchorVerdict}'s `unknown` — `true` only when a FAILED read produced it. */
+    unreachable: boolean;
 };
 /**
  * Classify one orphan anchor candidate, or `null` when it turns out not to be
@@ -326,7 +362,8 @@ export interface OrphanAnchorSweepResult {
  * left real orphan candidates unprobed. Classifying stops at the first
  * failed member/anchor read (the same fail-closed posture as
  * `sweepAnchors`): every anchor after that point is reported `orphan-unknown`
- * without a further call.
+ * without a further call. An `orphan-unknown` from a truncated
+ * closing-reference list (#850) is not a failed read and stops nothing.
  */
 export declare function sweepOrphanAnchors(state: SchedState, list: OpenAnchorLister, read: IssueCloseReader, opts?: OrphanShippingCheckOptions): OrphanAnchorSweepResult | null;
 /**

package/dist/anchor-close.d.ts.map

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

package/dist/anchor-close.js

@@ -23,7 +23,7 @@
  * talks to GitHub or git is injected, so tests never shell out.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ORPHAN_SWEEP_MAX_ANCHORS = exports.ORPHAN_SWEEP_MAX_MEMBERS = exports.DEFAULT_BASE_BRANCH = exports.ANCHOR_CLOSE_BATCH_STATUSES = void 0;
+exports.ORPHAN_SWEEP_MAX_ANCHORS = exports.ORPHAN_SWEEP_MAX_MEMBERS = exports.DEFAULT_BASE_BRANCH = exports.REFS_TRUNCATED_REASON = exports.ANCHOR_CLOSE_BATCH_STATUSES = void 0;
 exports.openAnchorBatches = openAnchorBatches;
 exports.formatBatchStatus = formatBatchStatus;
 exports.anchorLedgerBlockers = anchorLedgerBlockers;
@@ -40,6 +40,7 @@ exports.orphanAnchorListArgs = orphanAnchorListArgs;
 exports.sweepOrphanAnchors = sweepOrphanAnchors;
 exports.batchAnchorStillOpen = batchAnchorStillOpen;
 const attribution_1 = require("./attribution");
+const groundtruth_1 = require("./groundtruth");
 const labels_1 = require("./labels");
 const state_1 = require("./state");
 /**
@@ -118,6 +119,13 @@ function anchorLedgerBlockers(state, batch) {
     }
     return [...new Set(reasons)];
 }
+/**
+ * #850: the evidence reason for a hand close whose closing-reference list is
+ * longer than the page read and holds no vouching reference on it — `unknown`,
+ * never a refusal. A re-read does not clear it (the README's anchor section
+ * gives the operator's remedy).
+ */
+exports.REFS_TRUNCATED_REASON = 'closed-by-hand-refs-truncated';
 /**
  * The verified shipping evidence for a member closed as completed, or the
  * reason it is not evidence. Only code that landed in `baseBranch` counts:
@@ -126,7 +134,9 @@ function anchorLedgerBlockers(state, batch) {
  * ({@link closingReferenceEvidence}) — or a commit reachable from it. A hand
  * close with no qualifying reference, an unmerged or other-base PR, and an
  * unverifiable commit are all refusals — anyone who can close the issue could
- * otherwise mint "shipped".
+ * otherwise mint "shipped". `unknown` (#850) is neither: GitHub answered, but
+ * only with the first page of a longer closing-reference list, none of which
+ * vouches — so a refusal could be wrong, and nothing is decided.
  */
 function shippingEvidence(truth, baseBranch, repo, commitInBase) {
     const closer = truth.closer;
@@ -154,37 +164,96 @@ function shippingEvidence(truth, baseBranch, repo, commitInBase) {
  * A hand close (no closer on the close event) is still shipped when a PR of
  * the pinned repo, MERGED into the base, names the issue as closed
  * (`Closes #N` — GitHub parsed it, then did not act: the imboard#4116 shape).
- * A merge needs write access, so an author's self-close alone never counts.
+ * Only a merged PR counts, and a merge needs write access, so an author's
+ * self-close alone never counts.
+ *
+ * The reference must also have merged inside the member's last open stretch
+ * ({@link refBound}): strictly AFTER its start — the last reopen (#799; one
+ * merged before it did not finish the issue, that is why it was reopened), or
+ * the issue's creation when it was never reopened (#850 review; a PR merged
+ * before the issue existed can only have been linked by an edit made after
+ * the fact) — and no later than its close (#850; one merged after the close
+ * did not back it). Every bound applies to every hand close; a time that
+ * cannot be read is not evidence either way: fail closed. An unreadable
+ * reopen, creation or close time refuses outright; otherwise the refusal
+ * names only the PRs failing the first bound that applies — merge time
+ * unreadable, then merged after the close, then merged before the stretch
+ * began — so a mixed list does not name every rejected PR. The remedy is a
+ * new PR or commit that closes the member, or an operator closing the anchor
+ * by hand; reopening and re-closing the member does not help (the reference
+ * then predates the reopen).
+ *
+ * The bounds are on when the PR MERGED, not on when its `Closes #N` was
+ * written: a reference edited into a PR that merged inside the stretch still
+ * vouches (#850 chose the time bound over reading when the link was made).
  *
- * #799: the reference must also have merged AFTER the member's last reopen.
- * One merged before it did not finish the issue — that is why it was
- * reopened — so it cannot vouch for the later hand close. An unreadable
- * reopen time, or an unreadable merge time after a reopen, is not evidence
- * either way: fail closed, naming the rejected PRs so the operator can see
- * which reference was stale. The remedy is a new PR or commit that closes
- * the member, or an operator closing the anchor by hand.
+ * #850: `closingPrs` is one page. With more on the next
+ * (`closingPrsTruncated`), no vouching reference on this page is `unknown`
+ * ({@link REFS_TRUNCATED_REASON}), not a refusal — one may be on the next page.
+ * A definite answer still stands: a reference on this page that vouches is
+ * shipped, and an unreadable reopen, creation or close time refuses whatever
+ * the next page holds.
  */
 function closingReferenceEvidence(truth, baseBranch, repo) {
     const refs = truth.closingPrs.filter((pr) => pr.merged &&
         pr.baseRefName === baseBranch &&
         repo !== undefined &&
         pr.repo?.toLowerCase() === repo.toLowerCase());
-    if (refs.length === 0)
+    const truncated = truth.closingPrsTruncated === true;
+    if (refs.length === 0 && !truncated)
         return { refused: 'closed-by-hand' };
-    const reopenedAt = truth.lastReopenedAt;
-    if (reopenedAt === undefined)
+    // `undefined` (an unreadable reopen timeline) parses to NaN, like garbage.
+    const reopened = truth.lastReopenedAt !== null;
+    const reopenedMs = reopened ? (0, groundtruth_1.timestampMs)(truth.lastReopenedAt) : Number.NEGATIVE_INFINITY;
+    if (Number.isNaN(reopenedMs))
         return { refused: 'closed-by-hand-reopen-unreadable' };
-    const ref = reopenedAt === null
-        ? refs[0]
-        : refs.find((pr) => pr.mergedAt !== null && Date.parse(pr.mergedAt) > Date.parse(reopenedAt));
-    if (ref !== undefined) {
-        return { shipped: `PR #${ref.number} (closing reference; issue closed by hand)` };
+    const createdMs = (0, groundtruth_1.timestampMs)(truth.createdAt);
+    if (Number.isNaN(createdMs))
+        return { refused: 'closed-by-hand-created-time-unreadable' };
+    const closedMs = (0, groundtruth_1.timestampMs)(truth.closedAt);
+    if (Number.isNaN(closedMs))
+        return { refused: 'closed-by-hand-close-time-unreadable' };
+    const stretch = { openedMs: Math.max(createdMs, reopenedMs), closedMs };
+    const bounds = refs.map((pr) => ({ pr, bound: refBound(pr, stretch) }));
+    const vouching = bounds.find((b) => b.bound === 'vouches');
+    if (vouching !== undefined) {
+        return { shipped: `PR #${vouching.pr.number} (closing reference; issue closed by hand)` };
     }
-    const prs = (list) => list.map((pr) => pr.number).join('+');
-    const untimed = refs.filter((pr) => pr.mergedAt === null);
-    return untimed.length > 0
-        ? { refused: `closed-by-hand-ref-pr-${prs(untimed)}-merge-time-unreadable` }
-        : { refused: `closed-by-hand-ref-pr-${prs(refs)}-predates-reopen` };
+    if (truncated)
+        return { unknown: exports.REFS_TRUNCATED_REASON };
+    // `refs` is non-empty here and none vouches, so some refusal bound applies;
+    // the `??` only satisfies the type checker.
+    const failed = REFUSAL_BOUND_ORDER.find((o) => bounds.some((b) => b.bound === o)) ?? 'predates-open';
+    const prs = bounds
+        .filter((b) => b.bound === failed)
+        .map((b) => b.pr.number)
+        .join('+');
+    const why = failed !== 'predates-open'
+        ? failed
+        : reopenedMs > createdMs
+            ? 'predates-reopen'
+            : 'predates-issue';
+    return { refused: `closed-by-hand-ref-pr-${prs}-${why}` };
+}
+/** The refusal bounds in the order {@link closingReferenceEvidence} names them. */
+const REFUSAL_BOUND_ORDER = [
+    'merge-time-unreadable',
+    'postdates-close',
+    'predates-open',
+];
+/**
+ * Whether `pr` merged inside the stretch `(openedMs, closedMs]`, or which
+ * bound it fails. The merge time goes through the ground truth's one
+ * timestamp rule ({@link timestampMs}), so a missing or loose time can never
+ * pass a bound — even from an `IssueCloseTruth` the parser did not build.
+ */
+function refBound(pr, stretch) {
+    const mergedMs = (0, groundtruth_1.timestampMs)(pr.mergedAt);
+    if (Number.isNaN(mergedMs))
+        return 'merge-time-unreadable';
+    if (mergedMs > stretch.closedMs)
+        return 'postdates-close';
+    return mergedMs > stretch.openedMs ? 'vouches' : 'predates-open';
 }
 /**
  * The blank `AnchorMemberReport` skeleton shared by {@link membersShippedVerdict}'s
@@ -214,7 +283,8 @@ function unreadMemberReports(members, ledgerStatus) {
  * can reuse the identical shipping-evidence logic for a batch that, by
  * definition, has no ledger entry to consult.
  *
- * `exhaustive: false` stops at the first disqualifying fact; `exhaustive:
+ * `exhaustive: false` stops at the first disqualifying fact — or undecided
+ * member (#850): either way the batch is not closable this pass; `exhaustive:
  * true` reads every member so the operator sees each one's state. Either way
  * a failed read stops the reads: GitHub being unreachable is not worth N
  * more timeouts.
@@ -222,11 +292,12 @@ function unreadMemberReports(members, ledgerStatus) {
 function readMembersShipping(members, read, baseBranch, opts, ledgerStatus) {
     const reports = unreadMemberReports(members, ledgerStatus);
     const reasons = [];
-    let unreachable = null;
+    const undecided = [];
+    let unreachableIssue = null;
     for (const member of reports) {
         const truth = read(member.issue);
         if (truth === undefined) {
-            unreachable = member.issue;
+            unreachableIssue = member.issue;
             break;
         }
         if (truth.state === 'MISSING') {
@@ -248,16 +319,18 @@ function readMembersShipping(members, read, baseBranch, opts, ledgerStatus) {
             const evidence = shippingEvidence(truth, baseBranch, opts.repo, opts.commitInBase);
             if ('shipped' in evidence)
                 member.shipped_by = evidence.shipped;
-            else
+            else if ('refused' in evidence)
                 reasons.push(`member-${evidence.refused}:#${member.issue}`);
+            else
+                undecided.push(`member-${evidence.unknown}:#${member.issue}`);
         }
         if ((0, labels_1.hasLabel)(truth.labels, labels_1.DECISION_PENDING_LABEL)) {
             reasons.push(`member-handed-back:#${member.issue}`);
         }
-        if (reasons.length > 0 && !opts.exhaustive)
+        if ((reasons.length > 0 || undecided.length > 0) && !opts.exhaustive)
             break;
     }
-    return { reasons, members: reports, unreachable };
+    return { reasons, undecided, members: reports, unreachableIssue };
 }
 /**
  * The member half of the predicate: every member CLOSED as `COMPLETED` by
@@ -266,9 +339,10 @@ function readMembersShipping(members, read, baseBranch, opts, ledgerStatus) {
  * members-closed evidence, so the two can never disagree about what
  * "shipped" means.
  *
- * `exhaustive: false` (the engine) stops at the first disqualifying fact and
- * skips GitHub entirely when the ledger already disqualifies — a batch that
- * stays blocked is re-checked every tick, so the cheap answer matters there.
+ * `exhaustive: false` (the engine) stops at the first disqualifying fact or
+ * undecided member (#850) and skips GitHub entirely when the ledger already
+ * disqualifies — a batch that stays blocked is re-checked every tick, so the
+ * cheap answer matters there.
  * `exhaustive: true` (the `sched status --anchors` sweep) reads every member
  * so the operator sees each one's state. Either way a failed read stops the
  * reads: GitHub being unreachable is not worth N more timeouts.
@@ -285,8 +359,9 @@ function membersShippedVerdict(state, batch, read, opts = {}) {
         };
     }
     const gh = readMembersShipping(batch.members, read, batch.base_branch, { exhaustive, repo: opts.repo, commitInBase: opts.commitInBase }, ledgerStatus);
-    // A known disqualifier outranks an unreachable read: whatever the missing
-    // poll would have said, the batch is not closable on this pass.
+    // A known disqualifier outranks an unreachable read or an undecided member
+    // (#850): whatever the missing poll or the unread reference page would have
+    // said, the batch is not closable on this pass.
     return foldMembersVerdict(ledgerReasons, gh, {
         needsOperator: 'needs-operator',
         unknown: 'unknown',
@@ -298,23 +373,39 @@ function membersShippedVerdict(state, batch, read, opts = {}) {
  * {@link classifyOrphanAnchor} (#830): both fold `prefixReasons` (reasons
  * already known before {@link readMembersShipping} ran — ledger blockers for
  * one, the anchor's own handed-back check for the other) together with `gh`'s
- * per-member reasons and unreachable-read signal into the SAME three-way
- * verdict shape — differing only in which kind-name vocabulary each caller
- * uses (`needs-operator`/`unknown`/`closable` vs the ledger-less orphan
- * sweep's own `orphan-*` names, kept deliberately distinct — see
- * {@link OrphanAnchorVerdict}).
+ * per-member reasons, undecided members and unreachable-read signal into the
+ * SAME three-way verdict shape — differing only in which kind-name vocabulary
+ * each caller uses (`needs-operator`/`unknown`/`closable` vs the ledger-less
+ * orphan sweep's own `orphan-*` names, kept deliberately distinct — see
+ * {@link OrphanAnchorVerdict}). A known disqualifier outranks both kinds of
+ * `unknown`, but what could not be settled still rides along after it — each
+ * undecided member, then a failed read — so an exhaustive sweep's row names
+ * every member it could not settle. Only an `unknown` a failed read produced
+ * is `unreachable` (#850); a needs-operator verdict never is, so a sweep
+ * reads on past it (the #790 ruling).
  */
 function foldMembersVerdict(prefixReasons, gh, kinds) {
     const reasons = [...prefixReasons, ...gh.reasons];
-    if (reasons.length > 0)
-        return { kind: kinds.needsOperator, reasons, members: gh.members };
-    if (gh.unreachable !== null) {
+    const failedRead = gh.unreachableIssue === null ? [] : [`issue #${gh.unreachableIssue} unreachable`];
+    if (reasons.length > 0) {
+        return {
+            kind: kinds.needsOperator,
+            reasons: [...reasons, ...gh.undecided, ...failedRead],
+            members: gh.members,
+        };
+    }
+    if (failedRead.length > 0) {
         return {
             kind: kinds.unknown,
-            reasons: [`issue #${gh.unreachable} unreachable`],
+            reasons: [...gh.undecided, ...failedRead],
             members: gh.members,
+            unreachable: true,
         };
     }
+    // #850: every read answered, but not every answer settled its member.
+    if (gh.undecided.length > 0) {
+        return { kind: kinds.unknown, reasons: gh.undecided, members: gh.members, unreachable: false };
+    }
     return { kind: kinds.closable, reasons: [], members: gh.members };
 }
 function anchorGroundVerdict(read, anchorIssue) {
@@ -343,8 +434,9 @@ function classifyAnchor(state, batch, read, opts = {}) {
     if (ground.kind === 'anchor-missing') {
         return { kind: 'needs-operator', reasons: ['anchor-missing'], members: [] };
     }
-    if (ground.kind === 'unknown')
-        return { kind: 'unknown', reasons: ground.reasons, members: [] };
+    if (ground.kind === 'unknown') {
+        return { kind: 'unknown', reasons: ground.reasons, members: [], unreachable: true };
+    }
     const extraReasons = ground.handedBack ? ['anchor-handed-back'] : [];
     return membersShippedVerdict(state, batch, read, { ...opts, extraReasons });
 }
@@ -416,24 +508,28 @@ function closeAnchor(exec, repoDir, repo, batch, anchorIssue, members) {
         ? 'close-failed'
         : 'closed';
 }
+/** The reason on every candidate a sweep reports without reading, after a failed read. */
+const SWEEP_ABORTED_REASON = 'GitHub unreachable — sweep aborted';
 /**
  * The fail-closed sweep loop shared by {@link sweepAnchors} and
  * {@link sweepOrphanAnchors} (#830): classify each candidate in order via
  * `classify`, which returns `null` to SKIP a candidate entirely (both sweeps
  * hit this on the same list-then-read race — the anchor closed between the
- * list and this read). Once a classified verdict's `kind` is `unknownKind`,
- * every LATER candidate is reported `abortedVerdict` WITHOUT calling
+ * list and this read). Once a classified verdict is `unreachable` (a read
+ * failed), every LATER candidate is reported `abortedVerdict` WITHOUT calling
  * `classify` again — GitHub being unreachable is not worth N more timeouts,
- * and a partial outage must never look like "the rest are clean".
+ * and a partial outage must never look like "the rest are clean". An
+ * `unknown` GitHub answered but could not settle (#850) is no outage: the
+ * sweep reads on, so it never reports later batches as unreachable.
  */
-function sweepFailClosed(candidates, unknownKind, abortedVerdict, classify, toItem) {
+function sweepFailClosed(candidates, abortedVerdict, classify, toItem) {
     const items = [];
     let aborted = false;
     for (const candidate of candidates) {
         const verdict = aborted ? abortedVerdict : classify(candidate);
         if (verdict === null)
             continue;
-        if (verdict.kind === unknownKind)
+        if (verdict.unreachable === true)
             aborted = true;
         items.push(toItem(candidate, verdict));
     }
@@ -443,13 +539,14 @@ function sweepFailClosed(candidates, unknownKind, abortedVerdict, classify, toIt
  * `sched status --anchors`' sweep (#768): every still-open anchor of a batch
  * that is no longer in flight, marked `closable` (the strict condition holds —
  * the engine will close it, within its 7-day window), `needs-operator`
- * (anything else), or `unknown` (a GitHub read failed — nothing decided),
- * with each member's state. Report-only by construction: it takes no exec for
- * writes and has no way to close anything. The first failed read stops the
- * sweep's reads; every later batch is reported `unknown` without a call.
+ * (anything else), or `unknown` (a GitHub read failed, or — #850 — a member's
+ * closing-reference list was truncated; nothing decided), with each member's
+ * state. Report-only by construction: it takes no exec for writes and has no
+ * way to close anything. The first FAILED read stops the sweep's reads; every
+ * later batch is reported `unknown` without a call.
  */
 function sweepAnchors(state, read, opts = {}) {
-    return sweepFailClosed(openAnchorBatches(state, SWEEP_BATCH_STATUSES), 'unknown', { kind: 'unknown', reasons: ['GitHub unreachable — sweep aborted'], members: [] }, (batch) => {
+    return sweepFailClosed(openAnchorBatches(state, SWEEP_BATCH_STATUSES), { kind: 'unknown', reasons: [SWEEP_ABORTED_REASON], members: [], unreachable: true }, (batch) => {
         const verdict = classifyAnchor(state, batch, read, { exhaustive: true, ...opts });
         return verdict.kind === 'anchor-closed' ? null : verdict;
     }, (batch, verdict) => ({
@@ -569,7 +666,7 @@ function classifyOrphanAnchor(candidate, read, opts = {}) {
         return { kind: 'orphan-needs-operator', reasons: ['anchor-missing'], members: [] };
     }
     if (ground.kind === 'unknown') {
-        return { kind: 'orphan-unknown', reasons: ground.reasons, members: [] };
+        return { kind: 'orphan-unknown', reasons: ground.reasons, members: [], unreachable: true };
     }
     if (candidate.members.length === 0) {
         return { kind: 'orphan-needs-operator', reasons: ['no-members-recovered'], members: [] };
@@ -651,7 +748,8 @@ exports.ORPHAN_SWEEP_MAX_ANCHORS = 20;
  * left real orphan candidates unprobed. Classifying stops at the first
  * failed member/anchor read (the same fail-closed posture as
  * `sweepAnchors`): every anchor after that point is reported `orphan-unknown`
- * without a further call.
+ * without a further call. An `orphan-unknown` from a truncated
+ * closing-reference list (#850) is not a failed read and stops nothing.
  */
 function sweepOrphanAnchors(state, list, read, opts = {}) {
     const anchors = list();
@@ -660,7 +758,7 @@ function sweepOrphanAnchors(state, list, read, opts = {}) {
     const ledgerAnchors = new Set(state.batches.map((b) => b.anchor).filter((a) => a !== null));
     const orphanCandidates = anchors.filter((issue) => !ledgerAnchors.has(issue.number));
     const truncated = orphanCandidates.length > exports.ORPHAN_SWEEP_MAX_ANCHORS;
-    const items = sweepFailClosed(orphanCandidates.slice(0, exports.ORPHAN_SWEEP_MAX_ANCHORS), 'orphan-unknown', { kind: 'orphan-unknown', reasons: ['GitHub unreachable — sweep aborted'], members: [] }, (issue) => {
+    const items = sweepFailClosed(orphanCandidates.slice(0, exports.ORPHAN_SWEEP_MAX_ANCHORS), { kind: 'orphan-unknown', reasons: [SWEEP_ABORTED_REASON], members: [], unreachable: true }, (issue) => {
         const { members, base_branch, members_over_cap } = parseOrphanAnchorBody(issue.body);
         return classifyOrphanAnchor({ anchor: issue.number, members, base_branch, members_over_cap }, read, opts);
     }, (issue, verdict) => ({