dorfl 0.0.0 → 0.1.0

package/dist/config.d.ts.map

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

package/dist/config.js

@@ -0,0 +1,241 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { brand } from './brand.js';
+import { validateIdentity } from './identity.js';
+import { DEFAULT_SELECTION_ORDER, } from './select-order.js';
+/**
+ * Resolve the `promptGuidance` namespace down to its concrete boolean fields
+ * with the documented defaults applied — so callers can read
+ * `resolvePromptGuidance(cfg).testFirst` without re-checking the namespace's
+ * presence (a per-repo file may legitimately omit `promptGuidance` entirely,
+ * or supply only a subset). Mirrors the gate family's defaults-resolved
+ * convention.
+ */
+export function resolvePromptGuidance(cfg) {
+    return { testFirst: cfg.promptGuidance?.testFirst === true };
+}
+/**
+ * The DEPRECATED config/env keys: present in an OLD config keeps working but is
+ * IGNORED with a one-line warning (never a hard error), so an existing setup is
+ * not broken by a removal. Each maps to the human-facing replacement hint. Mirrors
+ * the `allowAgents`→`autoBuild` removal-with-warning precedent.
+ *
+ * `provider` (the review-request provider OVERRIDE + `--provider` flag) was
+ * removed: the provider is purely ARBITER-derived now (a GitHub remote ⇒ the
+ * GitHub provider, else `none`), so an override could only contradict the arbiter.
+ * The legitimate `provider: none` use ("suppress the PR") is re-homed to the
+ * `noPR` intent axis.
+ */
+export const DEPRECATED_CONFIG_KEYS = {
+    provider: 'the `provider` axis was removed — the review-request provider is now purely ' +
+        'arbiter-derived (a GitHub remote ⇒ the GitHub provider, else none). To ' +
+        'deliberately suppress the PR (the old `provider: none` use), set `noPR: true` ' +
+        '(or pass `--no-pr`).',
+};
+/**
+ * Warn (once per offending key) for any DEPRECATED key present in a parsed config
+ * object, then DELETE it from the object so it never lingers in the resolved
+ * config. A stale key is IGNORED, not an error — an existing config keeps working.
+ * For `provider`, the warning points specifically at the `noPR` replacement when
+ * the stale value was the old `none` ("suppress the PR") use.
+ */
+export function warnDeprecatedConfigKeys(parsed, source, warn = (m) => console.error(`>> ${m}`)) {
+    for (const key of Object.keys(DEPRECATED_CONFIG_KEYS)) {
+        if (!(key in parsed) || parsed[key] === undefined) {
+            continue;
+        }
+        const staleNone = key === 'provider' && parsed[key] === 'none';
+        const hint = DEPRECATED_CONFIG_KEYS[key];
+        warn(`Ignoring deprecated key '${key}' in ${source}: ${hint}` +
+            (staleNone
+                ? ' (your `provider: none` maps directly to `noPR: true`.)'
+                : ''));
+        delete parsed[key];
+    }
+}
+/**
+ * Built-in defaults. Chosen so that zero-config is useful: stay strict about the
+ * autonomy gate (agents claim nothing unless a repo opts in via `autoBuild`).
+ * Discovery has no default `roots` — it is the registered hub-mirror set (empty
+ * until `remote add`/`remote find` registers a target).
+ */
+export const DEFAULT_CONFIG = {
+    autoBuild: false,
+    // The `promptGuidance` nudge namespace defaults to ALL members off — so the
+    // worker prompt is byte-identical to today when no repo opts in. NOT a gate;
+    // `verify` remains the sole acceptance bar regardless.
+    promptGuidance: { testFirst: false },
+    // Auto-tasking is human-first by default: an agent tasks nothing unless a
+    // repo opts in via `autoTask` (mirrors `autoBuild`, one level up).
+    autoTask: false,
+    // The observation INBOX is calm by default (`off`): the triage pool is dropped
+    // from the auto-pick selection, so observations are left untouched unless a repo
+    // opts in via `observationTriage` (`ask` ⇒ surface a question for each; `auto` ⇒
+    // auto-dispose the no-question cases). ADR `ci-config-policy-and-gate-family` §3.
+    observationTriage: 'off',
+    // The merge-question SURFACER defaults to `ask` — the conservative default
+    // (prd `land-time-reverify-and-parallel-merge-ceiling` Applied answer q2 /
+    // task `merge-questions-gate-axis` Applied answer q2). NEVER `off` by default:
+    // a silently-dropped merge-question means finished, pushed work never lands —
+    // strictly more consequential than a dropped observation-promote prompt, so
+    // this gate axis is DELIBERATELY HIGHER than `observationTriage`'s `off`. A
+    // trusted-repo fast path opts into `auto` (runner self-supplies the `merge`
+    // answer + lands via the SAME deterministic apply-time re-verify); a repo that
+    // lands by some other means opts into `off`. Resolved per-repo through the
+    // SAME precedence chain (flag > env > per-repo > global > default).
+    mergeQuestions: 'ask',
+    // DECLARED blocked work is calm by default (`false`): the `needsAnswers`-blocked
+    // pool is dropped from the auto-pick selection, so `advance` does NOT proactively
+    // render a declared blocker into a question sidecar unless a repo opts in via
+    // `surfaceBlockers`. Orthogonal PEER to `observationTriage`; `needs-attention`
+    // (a stuck build) is separate + always-on. ADR `ci-config-policy-and-gate-family` §3.
+    surfaceBlockers: false,
+    // SURFACING widens to STAGING by default (`true`) — a `needsAnswers` task in
+    // `tasks/backlog/` or a `needsAnswers` prd in `prds/proposed/` surfaces
+    // its questions BEFORE promotion, so a human promotes an already-clarified
+    // item. Prd `staging-surface-and-apply-promote-safety` (F2). BUILD/claim
+    // stays pool-only + trust-gated regardless: this widens ONLY the surface
+    // polarity, not the build polarity. Set `false` to restore the legacy
+    // pool-only surface behaviour.
+    surfaceStaging: true,
+    // The `drain` selection-order preset by default (ADR `ci-config-policy-and-gate-
+    // family`, selection-order section): drain ready work (build eligible tasks →
+    // task taskable prds) before creating/asking (surface → triage); `apply` is
+    // always first. Reproduces today's tasks-first two-pool default. Subsumes the
+    // removed `prdsFirst` boolean (`[task, build, ...]` reproduces `prdsFirst: true`).
+    selectionOrder: DEFAULT_SELECTION_ORDER,
+    maxParallel: 4,
+    perRepoMax: 2,
+    defaultArbiter: 'origin',
+    workspacesDir: join(homedir(), brand.workdirName),
+    arbitersDir: join(homedir(), 'git'),
+    integration: 'propose',
+    // The PR-INTENT axis defaults to `false` ("I want a PR"): on a GitHub arbiter,
+    // propose opens the PR via the arbiter-derived provider. Set `true` to push the
+    // branch but deliberately skip the PR (the explicit suppress-PR intent that
+    // re-homes the old `provider: none` use). NOT a provider choice.
+    noPR: false,
+    // The tasker's emitted tasks land STAGED (`pre-backlog/`) by default — the
+    // conservative landing that preserves the tracer task's behaviour: an item is
+    // durable + readable but NOT in the agent-eligible pool until a human/runner
+    // promotes it. A repo opts into the trusted fast-path with `tasksLandIn:
+    // 'ready'` (or `--tasks-land-in ready` / `DORFL_TASKS_LAND_IN=ready`).
+    // The runner-deterministic resolver overlays explicit-flag + untrusted-origin
+    // force on top of this default (`src/placement.ts`).
+    tasksLandIn: 'pre-backlog',
+    // `intake`-authored specs land STAGED (`pre-proposed/`) by default — the
+    // conservative landing that mirrors `tasksLandIn`'s built-in floor: a spec is
+    // durable + readable but NOT in the auto-tasking POOL until a human/runner
+    // promotes it. A repo opts into the trusted fast-path with `specsLandIn: 'ready'`
+    // (or `--specs-land-in ready` / `DORFL_SPECS_LAND_IN=ready`). The same
+    // runner-deterministic resolver overlays explicit-flag + untrusted-origin
+    // force on top of this default (`src/placement.ts`).
+    specsLandIn: 'pre-proposed',
+    agentCmd: '',
+    // Gate 2 (PR/code review) defaults OFF — it puts a model on the merge path, so
+    // it is opt-in (ADR §8). On an `approve` a resolved `merge` lands automatically
+    // (`merge` IS the auto-land mode); `propose` always leaves the merge to a human.
+    // The loop bound is a small N so an unattended revise↔review can never run forever.
+    review: false,
+    reviewMaxRounds: 2,
+    // The tasker improver loop is ON by default — auto-tasking has no `verify`
+    // floor, so the loop is the task path's quality engine (distinct from the
+    // acceptance gate's `review`, which defaults OFF).
+    taskerLoop: true,
+    // The tasker improver loop's hard cap on in-context review passes — a cheap
+    // default so an unattended review→edit→re-review can never run forever (the
+    // natural terminator is "no new blocking issue"; this is the ceiling on top).
+    taskerLoopMax: 3,
+    // The fresh-worktree acceptance gate is ON by default: most CI/tooling caches
+    // deps so `pnpm install` is fast, so correctness-first (the gate tests what
+    // MERGES, not the agent's pre-rebase checkout) is the right default. The
+    // opt-out (`--no-fresh-worktree-gate`) runs `verify` in the build worktree as
+    // before, for when the per-gate install cost is too high. Mirrors `taskerLoop`
+    // (positive name, default-on).
+    freshWorktreeGate: true,
+    // The cross-job merge serialiser's CAS-retry cap — the git-alone FLOOR of the
+    // land-time cross-job queue (prd `land-time-reverify-and-parallel-merge-ceiling`,
+    // Story 5 + Applied Answer q1 (a)). Matches `integration-core.ts`'s built-in
+    // `DEFAULT_MERGE_RETRIES` fallback (1000 — the C2 large liveness ceiling, NOT a
+    // small Race-1 budget) so resolving it through this layer is byte-for-byte
+    // today's behaviour when no source sets it. A wide-matrix CI raises it via
+    // `--merge-retries`/`DORFL_MERGE_RETRIES`/per-repo `mergeRetries`.
+    mergeRetries: 1000,
+    // The strict-merge-approval gate defaults OFF (sidecar OQ6 / task
+    // `strict-merge-approval-gate`): the cheap "green re-verify is enough" path
+    // is the default; the OQ6 PRD answer pins this. A repo opts in to the
+    // host-agnostic "dismiss stale approvals on base change" discipline with
+    // `strictMergeApproval: true` (or `--strict-merge-approval` /
+    // `DORFL_STRICT_MERGE_APPROVAL=true`). The re-surface vs. land branch is
+    // `apply-rung-merge-disposition`'s consumer, NOT here.
+    strictMergeApproval: false,
+};
+/** The conventional config location (`~/.config/dorfl/config.json`). */
+export function defaultConfigPath() {
+    return join(homedir(), '.config', brand.configDirName, 'config.json');
+}
+/** Merge a partial config over the built-in defaults; arrays are replaced. */
+export function mergeConfig(overrides) {
+    const merged = { ...DEFAULT_CONFIG };
+    // Iterate the override's own keys (not the defaults') so optional keys like
+    // `verify` (absent from DEFAULT_CONFIG, left unset by design) are carried over.
+    for (const key of Object.keys(overrides)) {
+        const value = overrides[key];
+        if (value !== undefined) {
+            // Assign through `unknown`: each key's value type matches by construction.
+            merged[key] = value;
+        }
+    }
+    return merged;
+}
+/**
+ * Persist `config` to `path` as pretty JSON (creating the parent dir). Used by
+ * `work-on` to SAVE the prompted `humanWorktreesDir` on first use so the human is
+ * never asked again. Only the keys present in `config` are written — we round-trip
+ * whatever the loader produced (defaults + file + the new key), which keeps the
+ * on-disk file explicit and stable.
+ */
+export function saveConfig(config, path) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(config, null, 2) + '\n');
+}
+/**
+ * Load config from `path`, merged over defaults. A missing file is not an error
+ * (defaults make the tool work out of the box); invalid JSON is.
+ */
+export function loadConfig(path = defaultConfigPath()) {
+    if (!existsSync(path)) {
+        return mergeConfig({});
+    }
+    let raw;
+    try {
+        raw = readFileSync(path, 'utf8');
+    }
+    catch (err) {
+        throw new Error(`Failed to read config at ${path}: ${err.message}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`Invalid JSON in config at ${path}: ${err.message}`);
+    }
+    // Drop (with a one-line warning) any DEPRECATED key (e.g. the removed `provider`
+    // override) so an existing config keeps working — ignored, never a hard error.
+    warnDeprecatedConfigKeys(parsed, path);
+    // Validate a present identity at LOAD time (dumb — no arbiter URL resolution;
+    // the transport-coherence check is push-time). A bad identity is a hard config
+    // error, never a silent ambient fallback.
+    if (parsed.identity !== undefined) {
+        try {
+            validateIdentity(parsed.identity);
+        }
+        catch (err) {
+            throw new Error(`Invalid identity in config at ${path}: ${err.message}`);
+        }
+    }
+    return mergeConfig(parsed);
+}
+//# sourceMappingURL=config.js.map

package/dist/config.js.map

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

package/dist/continue-branch.d.ts

@@ -0,0 +1,249 @@
+/**
+ * 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 declare function branchAheadOf(cwd: string, branchRef: string, mainRef: string, env: NodeJS.ProcessEnv | undefined): boolean;
+/**
+ * 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 declare function branchAheadOfArbiter(options: {
+    cwd: string;
+    /** The remote NAME to `ls-remote` (the arbiter as known to this repo). */
+    arbiterRemote: string;
+    /** Unqualified branch name on the arbiter (e.g. `work/task-<slug>`). */
+    branch: string;
+    /** The local ref to read for the ahead-of-main check (when arbiter says present). */
+    branchRef: string;
+    /** The local main ref to compare against. */
+    mainRef: string;
+    env: NodeJS.ProcessEnv | undefined;
+}): boolean;
+/** The result of rebasing a continued branch onto the freshly-fetched main. */
+export interface ContinueRebaseResult {
+    /** `clean` — the rebase replayed onto main with no conflict. */
+    /** `conflict` — the rebase conflicted; it was `--abort`ed (never auto-resolved). */
+    kind: 'clean' | 'conflict';
+}
+/**
+ * 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 declare function rebaseContinuedBranchOntoMain(cwd: string, mainRef: string, env: NodeJS.ProcessEnv | undefined): ContinueRebaseResult;
+/**
+ * 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 declare 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 declare function isStaleLeaseRejection(stderr: string): boolean;
+/**
+ * Outcome of {@link pushProposeBranchWithStaleLeaseRetry} — the sibling of
+ * {@link ContinuedPushResult} on the PROPOSE-mode work-branch push.
+ */
+export type ProposePushResult = 
+/** The work branch landed on the arbiter (first try or after a stale-lease retry). */
+{
+    kind: 'pushed';
+}
+/**
+ * BENIGN already-landed race tail: the remote `work/<slug>` ref is GONE on
+ * the arbiter AND our HEAD is provably reachable from `<arbiter>/main` — i.e.
+ * the work already landed via a sibling's merge and its head was reaped
+ * (`integrator.ts` `deleteMergedHeadBranch`'s ancestor-guarded reap, or `gc`).
+ * This is the propose-push analogue of the leased-delete `already-reaped`
+ * outcome (`item-lock.ts`): a vanished ref whose work is provably landed is
+ * the DESIRED end state, not a failure.
+ */
+ | {
+    kind: 'already-landed';
+};
+/**
+ * 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 declare function pushProposeBranchWithStaleLeaseRetry(options: {
+    cwd: string;
+    branch: string;
+    /** The arbiter remote name to push to / observe (e.g. `arbiter`, `origin`). */
+    arbiter: string;
+    retries?: number;
+    env: NodeJS.ProcessEnv | undefined;
+    /** Optional progress note sink (mirrors the continue helper's `note`). */
+    note?: (message: string) => void;
+}): ProposePushResult;
+/** The outcome of {@link pushContinuedBranchWithStaleLeaseRetry}. */
+export type ContinuedPushResult = 
+/** The work branch landed on the arbiter (first try or after a clean re-rebase). */
+{
+    kind: 'pushed';
+}
+/**
+ * A re-rebase onto the freshly-fetched main CONFLICTED on a retry; it was
+ * `--abort`ed (NEVER auto-resolved). The caller routes the item to
+ * needs-attention via the §10 path — the green work stays intact on the branch.
+ */
+ | {
+    kind: 'conflict';
+};
+/**
+ * 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 declare function pushContinuedBranchWithStaleLeaseRetry(options: {
+    cwd: string;
+    branch: string;
+    /** The arbiter remote name to push to / re-fetch from (e.g. `origin`). */
+    arbiter: string;
+    /** The local main ref to rebase onto across retries (e.g. `main`). */
+    mainRef: string;
+    /** The arbiter `<branch>` sha the caller already observed (pre-rebase tip). */
+    expectedRemoteTip: string;
+    retries?: number;
+    env: NodeJS.ProcessEnv | undefined;
+    /** Optional progress note sink (mirrors the claim loop's `note`). */
+    note?: (message: string) => void;
+}): ContinuedPushResult;
+//# sourceMappingURL=continue-branch.d.ts.map

package/dist/continue-branch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"continue-branch.d.ts","sourceRoot":"","sources":["../src/continue-branch.ts"],"names":[],"mappings":"AAuCA;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAC5B,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,CAAC,UAAU,GAAG,SAAS,GAChC,OAAO,CAwBT;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,0EAA0E;IAC1E,aAAa,EAAE,MAAM,CAAC;IACtB,wEAAwE;IACxE,MAAM,EAAE,MAAM,CAAC;IACf,qFAAqF;IACrF,SAAS,EAAE,MAAM,CAAC;IAClB,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC,UAAU,GAAG,SAAS,CAAC;CACnC,GAAG,OAAO,CAiBV;AAED,+EAA+E;AAC/E,MAAM,WAAW,oBAAoB;IACpC,gEAAgE;IAChE,oFAAoF;IACpF,IAAI,EAAE,OAAO,GAAG,UAAU,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,6BAA6B,CAC5C,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,CAAC,UAAU,GAAG,SAAS,GAChC,oBAAoB,CAYtB;AAED;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,IAAI,CAAC;AAE7C;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE7D;AAED;;;GAGG;AACH,MAAM,MAAM,iBAAiB;AAC5B,sFAAsF;AACpF;IAAC,IAAI,EAAE,QAAQ,CAAA;CAAC;AAClB;;;;;;;;GAQG;GACD;IAAC,IAAI,EAAE,gBAAgB,CAAA;CAAC,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,oCAAoC,CAAC,OAAO,EAAE;IAC7D,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,+EAA+E;IAC/E,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC,UAAU,GAAG,SAAS,CAAC;IACnC,0EAA0E;IAC1E,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC,GAAG,iBAAiB,CA6GpB;AAED,qEAAqE;AACrE,MAAM,MAAM,mBAAmB;AAC9B,oFAAoF;AAClF;IAAC,IAAI,EAAE,QAAQ,CAAA;CAAC;AAClB;;;;GAIG;GACD;IAAC,IAAI,EAAE,UAAU,CAAA;CAAC,CAAC;AAEtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,sCAAsC,CAAC,OAAO,EAAE;IAC/D,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,0EAA0E;IAC1E,OAAO,EAAE,MAAM,CAAC;IAChB,sEAAsE;IACtE,OAAO,EAAE,MAAM,CAAC;IAChB,+EAA+E;IAC/E,iBAAiB,EAAE,MAAM,CAAC;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC,UAAU,GAAG,SAAS,CAAC;IACnC,qEAAqE;IACrE,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC,GAAG,mBAAmB,CAiFtB"}