dorfl 0.0.0 → 0.1.0

package/dist/continue-branch.js

@@ -0,0 +1,389 @@
+import { run } from './git.js';
+/**
+ * The **continue-detection** shared by BOTH onboarding paths (the keystone of
+ * the `requeue-continue-and-reset` task). `requeue` keeps the `work/<slug>`
+ * branch so the NEXT claim CONTINUES from its tip instead of force-cutting a
+ * fresh branch off main. This module factors the one question both onboarding
+ * paths must ask — **"does the arbiter have a `work/<slug>` ref AHEAD of
+ * main?"** — into ONE helper, plus the rebase-onto-fresh-main step the continued
+ * branch needs at onboard-time (ADR §10: rebase-or-abort, never auto-resolve →
+ * conflict routes to needs-attention; the agent builds on a CURRENT base).
+ *
+ * The two onboarding paths reference the same two refs differently:
+ *   - **in-place** (`src/start.ts` `switchToWorkBranch`, used by
+ *     `do`/`start`/`work-on`): a normal clone. After `git fetch <arbiter>` the
+ *     branch is the remote-tracking ref `<arbiter>/work/<slug>` and main is
+ *     `<arbiter>/main`.
+ *   - **job-worktree** (`src/workspace.ts` `createJob`, used by
+ *     `do --remote`/`run`): a BARE hub mirror. `ensureMirror` fetches
+ *     `+refs/heads/*:refs/heads/*`, so the arbiter's `work/<slug>` lands as a
+ *     LOCAL head `work/<slug>` and main is the local head `main`.
+ *
+ * Both call {@link branchAheadOf} with the appropriate ref names; the predicate
+ * is identical (ref exists AND is not an ancestor of main, i.e. it carries
+ * commits beyond main — the prior attempt's work to continue from). When the
+ * branch is ABSENT (the common case: a fresh task, or a `requeue --reset` that
+ * deleted it) the predicate is false and the caller falls through to the normal
+ * fresh-cut-off-main path with NO special logic.
+ */
+/** Run git, returning the raw result (no throw) — for soft checks. */
+function gitSoft(args, cwd, env) {
+    return run('git', args, cwd, { env });
+}
+/**
+ * True iff the git ref `branchRef` exists in `cwd` AND its tip is NOT an
+ * ancestor of `mainRef` — i.e. it carries commits beyond main (the prior
+ * attempt's work a `requeue` kept, to be continued). False when the ref is
+ * absent (nothing to continue → fresh cut) or already merged into main (no work
+ * beyond main → nothing to continue). Read-only; never throws.
+ *
+ * Both onboarding paths feed this ONE predicate with their own ref names:
+ *   - in-place clone:   branchRef=`<arbiter>/work/<slug>`, mainRef=`<arbiter>/main`
+ *   - bare hub mirror:  branchRef=`work/<slug>`,           mainRef=`main`
+ */
+export function branchAheadOf(cwd, branchRef, mainRef, env) {
+    const tip = gitSoft(['rev-parse', '--verify', '--quiet', `${branchRef}^{commit}`], cwd, env).stdout.trim();
+    if (tip === '') {
+        return false; // the branch is not on the arbiter → fresh cut, no continue
+    }
+    const mainTip = gitSoft(['rev-parse', '--verify', '--quiet', `${mainRef}^{commit}`], cwd, env).stdout.trim();
+    if (mainTip === '') {
+        // No main to compare against (shouldn't happen): treat as ahead so the kept
+        // branch is continued rather than silently dropped.
+        return true;
+    }
+    // Ahead ⇔ the branch tip is NOT an ancestor of main (it has commits main lacks).
+    const isAncestor = gitSoft(['merge-base', '--is-ancestor', tip, mainTip], cwd, env).status ===
+        0;
+    return !isAncestor;
+}
+/**
+ * Arbiter-authoritative continue-detection: like {@link branchAheadOf}, but
+ * first asks the arbiter (`git ls-remote <arbiterRemote> refs/heads/<branch>`)
+ * whether the kept branch EXISTS — so a STALE local remote-tracking ref
+ * (`refs/remotes/<arbiter>/<branch>` or a bare mirror's `refs/heads/<branch>`)
+ * pointing at a branch already DELETED on the arbiter (by `requeue --reset`, by
+ * the merge-reap, or cross-machine by `gc --remote-branches`) can no longer
+ * fool the onboard into "continue". This is the READ-side backstop that pairs
+ * with the WRITE-side write-through ordering at every delete site
+ * (local-ref-first, then `git push <arbiter> --delete`): write-through keeps
+ * SAME-MACHINE state in sync at the source; this catches the CROSS-MACHINE
+ * residue at the read (the other machine cannot touch this machine's local
+ * tracking refs). A plain `git remote prune` does NOT cover this — verified a
+ * no-op on the bare hub mirror, which has no `remote.origin.fetch` refspec for
+ * the orphaned `refs/remotes/origin/*` namespace.
+ *
+ * The decision rules, in order:
+ *   - `git ls-remote <arbiterRemote> refs/heads/<branch>` exits 0 with EMPTY
+ *     stdout (branch absent on the arbiter) ⇒ NOT ahead (fresh cut). This is
+ *     the bug-fix case: a stale local ref CANNOT override the arbiter's truth.
+ *   - `ls-remote` exits 0 with a sha ⇒ delegate to {@link branchAheadOf} on
+ *     the local refs (the existing predicate: ref exists AND not an ancestor
+ *     of main). The arbiter-present case is the normal continue path.
+ *   - `ls-remote` exits non-zero (unreachable arbiter / offline) ⇒ fall back
+ *     to {@link branchAheadOf} on the local refs — the best the read can do
+ *     when the arbiter cannot answer (same direction as today).
+ *
+ * `branch` is the unqualified branch name on the arbiter (e.g.
+ * `work/task-<slug>`); `branchRef` + `mainRef` are the local refs the
+ * arbiter-present delegate uses (in-place clone: `<arbiter>/<branch>` /
+ * `<arbiter>/main`; bare hub mirror: `<branch>` / `main`). `arbiterRemote` is
+ * the remote NAME to ls-remote (e.g. `origin` for the mirror, `arbiter` for an
+ * in-place clone with the conventional remote name).
+ */
+export function branchAheadOfArbiter(options) {
+    const { cwd, arbiterRemote, branch, branchRef, mainRef, env } = options;
+    const ls = gitSoft(['ls-remote', '--heads', arbiterRemote, branch], cwd, env);
+    if (ls.status === 0) {
+        // Reachable arbiter: its answer is AUTHORITATIVE. Empty ⇒ branch absent
+        // ⇒ no continue (a stale local ref cannot resurrect a deleted branch).
+        if (ls.stdout.trim() === '') {
+            return false;
+        }
+        // Present on the arbiter ⇒ use the existing local-ref predicate to decide
+        // ahead-of-main (which is how "there is work to continue" is defined).
+        return branchAheadOf(cwd, branchRef, mainRef, env);
+    }
+    // Unreachable arbiter / offline — fall back to the local-ref answer (the
+    // best the read can do when the arbiter cannot answer; same direction as
+    // before this backstop existed).
+    return branchAheadOf(cwd, branchRef, mainRef, env);
+}
+/**
+ * Rebase the CURRENTLY-CHECKED-OUT continued `work/<slug>` branch onto
+ * `mainRef` (the freshly-fetched main), so the agent builds on a CURRENT base
+ * (ADR §10: rebase, NOT merge — linear history; the prior attempt's commits were
+ * based on an OLD main that moved while the item sat in backlog).
+ *
+ * This is a PLAIN rebase. After the per-item-lock cut-over (prd
+ * `ledger-status-per-item-lock-refs`, tasks 9a–9d) NO transient status lands on
+ * a work branch: claim does not move the body (it rests in `backlog/`),
+ * needs-attention is the lock `state: stuck` (not a `git mv`), and the
+ * tasking/advancing markers are gone. So a branch cut from `main` inherits no
+ * runner-authored move-only bookkeeping commit, there is nothing to drop, and
+ * the old `drop-bookkeeping-rebase` machinery (which papered over the
+ * rename/rename ledger conflict that inheritance caused) is deleted. The ONLY
+ * commits replayed are the agent's own wip / `→done` commits.
+ *
+ * A CLEAN rebase returns `{kind: 'clean'}`; a CONFLICTING rebase (a GENUINE code
+ * conflict) is `--abort`ed (NEVER auto-resolved) and returns `{kind: 'conflict'}`
+ * so the caller can route the item to needs-attention via the §10 path. Must be
+ * called while HEAD is the continued branch.
+ *
+ * RENAME-DETECTION-OFF (task `disable-rename-detection-on-continue-rebase`): the
+ * rebase is invoked with `-c merge.directoryRenames=false` SCOPED to the
+ * invocation (never a persistent `git config` write), so a single durable
+ * folder-transition `git mv` out of a SPARSE source folder is NOT misread by
+ * git's directory-rename heuristic as a whole-DIRECTORY rename — which would
+ * spuriously flag every sibling file main added into that same folder as
+ * `CONFLICT (file location)` and force a FALSE needs-attention. Content-rename
+ * detection (`-Xno-renames` / `merge.renames` / `diff.renames`) is NOT what
+ * controls this conflict and was empirically verified ineffective; only
+ * `merge.directoryRenames=false` suppresses it. A GENUINE same-path content
+ * conflict still conflicts unchanged.
+ */
+export function rebaseContinuedBranchOntoMain(cwd, mainRef, env) {
+    const rebase = gitSoft(['-c', 'merge.directoryRenames=false', 'rebase', mainRef], cwd, env);
+    if (rebase.status === 0) {
+        return { kind: 'clean' };
+    }
+    // NEVER auto-resolve: abort back to a clean continued-branch tip.
+    gitSoft(['rebase', '--abort'], cwd, env);
+    return { kind: 'conflict' };
+}
+/**
+ * The default cap on stale-lease push retries — mirrors the claim / tasking-lock
+ * INSTANT-contention loop's `retries: 3` default (`claim-cas.ts` `DEFAULT_RETRIES`).
+ * After this many re-fetch + re-rebase + re-push attempts the green work is left
+ * RECOVERABLE and the caller surfaces a clear terminal failure.
+ */
+export const DEFAULT_STALE_LEASE_RETRIES = 3;
+/**
+ * Lexical signal of a `--force-with-lease` STALE-LEASE rejection (git prints
+ * `! [rejected] <ref> (stale info)`), as distinct from any OTHER push failure
+ * (connectivity, auth, a protected ref). ONLY this case is safe to re-lease +
+ * retry on the UNSHARED work branch — every other failure must surface, never
+ * silently overwrite. This is the SAME family of contention markers the
+ * ledger-write CAS recognises (`ledger-write.ts`), narrowed here to the lease's
+ * own `stale info`.
+ */
+export function isStaleLeaseRejection(stderr) {
+    return /stale info/i.test(stderr);
+}
+/**
+ * Push the propose-mode work branch with the SAME stale-lease retry semantics
+ * as {@link pushContinuedBranchWithStaleLeaseRetry} (explicit
+ * `--force-with-lease=<branch>:<expectedTip>`, `stale info` detection, bounded
+ * re-observation + retry, terminal throw on cap exhaustion / non-stale
+ * failure), plus the one race the continue path does not have: a `work/<slug>`
+ * ref that is GONE on the arbiter because the work already LANDED on `main` is
+ * a BENIGN already-landed success, not a failure. The predicate mirrors the
+ * leased-delete `already-reaped` + merged-head-reap ancestor guards: gone ref
+ * AND `HEAD` is an ancestor of `<arbiter>/main`.
+ *
+ * WHY a propose-specific helper instead of the continue helper verbatim: the
+ * continue helper's stale-lease retry RE-REBASES the kept branch onto the
+ * freshly-fetched main (a kept-branch onboard's job — main may have moved
+ * while the prior attempt sat in backlog). In the propose path the caller has
+ * ALREADY rebased the branch onto `<arbiter>/main` (`integrateWithRebase`, or
+ * `integration-core.ts` `recoverAlreadyCommitted`'s recovery rebase), so the
+ * only race the lease needs to survive here is the remote work ref MOVING /
+ * REAPING under us — re-leasing against the freshly-observed tip is enough,
+ * AND a re-rebase mid-integrate would smuggle a NEW rebase past
+ * `integrateWithRebase`'s explicit conflict-aborts-to-needs-attention contract.
+ * So this helper shares the stale-info detection + bounded retry shape (the
+ * `--force-with-lease`-only / never-bare-force / never-`:main` guardrails are
+ * identical) but does NOT layer the rebase step.
+ *
+ * Guardrails (ADR §11): `--force-with-lease` ONLY (re-computed each attempt),
+ * NEVER bare `--force`, NEVER `:main`, the WORK branch ONLY. The lease is
+ * threaded as `<branch>:<expectedTip>` — using EMPTY (`<branch>:`) when the
+ * arbiter has no ref yet (the first-time propose / post-reap shape — the same
+ * create-only lease form `item-lock.ts` uses for the lock CAS), so a bare-hub-
+ * mirror worktree (no `refs/remotes/<arbiter>/*` upstream) leases correctly.
+ *
+ * Bounded by `retries` (default {@link DEFAULT_STALE_LEASE_RETRIES}, mirroring
+ * the claim / continue retry cap). Must be called while HEAD is the propose
+ * `<branch>`.
+ */
+export function pushProposeBranchWithStaleLeaseRetry(options) {
+    const { cwd, branch, arbiter, env } = options;
+    const note = options.note ?? (() => { });
+    const retries = options.retries ?? DEFAULT_STALE_LEASE_RETRIES;
+    const mainRef = `refs/remotes/${arbiter}/main`;
+    const refreshMain = () => {
+        gitSoft(['fetch', '--quiet', arbiter, `+refs/heads/main:${mainRef}`], cwd, env);
+    };
+    /** The arbiter's CURRENT `<branch>` sha (via `ls-remote`), or `''` when absent / unreachable. */
+    const observeArbiterTip = () => {
+        const ls = gitSoft(['ls-remote', '--heads', arbiter, branch], cwd, env);
+        if (ls.status !== 0)
+            return '';
+        const m = /^([0-9a-f]{40})/m.exec(ls.stdout.trim());
+        return m ? m[1] : '';
+    };
+    /** True iff HEAD is provably reachable from `<arbiter>/main` (the work landed). */
+    const headOnArbiterMain = () => {
+        const head = gitSoft(['rev-parse', '--verify', '--quiet', 'HEAD'], cwd, env).stdout.trim();
+        if (head === '')
+            return false;
+        return (gitSoft(['merge-base', '--is-ancestor', head, mainRef], cwd, env)
+            .status === 0);
+    };
+    /**
+     * The BENIGN already-landed predicate: the remote work ref is GONE on the
+     * arbiter AND our HEAD is provably reachable from `<arbiter>/main`. Mirrors
+     * `integrator.ts` `deleteMergedHeadBranch`'s ancestor-guarded reap + the
+     * `item-lock.ts` leased-delete `already-reaped` precedent: a vanished ref
+     * whose work is provably landed is the desired end state. Re-fetches main
+     * first so the answer reflects the current arbiter, not a stale local view.
+     */
+    const benignAlreadyLanded = () => {
+        refreshMain();
+        return observeArbiterTip() === '' && headOnArbiterMain();
+    };
+    // Short-circuit BEFORE any push: the dominant recovery race shape (a sibling
+    // already merged this work and reaped the head before we even attempted our
+    // push). Avoids burning a stale-lease retry budget on a no-op.
+    if (benignAlreadyLanded()) {
+        note(`${branch}: already landed on ${arbiter}/main + remote head reaped — ` +
+            'clean no-op (no push, no review request).');
+        return { kind: 'already-landed' };
+    }
+    let attempt = 0;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const observed = observeArbiterTip();
+        // Explicit `<branch>:<expected>` — EMPTY when the ref is absent (first-time
+        // propose, or a post-reap retry), MATCHING when present. The empty-expected
+        // shape is the same create-only `--force-with-lease=<ref>:` form
+        // `item-lock.ts` uses for the CAS create.
+        const lease = observed === '' ? `${branch}:` : `${branch}:${observed}`;
+        const push = gitSoft(['push', arbiter, `${branch}:${branch}`, `--force-with-lease=${lease}`], cwd, env);
+        if (push.status === 0) {
+            return { kind: 'pushed' };
+        }
+        // Only `stale info` is re-leasable on this unshared work branch; every
+        // other failure (connectivity, protected ref, auth) SURFACES at once.
+        if (!isStaleLeaseRejection(push.stderr)) {
+            throw new Error(`pushing ${branch} to ${arbiter} failed (not a stale lease): ` +
+                (push.stderr.trim() || `exit ${push.status}`));
+        }
+        // A stale lease: re-check the BENIGN already-landed predicate first (the
+        // race tail this task carries), else retry with a freshly-observed lease.
+        if (benignAlreadyLanded()) {
+            note(`${branch}: stale lease + work already on ${arbiter}/main + remote ` +
+                'head reaped — clean no-op.');
+            return { kind: 'already-landed' };
+        }
+        attempt += 1;
+        if (attempt > retries) {
+            throw new Error(`pushing ${branch} to ${arbiter} kept failing with a stale ` +
+                `--force-with-lease after ${retries} retr${retries === 1 ? 'y' : 'ies'} ` +
+                '(the arbiter work ref keeps moving under us, and the work is not ' +
+                `provably on main). The green work is still committed on ${branch} — ` +
+                'route to needs-attention and retry when the churn settles.');
+        }
+        note(`${branch} propose push rejected (stale lease) — re-observe + retry ` +
+            `(${attempt}/${retries})...`);
+    }
+}
+/**
+ * Push the CONTINUED `work/<slug>` branch to the arbiter with
+ * `--force-with-lease`, surviving a STALE-LEASE ("stale info") rejection by
+ * re-observing the arbiter's tip and replaying our green work onto it — instead
+ * of stranding a committed, gate-green build in the job worktree (the observed
+ * `advance-verb-resolver` incident).
+ *
+ * WHY a retry is SAFE here: the `work/<slug>` branch is UNSHARED — the arbiter
+ * CAS serialises the claim per slug, so no rival writer legitimately advances it
+ * concurrently. The lease's job is to catch a STALE LOCAL view, not a rival; so
+ * on a stale-lease rejection the correct response is to re-fetch the actual
+ * remote tip, rebase our work onto current main, and push again, re-leased
+ * against the JUST-fetched ref. This stays within the existing guardrails:
+ * `--force-with-lease` ONLY (re-computed each attempt), NEVER bare `--force`,
+ * NEVER targeting `main`, the WORK branch ONLY (ADR §11).
+ *
+ * The flow, bounded by `retries` (default {@link DEFAULT_STALE_LEASE_RETRIES},
+ * mirroring the claim/tasking-lock instant-contention cap):
+ *   1. Push `<branch>:<branch> --force-with-lease=<branch>:<expectedRemoteTip>`.
+ *   2. On success → `{kind: 'pushed'}`.
+ *   3. On a STALE-LEASE rejection → re-fetch `main` + `<branch>` from the arbiter
+ *      (into a remote-tracking ref, since the branch is CHECKED OUT here), re-run
+ *      the onboard-time rebase onto the freshly-fetched main, and retry with the
+ *      lease re-leased against the freshly-fetched remote tip. A rebase CONFLICT
+ *      on a retry → `{kind: 'conflict'}` (the existing abort → needs-attention
+ *      path; the retry covers ONLY the clean-rebase stale-lease case).
+ *   4. After the cap → THROW a clear terminal error (the green work is still
+ *      committed on the branch, so the caller's needs-attention route keeps it
+ *      recoverable).
+ *   5. Any NON-stale push failure (connectivity, protected ref) → THROW at once
+ *      (never re-leased, never silently swallowed).
+ *
+ * `expectedRemoteTip` is the arbiter `work/<slug>` sha the caller already
+ * observed (the pre-rebase mirror head). The explicit `<branch>:<sha>` lease is
+ * REQUIRED in the bare-hub-mirror worktree, which has no `refs/remotes/origin/*`
+ * upstream for git to imply the lease from. Must be called while HEAD is the
+ * continued `<branch>`.
+ */
+export function pushContinuedBranchWithStaleLeaseRetry(options) {
+    const { cwd, branch, arbiter, mainRef, env } = options;
+    const note = options.note ?? (() => { });
+    const retries = options.retries ?? DEFAULT_STALE_LEASE_RETRIES;
+    // The remote-tracking ref we re-fetch the arbiter `<branch>` into so the lease
+    // can be re-computed WITHOUT touching the checked-out local `<branch>` head
+    // (git refuses to fetch into a checked-out branch).
+    const trackingRef = `refs/remotes/${arbiter}/${branch}`;
+    let expectedTip = options.expectedRemoteTip;
+    let attempt = 0;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const push = gitSoft([
+            'push',
+            arbiter,
+            `${branch}:${branch}`,
+            `--force-with-lease=${branch}:${expectedTip}`,
+        ], cwd, env);
+        if (push.status === 0) {
+            return { kind: 'pushed' };
+        }
+        // Only a STALE-LEASE rejection is re-leasable on this unshared branch; any
+        // other failure (connectivity, protected ref) surfaces immediately.
+        if (!isStaleLeaseRejection(push.stderr)) {
+            throw new Error(`pushing ${branch} to ${arbiter} failed (not a stale lease): ` +
+                (push.stderr.trim() || `exit ${push.status}`));
+        }
+        attempt += 1;
+        if (attempt > retries) {
+            throw new Error(`pushing ${branch} to ${arbiter} kept failing with a stale ` +
+                `--force-with-lease after ${retries} retr${retries === 1 ? 'y' : 'ies'} ` +
+                '(the arbiter work ref keeps moving under us). The green work is ' +
+                `still committed on ${branch} — route to needs-attention and retry ` +
+                'when the churn settles.');
+        }
+        note(`${branch} push rejected (stale lease) — re-fetch + re-rebase + retry ` +
+            `(${attempt}/${retries})...`);
+        // Re-observe the arbiter: refresh local `main` (NOT checked out → fetch into
+        // its head) and the arbiter `<branch>` (CHECKED OUT → fetch into a
+        // remote-tracking ref so the lease can re-compute against it).
+        gitSoft([
+            'fetch',
+            arbiter,
+            `+refs/heads/main:${mainRef}`,
+            `+refs/heads/${branch}:${trackingRef}`,
+        ], cwd, env);
+        const fresh = gitSoft(['rev-parse', '--verify', '--quiet', trackingRef], cwd, env).stdout.trim();
+        if (fresh !== '') {
+            expectedTip = fresh;
+        }
+        // Replay our green work onto the freshly-fetched main (ADR §10: rebase, not
+        // merge). A CONFLICT is the EXISTING abort → needs-attention path — the retry
+        // handles ONLY the clean-rebase stale-lease case (never auto-resolves).
+        const rebase = rebaseContinuedBranchOntoMain(cwd, mainRef, env);
+        if (rebase.kind === 'conflict') {
+            return { kind: 'conflict' };
+        }
+        // Loop: retry the push, now re-leased against the freshly-fetched remote tip.
+    }
+}
+//# sourceMappingURL=continue-branch.js.map

package/dist/continue-branch.js.map

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

package/dist/cwd-section.d.ts

@@ -0,0 +1,186 @@
+import { type RepoReport } from './scan.js';
+import type { Config } from './config.js';
+import type { ConfigOverrideMap } from './config-override.js';
+/**
+ * The CWD-LOCAL section of `scan`/`status` (the `scan-status-read-cwd-repo`
+ * task). When a command runs INSIDE a participating repo, it ALSO reports that
+ * CURRENT repo as a clearly-labelled, separately-counted LOCAL section, in
+ * addition to (NEVER merged into) the cross-repo REGISTRY view.
+ *
+ * The consistency rule this module enforces (do not violate):
+ *
+ *   - The local section reads the LOCAL WORKING TREE (`scanRepoPaths([cwd])`) —
+ *     your possibly-uncommitted / unpushed / diverged state — NOT the bare
+ *     mirror-ref the registry reads. The two reads have DIFFERENT freshness +
+ *     storage models, so they are kept VISUALLY + SEMANTICALLY distinct, each
+ *     with its OWN count. A merged grand total would be true in NEITHER model.
+ *   - **The SELECTION pool is REMOTE-AUTHORITATIVE + FAILS CLOSED offline.** The
+ *     held-lock set (`refs/dorfl/lock/*`) lives ONLY on the arbiter, and it is the
+ *     LOAD-BEARING signal that keeps a claimed / in-flight item out of the
+ *     eligible pool (the body no longer moves on claim). So the cwd pool reads the
+ *     held set from the arbiter (`heldTaskSlugsStrict`) and SUBTRACTS it before
+ *     reporting eligibility — exactly as the registry `scan()` does. When the cwd
+ *     repo has a configured arbiter but that read cannot reach it, eligibility is
+ *     UNKNOWN and the section THROWS rather than emit a confident-but-wrong pool
+ *     (the
+ *     `scan-cwd-selection-pool-read-local-skips-held-lock-subtraction-offline-must-fail`
+ *     decision: offline selection fails; there is NO `--local` fallback). This is
+ *     the SELECTION concern; the divergence line is the SURFACE concern and keeps
+ *     its graceful warn+last-known behaviour.
+ *   - **Fetch-first ALSO for the cwd** (the maintainer's explicit ask): the cwd
+ *     repo's arbiter is fetched BEFORE the divergence is computed (the local
+ *     working tree is the LEAST authoritative view), reusing the
+ *     `scan-status-fetch-first` fetch+warn+fallback discipline — a failed fetch
+ *     WARNS and falls back to last-known, NEVER errors out (a read-only command
+ *     must degrade, ADR §5/§6).
+ *   - The divergence-vs-arbiter is shown with the `main-divergence-guard` framing
+ *     (`local main is N commits ahead of <arbiter>/main` = unpushed).
+ *   - **De-dup:** if the cwd repo is ALSO registered, it is shown ONCE in the
+ *     local section marked "(also registered)" and its registry row is dropped
+ *     from the registry list — so the same repo never appears as two mystery
+ *     rows with possibly-disagreeing states.
+ *
+ * The registry model is UNCHANGED by this: `scan`/`status` are read-only DISPLAY
+ * surfaces; the daemon (`run`) + the arbiter CAS still claim against the REGISTRY
+ * only. Showing the cwd changes nothing about where claims happen.
+ */
+/** The cwd repo's arbiter, as resolved for the local section's divergence line. */
+export interface CwdArbiter {
+    /** The arbiter remote name inspected (e.g. `arbiter` / `origin`). */
+    remote: string;
+    /** True iff the cwd repo has a remote with that name. */
+    configured: boolean;
+    /** The arbiter's URL, when configured. */
+    url?: string;
+    /**
+     * True iff the cwd repo's arbiter `main` was FRESHLY FETCHED before the
+     * divergence was computed. False ⇒ the fetch failed (offline / no arbiter) and
+     * the divergence reflects the last-known arbiter ref (a warning was emitted).
+     */
+    fetched: boolean;
+    /** Commits local `main` is AHEAD of `<arbiter>/main` (unpushed). */
+    ahead: number;
+    /** Commits local `main` is BEHIND `<arbiter>/main` (needs a pull/rebase). */
+    behind: number;
+}
+/** The cwd-local section report (one repo: the current working tree). */
+export interface CwdSection {
+    /** Absolute path to the cwd repo. */
+    path: string;
+    /**
+     * True iff the cwd is a participating repo (a `work/` tree with lifecycle
+     * content in any pool — see {@link isParticipatingRepo}, NOT `tasks/ready/`
+     * alone). When false, every other field is absent — there is NO local section.
+     */
+    participating: boolean;
+    /** The cwd repo's `work/` lifecycle, read from the LOCAL WORKING TREE. */
+    repo?: RepoReport;
+    /** Total backlog item count for the cwd (its OWN count, never merged). */
+    totalItems?: number;
+    /** Eligible item count for the cwd (its OWN count). */
+    totalEligible?: number;
+    /**
+     * True iff the cwd repo is ALSO in the registry (its arbiter URL keys to a
+     * registered hub mirror). When true the cwd is de-duped: shown once here,
+     * marked "(also registered)", and its registry row is dropped.
+     */
+    alsoRegistered?: boolean;
+    /**
+     * The registered hub-mirror PATH the cwd de-dups against (so the registry view
+     * can drop that row). Present only when {@link alsoRegistered} is true.
+     */
+    registeredMirrorPath?: string;
+    /** The cwd repo's arbiter + divergence (fetch-first). Absent when no arbiter. */
+    arbiter?: CwdArbiter;
+}
+/** The verdict of the FETCH-FREE cwd pre-check {@link cwdSectionDisposition}. */
+export interface CwdDisposition {
+    /** True iff the cwd is a participating repo (a `work/` tree with lifecycle
+     * content in any pool — see {@link isParticipatingRepo}, NOT `tasks/ready/`
+     * alone). */
+    participating: boolean;
+    /**
+     * True iff the cwd's arbiter URL keys to a registered hub mirror. When true the
+     * registry view ALREADY covers this repo, so a default `scan`/`status` should
+     * SKIP resolving the (expensive, fetch-first) cwd section entirely — the registry
+     * row represents it, and re-reading the cwd would just re-fetch the SAME arbiter
+     * `main` + lock refs the registry loop already fetched (the redundant-fetch the
+     * `scan-here-and-skip-redundant-cwd` decision eliminates). Meaningful only when
+     * {@link participating}.
+     */
+    alsoRegistered: boolean;
+}
+/**
+ * The FETCH-FREE pre-check that decides whether a DEFAULT `scan`/`status` should
+ * pay for the cwd section at all. It does NO network I/O: it reads whether the cwd
+ * participates (local `readdirSync`) and resolves the cwd's arbiter URL via the
+ * fetch-free {@link arbiterStatus} (a local `git remote get-url`), then asks the
+ * fetch-free {@link resolveRegistration} (local {@link listMirrors} key match)
+ * whether that URL is already a registered mirror.
+ *
+ * The CLI gates on this BEFORE calling {@link resolveCwdSection}: a participating
+ * cwd that is ALSO registered is skipped (the registry already covers it, and the
+ * cwd read would only re-fetch the same arbiter), while a participating cwd with
+ * NO mirror is resolved + shown standalone so a mirror-less repo you are standing
+ * in is never invisible. `--here` bypasses this gate (it ALWAYS resolves the cwd,
+ * and only the cwd).
+ */
+export declare function cwdSectionDisposition(input: {
+    cwd: string;
+    config: Config;
+    /** The DIVERGENCE/arbiter remote whose URL keys the registration check. */
+    arbiterRemote?: string;
+    env?: NodeJS.ProcessEnv;
+}): CwdDisposition;
+/** Inputs to {@link resolveCwdSection}. */
+export interface ResolveCwdSectionOptions {
+    /** The current working directory to inspect (the candidate cwd repo). */
+    cwd: string;
+    /** Resolved global config (for `workspacesDir` + per-repo `autoBuild`). */
+    config: Config;
+    /**
+     * The per-machine {@link ConfigOverrideMap}. Threaded into the local
+     * working-tree scan so the cwd section's eligibility reflects the per-machine
+     * override (consistent with the autopick / advance paths). Default: none.
+     */
+    override?: ConfigOverrideMap;
+    /**
+     * The arbiter remote name to fetch + diff against (the SURFACE/divergence
+     * remote). Defaults to the same remote `status`'s arbiter section resolves
+     * (`arbiter`); the CLI passes the configured value.
+     */
+    arbiterRemote?: string;
+    /**
+     * The COORDINATION arbiter remote where the per-item lock refs
+     * (`refs/dorfl/lock/*`) live — the remote the held-lock SUBTRACTION reads. This
+     * is the SAME remote `claim`/`do`/`complete` push locks to, which defaults to
+     * `origin` (NOT the `arbiter`-named DIVERGENCE remote above — a repo can use
+     * `origin` as its arbiter and have no `arbiter` remote at all, exactly this
+     * repo's shape). Decoupled so the held-lock read targets the real coordination
+     * arbiter even when the divergence remote is absent. Default `origin`.
+     */
+    lockArbiterRemote?: string;
+    /** Sink for the fetch-first fall-back warning (warn + last-known, never error). */
+    warn?: (message: string) => void;
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * Resolve the cwd-local section for `scan`/`status`. Returns
+ * `{participating: false}` when the cwd is NOT a participating repo (the callers
+ * then render only the registry view, unchanged). When participating it:
+ *
+ *   1. FETCHES the cwd repo's arbiter first (warn + fall back to last-known on
+ *      failure — never errors), then computes the divergence vs `<arbiter>/main`;
+ *   2. reads the COORDINATION arbiter's HELD-LOCK set (the remote where
+ *      `refs/dorfl/lock/*` live, default `origin`; fail-closed: throws when that
+ *      remote exists but is unreachable) to SUBTRACT in-flight items from the pool;
+ *   3. reads the cwd's `work/` lifecycle from the LOCAL WORKING TREE
+ *      (`scanRepoPaths([cwd])`) with that held set subtracted;
+ *   4. de-dups against the registry (is the cwd's arbiter URL a registered
+ *      mirror?).
+ *
+ * It MUTATES nothing but the arbiter fetch (a read refresh, same as the registry
+ * fetch-first); it never claims/moves/integrates.
+ */
+export declare function resolveCwdSection(options: ResolveCwdSectionOptions): Promise<CwdSection>;
+//# sourceMappingURL=cwd-section.d.ts.map

package/dist/cwd-section.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cwd-section.d.ts","sourceRoot":"","sources":["../src/cwd-section.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgB,KAAK,UAAU,EAAC,MAAM,WAAW,CAAC;AAKzD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,mFAAmF;AACnF,MAAM,WAAW,UAAU;IAC1B,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAC;IACf,yDAAyD;IACzD,UAAU,EAAE,OAAO,CAAC;IACpB,0CAA0C;IAC1C,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB,oEAAoE;IACpE,KAAK,EAAE,MAAM,CAAC;IACd,6EAA6E;IAC7E,MAAM,EAAE,MAAM,CAAC;CACf;AAED,yEAAyE;AACzE,MAAM,WAAW,UAAU;IAC1B,qCAAqC;IACrC,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,aAAa,EAAE,OAAO,CAAC;IACvB,0EAA0E;IAC1E,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,0EAA0E;IAC1E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uDAAuD;IACvD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;OAGG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,iFAAiF;IACjF,OAAO,CAAC,EAAE,UAAU,CAAC;CACrB;AAcD,iFAAiF;AACjF,MAAM,WAAW,cAAc;IAC9B;;iBAEa;IACb,aAAa,EAAE,OAAO,CAAC;IACvB;;;;;;;;OAQG;IACH,cAAc,EAAE,OAAO,CAAC;CACxB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE;IAC5C,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,2EAA2E;IAC3E,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACxB,GAAG,cAAc,CAgBjB;AAED,2CAA2C;AAC3C,MAAM,WAAW,wBAAwB;IACxC,yEAAyE;IACzE,GAAG,EAAE,MAAM,CAAC;IACZ,2EAA2E;IAC3E,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;;;;OAQG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,mFAAmF;IACnF,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,iBAAiB,CACtC,OAAO,EAAE,wBAAwB,GAC/B,OAAO,CAAC,UAAU,CAAC,CAwFrB"}