dorfl 0.0.0 → 0.1.0

package/dist/item-lock.d.ts

@@ -0,0 +1,626 @@
+import { type SidecarType } from './sidecar.js';
+/**
+ * The **unified item-lock module** (prd `ledger-status-per-item-lock-refs`, ADR
+ * `ledger-status-on-per-item-lock-refs`). The runner's ONE lock primitive: ONE
+ * lock per item, on a PER-ITEM hidden ref `refs/dorfl/lock/<entry>`,
+ * acquired by an ATOMIC create-only push and released by DELETING the ref, with a
+ * two-axis (`action` × `state`) entry. It collapses the old transient status
+ * folders (`in-progress`, `needs-attention`, `tasking`, `advancing`) into ONE
+ * lock keyed by item identity; `in-progress` = lock held active for `implement`,
+ * `needs-attention` = lock held `stuck`.
+ *
+ * It GENERALISES the green tracer that proved the dangerous core end-to-end on a
+ * bare `file://` arbiter (the tracer is now this file). The one production
+ * difference from the tracer is the IDENTITY SEAM: callers pass a NAMESPACED item
+ * identity (`task:<slug>` / `prd:<slug>` / `observation:<slug>` / `obs:<slug>`,
+ * or a bare `<slug>` = task), and this module derives the type-encoded lock
+ * `<entry>` (`<type>-<slug>`) through {@link resolveSidecarIdentity} — the SAME
+ * single source of truth the sidecar (`work/questions/<type>-<slug>.md`) and the
+ * work branch (`work/<type>-<slug>`) already use. There is deliberately NO second
+ * identity scheme: a task, a prd,
+ * and an observation that share a slug get DISTINCT lock refs, and the SAME item
+ * under different actions shares ONE ref (so implement / task / advance on one
+ * item are mutually exclusive by construction).
+ *
+ * It is NOT yet wired into claim/task/advance — those are separate, dependent
+ * tasks — and deliberately does NOT touch `main`.
+ *
+ * WHY a per-item ref (not a marker on `main` or a tree on one shared ref):
+ *   - **No false contention, no retry.** The ONLY writer that can contend on item
+ *     X's lock is another writer FOR X — a GENUINE conflict the loser SHOULD lose.
+ *     Two writers for DIFFERENT items touch DIFFERENT refs and never serialise. So
+ *     acquire needs NO refetch-retry budget (contrast the shared-`main` CAS, which
+ *     falsely-contends under parallelism and exhausts its retry cap → exit 3).
+ *   - **Self-cleaning, no storage growth.** Acquire CREATES the ref; release
+ *     DELETES it (not "empties" it), so the live ref set = currently-held items
+ *     only. The lock commit is PARENTLESS (no `main` parent), so on ref-delete it
+ *     is immediately unreachable and reclaimed by normal git gc — and the lock ref
+ *     is fully decoupled from `main`'s object graph.
+ *   - **Branch-inheritance impossible.** Nothing is in `main`'s tree, so a work
+ *     branch cut from `main` inherits no lock state.
+ *   - **Provider-agnostic.** A ref is a ref: the create-only / delete pushes work
+ *     identically on a `--bare file://` arbiter and a real remote.
+ *
+ * ATOMICITY is the `--force-with-lease=<ref>:` (EMPTY expected) create-only push:
+ * the arbiter accepts it ONLY if the ref is still absent; a racer who lost finds
+ * the ref present and is rejected. No nonce gymnastics are needed here (unlike the
+ * shared-`main` CAS) because the ref NAME is the identity — two acquires for the
+ * same item race the SAME ref, and ref-level create-only is itself the mutex.
+ */
+/** The ref namespace for per-item locks. HIDDEN (not `refs/heads/*`): invisible
+ * in the GitHub UI, not swept by branch automation, not fetched by a default
+ * clone. Deletion = "all locks released" (recoverable; work is on the work
+ * branches + `main`). */
+export declare const LOCK_REF_PREFIX = "refs/dorfl/lock";
+/**
+ * The single IDENTITY SEAM for the lock: derive the type-encoded lock `<entry>`
+ * (`<type>-<slug>`) from a NAMESPACED item identity, through the shared
+ * {@link resolveSidecarIdentity} resolver (the single source of truth, which the
+ * sidecar filename + the advancing-lock marker also key onto). Accepts the same
+ * forms as that resolver: `task:<slug>` / `prd:<slug>` / `observation:<slug>` /
+ * `obs:<slug>`, or a bare `<slug>` (= task). Acquire/release/read ALL key
+ * through THIS function, so there is one — and only one — addressing scheme.
+ */
+export declare function lockEntryFor(item: string): string;
+/** The lock ref for a type-encoded `<entry>` (`<type>-<slug>`). */
+export declare function itemLockRef(entry: string): string;
+/** WHAT holds the lock — the three mutually-exclusive actions over one item. */
+export type LockAction = 'implement' | 'task' | 'advance';
+/** Health of the hold: `active` (in-progress) or `stuck` (needs-attention). */
+export type LockState = 'active' | 'stuck';
+/**
+ * The two-axis lock entry. `action` and `state` are INDEPENDENT axes (so
+ * "advanced-and-stuck" and "building-and-stuck" are both representable, which a
+ * single action-field could not do). `reason` is present IFF `state === 'stuck'`.
+ *
+ * Since the lock entry is the SOLE stuck record (task
+ * `cutover-needs-attention-becomes-lock-stuck-recovery-surface`, decision i+: the
+ * `needs-attention/` folder is retired), `reason` is the FULL bounce prose (it may
+ * span multiple lines — a red-gate excerpt, a rebase-conflict report, an agent's
+ * ambiguity note), and `questions` carries any agent-surfaced questions for the
+ * human. Both ride in the lock blob BODY (not a single frontmatter field) so they
+ * round-trip richly, in a shape a future advance-surface rung (the
+ * surface-stuck-locks-as-questions direction captured in
+ * `work/notes/observations/needs-attention-may-have-no-human-visible-outcome-after-lock-cutover-surface-as-questions-2026-06-21.md`)
+ * can render into a `work/questions/` sidecar. `questions` is present (non-empty) only
+ * for a stuck entry that recorded them.
+ */
+export interface LockEntry {
+    entry: string;
+    action: LockAction;
+    state: LockState;
+    holder: string;
+    since: string;
+    reason?: string;
+    questions?: string[];
+}
+/** Outcome of an acquire attempt. `acquired` = we hold it; `lost` = someone else
+ * does (a genuine same-item conflict). `error` = environment/usage. */
+export type AcquireOutcome = 'acquired' | 'lost' | 'error';
+export type ReleaseOutcome = 'released' | 'not-held' | 'error';
+export interface AcquireResult {
+    outcome: AcquireOutcome;
+    /** The type-encoded lock entry (`<type>-<slug>`) the acquire keyed onto. */
+    entry: string;
+    ref: string;
+    message: string;
+}
+export interface ReleaseResult {
+    outcome: ReleaseOutcome;
+    /** The type-encoded lock entry (`<type>-<slug>`) the release keyed onto. */
+    entry: string;
+    ref: string;
+    message: string;
+}
+/**
+ * Outcome of an AMEND-style transition (mark-stuck / resume / requeue) — the
+ * lock-entry STATE MACHINE's interior moves (prd `ledger-status-per-item-lock-refs`,
+ * the C8 lock-entry state machine in the design trail). Each is a single CAS on the
+ * held ref (no retry loop), so the verdict is definitive:
+ *   - `transitioned` — we won the CAS; the entry now holds the target `(action, state)`.
+ *   - `not-held`     — there is no entry to transition (the move's precondition is
+ *                      "a held entry in the right state"; absent ⇒ illegal here).
+ *   - `wrong-state`  — an entry exists but in the wrong `state` for this move
+ *                      (e.g. resume on an `active` entry, mark-stuck on a `stuck` one).
+ *                      An ILLEGAL transition, rejected, not coerced.
+ *   - `lost`         — the leased CAS was rejected because a CONCURRENT writer changed
+ *                      the ref between our read and our push (a genuine same-item race).
+ *   - `error`        — environment/usage (missing item, missing reason for mark-stuck, …).
+ */
+export type TransitionOutcome = 'transitioned' | 'not-held' | 'wrong-state' | 'lost' | 'error';
+export interface TransitionResult {
+    outcome: TransitionOutcome;
+    /** The type-encoded lock entry (`<type>-<slug>`) the transition keyed onto. */
+    entry: string;
+    ref: string;
+    message: string;
+    /** The lock entry AFTER a successful `transitioned` (absent for requeue's removal). */
+    lock?: LockEntry;
+}
+/**
+ * Serialise a lock entry to the ref's blob body (markdown frontmatter, like the
+ * advancing marker, so it round-trips and is previewable). The two-axis state
+ * (`entry`/`action`/`state`/`holder`/`since`) lives in the frontmatter; a stuck
+ * entry's FULL reason prose + any surfaced questions live in the BODY (under
+ * `## Reason` / `## Questions`) so they round-trip RICHLY (multi-line reason,
+ * bulleted questions) — the lock entry is the SOLE stuck record now, in a shape a
+ * future advance-surface rung can render. {@link parseLockEntry} is the exact
+ * inverse.
+ */
+export declare function serialiseLockEntry(e: LockEntry): string;
+export interface AcquireOptions {
+    /**
+     * The NAMESPACED item identity to lock (`task:<slug>` / `prd:<slug>` /
+     * `observation:<slug>` / `obs:<slug>`, or a bare `<slug>` = task). Resolved to
+     * the type-encoded lock `<entry>` through {@link lockEntryFor}.
+     */
+    item: string;
+    action: LockAction;
+    cwd: string;
+    arbiter?: string;
+    holder?: string;
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * Acquire the per-item lock atomically: build a parentless lock commit and push it
+ * to `refs/dorfl/lock/<entry>` with `--force-with-lease=<ref>:` (the EMPTY
+ * expected value = create-only). The arbiter accepts ONLY if the ref is still
+ * absent. A racer who lost finds the ref present → its lease fails → `lost`. No
+ * retry loop: a rejection here is a GENUINE same-item conflict, not false
+ * contention.
+ */
+export declare function acquireItemLock(opts: AcquireOptions): Promise<AcquireResult>;
+export interface ReleaseOptions {
+    /** The NAMESPACED item identity (same forms as {@link AcquireOptions.item}). */
+    item: string;
+    cwd: string;
+    arbiter?: string;
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * Release the per-item lock by DELETING the ref (`git push <arbiter>
+ * :refs/dorfl/lock/<entry>`). Deleting (not emptying) is what makes the
+ * lock set self-cleaning: a released item has NO ref, and its parentless commit
+ * becomes unreachable for gc. Idempotent: deleting an absent ref is `not-held`.
+ */
+export declare function releaseItemLock(opts: ReleaseOptions): Promise<ReleaseResult>;
+/** Outcome of a GUARDED release ({@link releaseHeldItemLock}): the caller HELD the
+ * lock, so an absent ref is NOT benign — it is `vanished` (the ref was deleted
+ * under us, an abort signal). */
+export type ReleaseHeldOutcome = 'released' | 'vanished' | 'error';
+export interface ReleaseHeldResult {
+    outcome: ReleaseHeldOutcome;
+    /** The type-encoded lock entry (`<type>-<slug>`) the release keyed onto. */
+    entry: string;
+    ref: string;
+    message: string;
+}
+/**
+ * GUARDED release for a runner that KNOWS it acquired and HELD the lock (prd
+ * `ledger-status-per-item-lock-refs` US #13): unlike {@link releaseItemLock} —
+ * whose `not-held` is a BENIGN idempotent case the complete/tasking/needs-attention
+ * callers tolerate (the body may predate the lock, or a crash-recovery may have
+ * already cleared it) — here the absence of OUR ref is an ABORT SIGNAL. A held
+ * runner whose own lock VANISHED mid-build (someone `release-lock`-ed it, or a
+ * `gc`/recovery cleared it) must DETECT it on release and route to
+ * needs-attention rather than silently "clean-release" a lock it no longer holds:
+ * the work it just did was NOT protected by the exclusion it thought it had.
+ *
+ * So this maps {@link releaseItemLock}'s `not-held` to a DISTINCT `vanished`
+ * outcome the caller branches on (abort / needs-attention), while a genuine
+ * `released` is the happy path and `error` stays `error`. It is otherwise the
+ * SAME leased delete (no second mechanism): a clean `released` deletes the ref we
+ * held. Use this ONLY where the caller provably HELD the lock (the in-flight
+ * runner's own release); the tolerant idempotent callers keep using
+ * {@link releaseItemLock}.
+ */
+export declare function releaseHeldItemLock(opts: ReleaseOptions): Promise<ReleaseHeldResult>;
+/** Verdict of the SHARED leased delete {@link leasedDeleteLockRef}: `deleted` (the
+ * ref was removed), `lost` (a concurrent change moved the ref between the read and
+ * the delete — the lease was REJECTED, never `--force`d), or `error`. */
+export type LeasedDeleteOutcome = 'deleted' | 'lost' | 'error';
+export interface MarkStuckOptions {
+    /** The NAMESPACED item identity (same forms as {@link AcquireOptions.item}). */
+    item: string;
+    /** The needs-attention prose. REQUIRED — a `stuck` entry always carries a reason. */
+    reason: string;
+    /**
+     * Any agent-surfaced QUESTIONS for the human, recorded on the stuck entry's
+     * body (the lock is the SOLE stuck record now). Optional; empty/absent ⇒ no
+     * questions block. A future advance-surface rung renders these into a
+     * `work/questions/` sidecar.
+     */
+    questions?: string[];
+    cwd: string;
+    arbiter?: string;
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * mark-stuck (transition 2): `[action, active] -> [action, stuck] + reason`. The
+ * runner bounces (red gate, agent failure, decomposition-unclear). A leased CAS
+ * amend of the SAME entry's `state` + `reason`, keeping `action`/`holder`/`since`.
+ * It is the source of the needs-attention SURFACE (now read from the lock ref,
+ * not a `work/needs-attention/` folder).
+ *
+ * PRECONDITIONS (the state machine + invariants):
+ *   - the entry must be HELD and `active` (`not-held` / `wrong-state` otherwise) —
+ *     stuck is reachable only FROM active, never from absent or already-stuck.
+ *   - `reason` must be non-empty (the `reason` PRESENT iff `state: stuck` invariant).
+ */
+export declare function markStuckItemLock(opts: MarkStuckOptions): Promise<TransitionResult>;
+export interface ResumeOptions {
+    /** The NAMESPACED item identity (same forms as {@link AcquireOptions.item}). */
+    item: string;
+    cwd: string;
+    arbiter?: string;
+    /** Optionally reassign the holder on resume (a human/continue picks it up). */
+    holder?: string;
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * resume (transition 3): `[action, stuck] -> [action, active]`. A human (or a
+ * `continue`) picks the stuck item up: amend `state` back to `active` and CLEAR
+ * `reason` (the `reason` iff `stuck` invariant — an active entry never carries a
+ * stuck reason). Keeps the same `action`; `holder` may be reassigned. The
+ * lock-entry analogue of the old `needs-attention -> in-progress` folder move.
+ *
+ * PRECONDITION: the entry must be HELD and `stuck` (`not-held` / `wrong-state`
+ * otherwise) — active is reachable from stuck only, not from absent.
+ */
+export declare function resumeItemLock(opts: ResumeOptions): Promise<TransitionResult>;
+/**
+ * requeue (transition 4): `[action, stuck] -> (absent)`. Give up on a STUCK hold
+ * and return the item to the pool by REMOVING the entry. The body never moved
+ * (Amendment 5 — it is already resting in `backlog/` on `main`), so requeue is
+ * purely "release the lock"; the kept `work/<slug>` branch remains for recovery.
+ *
+ * Distinct from {@link releaseItemLock} (transition 6, abort from ACTIVE): requeue
+ * is the GUARDED give-up from `stuck` only, so it rejects (`wrong-state`) an
+ * `active` entry — abandoning an in-flight active hold goes through `release`, not
+ * `requeue`. The removal itself is a leased delete (a concurrent change ⇒ `lost`).
+ */
+export declare function requeueItemLock(opts: ReleaseOptions): Promise<TransitionResult>;
+/**
+ * Read the current lock entry for an item from the arbiter (the `status`/`scan`
+ * read path): fetch the lock refs, read `lock.md` from the ref's tree. Returns
+ * `undefined` when the item is not locked.
+ */
+export declare function readItemLock(opts: ReleaseOptions): Promise<LockEntry | undefined>;
+/**
+ * The DURABLE-`main` terminal record paths for an item, by its type — the
+ * authoritative resting records the cross-substrate reconciliation reads. An
+ * item is TERMINAL on `main` iff ANY of these paths exists on `<arbiter>/main`.
+ * The won't-proceed terminal is PER-REGIME (the slug-collision correctness fix:
+ * a dropped task and a dropped prd sharing a slug used to collide on one
+ * bare-slug `work/dropped/<slug>.md`):
+ *   - a TASK: `work/tasks/done/<slug>.md` (completed) OR
+ *     `work/tasks/cancelled/<slug>.md` (the task regime's won't-proceed terminal).
+ *   - a PRD: `work/prds/tasked/<slug>.md` (tasked) OR `work/prds/dropped/<slug>.md`
+ *     (the prd regime's won't-proceed terminal).
+ *   - an OBSERVATION: NONE. A note has no durable terminal folder — it leaves by
+ *     deletion (its absence, not a terminal record, is the end state). A promoted
+ *     observation becomes a NEW task/prd with its own ref.
+ */
+export declare function terminalMainPaths(type: SidecarType, slug: string): string[];
+/** The outcome of a cross-substrate reconciliation of one item's lock against
+ * the authoritative `main` durable record (prd `ledger-status-per-item-lock-refs`
+ * US #9/#10; ADR `ledger-status-on-per-item-lock-refs`). */
+export type ReconcileOutcome = 'cleared-stale' | 'kept-stuck' | 'kept-in-flight' | 'no-lock' | 'error';
+export interface ReconcileResult {
+    outcome: ReconcileOutcome;
+    /** The type-encoded lock entry (`<type>-<slug>`) reconciled. */
+    entry: string;
+    ref: string;
+    /** Whether `<arbiter>/main` shows the item terminal (per {@link terminalMainPaths}:
+     * a task at `tasks/done`/`tasks/cancelled`, a prd at `prds/tasked`/`prds/dropped`). */
+    terminalOnMain: boolean;
+    message: string;
+}
+/**
+ * Reconcile ONE item's per-item lock against the AUTHORITATIVE `main` durable
+ * record — the heart of complete's cross-substrate crash-safety (prd
+ * `ledger-status-per-item-lock-refs` US #9/#10; ADR
+ * `ledger-status-on-per-item-lock-refs`; the design trail's Amendment 6).
+ *
+ * complete's order is hold lock → land the DURABLE `main` move FIRST → release
+ * the lock SECOND. A crash BETWEEN the move and the release leaves a
+ * terminal-on-`main` item (a completed/cancelled task or a tasked/dropped prd,
+ * per {@link terminalMainPaths}) with a STILL-HELD lock — a stale lock with no
+ * in-flight work behind it. This is the recovery that converges it.
+ *
+ * THE RECOVERY RULE (the `main` record is authoritative over a stale lock):
+ *   - `main` is TERMINAL + the held lock is `active`  → the item is RESTED, the
+ *     lock is STALE (the crash was after the move) → CLEAR it (`cleared-stale`).
+ *   - `main` is TERMINAL + the held lock is `stuck`   → KEEP it (`kept-stuck`).
+ *     `done` + `stuck` may legitimately CO-EXIST (a rebase-conflict bounce of a
+ *     just-completed item — US #10). The stuck lock wins the human's attention;
+ *     the `main` record wins dependency resolution. NOT corruption, never cleared
+ *     here (a human resolves it via `resume`/`requeue`/`release-lock`).
+ *   - `main` is NOT terminal + a lock is held         → the NORMAL in-flight
+ *     state (`kept-in-flight`); the lock is doing its job, leave it.
+ *   - no lock at all                                   → `no-lock` (at rest).
+ *
+ * Best-effort + idempotent: it NEVER throws (a fetch/read fault degrades to
+ * `error`, leaving the lock untouched — the safe direction), and re-running it
+ * on an already-reconciled item is a clean `no-lock`. The clear is the SAME
+ * leased delete {@link releaseItemLock} uses, so it cannot race off a concurrent
+ * change.
+ *
+ * BROADENED CONTRACT (leased-delete-rejection arm, task
+ * `reaper-no-lock-outcome-benign-not-lost`, promote-slice follow-up
+ * `reconcile-item-lock-broadened-contract-audit`, review 2026-06-20): when the
+ * SHARED leased delete is REJECTED (the arbiter ref moved between our read and
+ * our write) this function performs an EXTRA `git ls-remote <arbiter> <ref>`
+ * round-trip to distinguish the two rejection sub-cases, and applies to ALL
+ * callers — NOT only the reaper:
+ *   - REMOTE REF IS EMPTY (a concurrent reaper / release-lock / requeue cleared
+ *     the SAME stale lock first): the desired end state — benign. This function
+ *     ALSO `git update-ref -d`s the LOCAL stale tracking ref as a SIDE-EFFECT
+ *     (so a subsequent read in this clone sees the correct deleted state; a
+ *     non-pruning fetch would otherwise leave a dangling local ref), then
+ *     returns `no-lock`. Note the outcome-shape change: this rejection USED TO
+ *     surface as `error` — it now surfaces as `no-lock` for EVERY caller. A
+ *     caller that keys recovery / surfacing off `error` on this arm must be
+ *     audited (see the follow-up task's `## Decisions` block).
+ *   - REMOTE REF STILL EXISTS AT A DIFFERENT SHA (a genuine concurrent mutation
+ *     — e.g. a racer just marked it `stuck`): back off rather than force —
+ *     `error`.
+ * Because the function name reads "reconcile" (read-style), the local
+ * `update-ref -d` is a deliberate SIDE-EFFECT on the local clone's refs — it
+ * only fires on this specific rejection arm and is otherwise invisible.
+ */
+export declare function reconcileItemLockAgainstMain(opts: ReleaseOptions): Promise<ReconcileResult>;
+/**
+ * The READ-ONLY classifier behind {@link reconcileItemLockAgainstMain}: it derives
+ * the SAME {@link ReconcileOutcome} verdict, but NEVER mutates the arbiter — it
+ * does NOT clear a stale-active lock, it only REPORTS that the lock IS
+ * reconcilable. This is what the `gc --ledger` stuck-lock report keys off (the
+ * forward-pointer's wiring): per the no-auto-sweep ADR rule, the plain report
+ * surfaces a stale-active lock as `cleared-stale`-eligible WITHOUT clearing it —
+ * a human still asserts the clear via `release-lock` (or runs complete's recovery,
+ * which DOES clear via {@link reconcileItemLockAgainstMain}). The classification
+ * is identical so the report and the recovery never disagree about WHAT a lock is;
+ * only the ACTION differs (report vs clear).
+ *
+ * A `cleared-stale` outcome here therefore means "would be cleared by recovery /
+ * `release-lock`" (the lock is terminal-on-`main` + `active` = stale), NOT that
+ * anything was cleared. Best-effort + never throws (a fetch/read fault degrades to
+ * `error`).
+ */
+export declare function classifyItemLockAgainstMain(opts: ReleaseOptions): Promise<ReconcileResult>;
+/** One lingering lock in the `gc --ledger` stuck-lock REPORT: the held entry plus
+ * the read-only cross-substrate {@link ReconcileOutcome} classification of it
+ * against the authoritative `main` durable record (held/stuck vs stale-active over
+ * a terminal item). Reported, NEVER cleared by the report itself. */
+export interface LockReportEntry {
+    /** The full held lock entry (action × state + holder/since/reason). */
+    lock: LockEntry;
+    /** The lock ref (`refs/dorfl/lock/<entry>`). */
+    ref: string;
+    /**
+     * The READ-ONLY {@link classifyItemLockAgainstMain} verdict:
+     *   - `kept-in-flight` — a normal in-flight hold (not terminal on `main`).
+     *   - `kept-stuck`     — terminal on `main` + `stuck` (the `done`+`stuck`
+     *     co-existence; wins the human's attention, never cleared here).
+     *   - `cleared-stale`  — terminal on `main` + `active` = a STALE lock the report
+     *     names as reconcilable; a human clears it via `release-lock` (NOT
+     *     auto-cleared by the report — no auto-sweep).
+     *   - `error`          — a per-item classification fault (kept verbatim).
+     */
+    reconcile: ReconcileOutcome;
+}
+/** The `gc --ledger` stuck/orphaned-lock REPORT (prd
+ * `ledger-status-per-item-lock-refs` US #14): every lingering per-item lock on the
+ * arbiter, each classified read-only against `main`. An EMPTY list = no locks held
+ * (an absent ref namespace reads as `[]`, the recoverable "all locks released"
+ * state — US #12). The report NEVER clears anything. */
+export interface ItemLockReport {
+    locks: LockReportEntry[];
+}
+/**
+ * Build the `gc --ledger` stuck/orphaned-lock REPORT (prd
+ * `ledger-status-per-item-lock-refs` US #12/#13/#14; ADR
+ * `ledger-status-on-per-item-lock-refs`): enumerate every per-item lock currently
+ * held on the arbiter ({@link listItemLockEntries} — held active + stuck, with
+ * holder/since/reason) and classify EACH read-only against the authoritative
+ * `main` durable record via {@link classifyItemLockAgainstMain} (the wiring the
+ * `complete-lock-then-durable-main-move-crash-safe` task's
+ * `reconcileItemLockAgainstMain` had no production caller for). This is the
+ * generalisation of the (now-retired) advancing-marker report from advancing-only
+ * to the UNIFIED lock (the `gc --ledger` stuck-lock report).
+ *
+ * It is a REPORT, never a sweep: it CLEARS nothing (no liveness heartbeat, no
+ * auto-sweep — the same trust model as the advancing report; a human asserts a
+ * lock is dead via `release-lock`). A stale-active lock over a terminal-on-`main`
+ * item is surfaced as `cleared-stale`-eligible ("reconcilable") but left in place.
+ *
+ * Best-effort + degrades safely: an absent lock-ref namespace ⇒ an EMPTY report
+ * ({@link listItemLockEntries} returns `[]`) — so a deleted lock ref reads as "all
+ * locks released" (recoverable; work is safe on the `work/<slug>` branches +
+ * `main`).
+ */
+export declare function reportItemLocks(cwd: string, arbiter?: string, env?: NodeJS.ProcessEnv): Promise<ItemLockReport>;
+/**
+ * Format the `gc --ledger` stuck/orphaned-lock REPORT for the terminal: one block
+ * per lingering lock (entry, action/state, holder, since, the stuck `reason`, the
+ * read-only `main`-reconciliation note, and a copy-pasteable `release-lock`
+ * hint). An EMPTY report yields NO lines (a clean lock set is silent here, like
+ * the duplicate-slug surface). It REPORTS only — the matching wording makes the
+ * no-auto-sweep contract explicit (a human asserts a lock is dead).
+ */
+/**
+ * Does the `gc --ledger` lock report contain a lock that NEEDS HUMAN ATTENTION
+ * (prd US#14/#21; ADR `ledger-status-on-per-item-lock-refs`: this surface is the
+ * STUCK / crash-orphaned lock, NOT every held one)? TRUE iff some lock is
+ * `kept-stuck` (terminal-on-`main` + stuck) or `cleared-stale`-eligible
+ * (terminal-on-`main` + a stale active orphan). A `kept-in-flight` (active,
+ * non-terminal) lock is the NORMAL in-flight state of a healthy concurrent build
+ * (read by `status` as healthy) and does NOT count — so a routine `gc --ledger`
+ * health check whose only locks are healthy in-flight holds exits 0. This is the
+ * fail-loud EXIT predicate for the gc lock surface (the report itself still lists
+ * every held lock, in-flight ones informationally).
+ */
+export declare function itemLockReportNeedsAttention(report: ItemLockReport): boolean;
+export declare function formatItemLockReport(report: ItemLockReport): string[];
+/** Per-lock outcome of the human-invoked {@link reapStaleItemLocks} SWEEP:
+ *   - `reaped`         — a `cleared-stale` lock (terminal-on-main + active) cleared
+ *                        via the SHARED leased delete.
+ *   - `already-reaped` — BENIGN: the lock was already gone by the time the sweep
+ *                        re-read the ref (`no-lock`) — another reaper / a
+ *                        `release-lock` / a `requeue` got there first; the ref is
+ *                        at the desired end state. NOT `lost` and does NOT count
+ *                        as needs-attention (see the exit-code contract recorded
+ *                        in this task's done record).
+ *   - `kept-stuck`     — left untouched (terminal + stuck — human attention; US #10).
+ *   - `kept-in-flight` — left untouched (active, non-terminal — a healthy build).
+ *   - `lost`           — a `cleared-stale` candidate whose leased delete was REJECTED
+ *                        (the ref changed concurrently to a DIFFERENT value);
+ *                        REPORTED, never `--force`d.
+ *   - `error`          — a per-item classification/clear fault (left untouched). */
+export type ReapOutcome = 'reaped' | 'already-reaped' | 'kept-stuck' | 'kept-in-flight' | 'lost' | 'error';
+/** One lock's disposition in the {@link ReapReport}. */
+export interface ReapEntry {
+    /** The full lock entry as the report saw it (action × state + holder/since). */
+    lock: LockEntry;
+    /** The lock ref (`refs/dorfl/lock/<entry>`). */
+    ref: string;
+    /** What the sweep DID with this lock. */
+    outcome: ReapOutcome;
+    /** A human-readable note (the clear message, or why it was kept). */
+    message: string;
+}
+/** The result of {@link reapStaleItemLocks}: every held lock with what the sweep
+ * did to it, plus convenience counts. A lock NEEDS HUMAN ATTENTION after the sweep
+ * iff it is `kept-stuck` or `lost` (a `cleared-stale` whose leased delete lost the
+ * race); a `kept-in-flight` is the normal healthy state and does NOT. */
+export interface ReapReport {
+    entries: ReapEntry[];
+    reaped: number;
+    /** BENIGN already-reaped count: the sweep found the ref already gone (`no-lock`)
+     * — another reaper / release-lock / requeue cleared it first. The desired end
+     * state; NOT `lost`, does NOT contribute to needs-attention / a non-zero exit. */
+    alreadyReaped: number;
+    kept: number;
+    lost: number;
+}
+/**
+ * The OPT-IN `gc --ledger --reap-stale-locks` SWEEP (prd
+ * `ledger-status-per-item-lock-refs` US #14): a human asserting "clear the dead
+ * TERMINAL locks now", so one command sweeps every orphaned terminal lock instead
+ * of N hand-run `release-lock`s. It is the WRITE twin of {@link reportItemLocks}
+ * (the default report-only surface): it enumerates the SAME held locks, classifies
+ * each read-only, and for EXACTLY the `cleared-stale` class (terminal-on-`main` +
+ * `active` = stranded) performs the SHARED leased delete via
+ * {@link reconcileItemLockAgainstMain} (the recovery's clear, re-checked fresh per
+ * item) — there is NO parallel clear mechanism.
+ *
+ * SCOPE FENCE (the trust model the default preserves):
+ *   - it clears ONLY `cleared-stale`. A `kept-stuck` (terminal + stuck — human
+ *     attention) and a `kept-in-flight` (active + non-terminal — a healthy build)
+ *     are NEVER reaped, even here. Because each clear goes through
+ *     {@link reconcileItemLockAgainstMain}, which RE-reads + RE-classifies before
+ *     deleting, a lock that turned stuck/in-flight between the report and the sweep
+ *     is still safe (reconcile returns `kept-*`, not a delete).
+ *   - the clear is a LEASED delete: a concurrent change to the ref makes it REJECT
+ *     (`lost`), reported — never a blind `--force`.
+ *
+ * The DEFAULT `gc --ledger` (no flag) never calls this: it stays report-only,
+ * fail-loud, delete-nothing. This is gated behind the explicit `--reap-stale-locks`
+ * flag (a human authorising the clear), exactly as `release-lock`'s trust model.
+ */
+export declare function reapStaleItemLocks(cwd: string, arbiter?: string, env?: NodeJS.ProcessEnv): Promise<ReapReport>;
+/**
+ * Does a {@link reapStaleItemLocks} sweep leave a lock that STILL needs human
+ * attention? TRUE iff some entry is `kept-stuck` (a stuck lock the reaper rightly
+ * left) or `lost`/`error` (a `cleared-stale` whose leased delete lost the race, or
+ * an unresolvable fault). A `reaped` (successfully cleared) or a `kept-in-flight`
+ * (healthy build) lock does NOT count — so a sweep that cleared every stale lock
+ * and left only healthy in-flight holds exits 0. This is the post-sweep analogue of
+ * {@link itemLockReportNeedsAttention}.
+ */
+export declare function reapReportNeedsAttention(report: ReapReport): boolean;
+/**
+ * Format the `gc --ledger --reap-stale-locks` sweep for the terminal: a header
+ * line with the reaped/kept counts, then one line per lock (what was reaped vs
+ * kept vs lost). An EMPTY sweep (no locks held) yields NO lines (silent, like the
+ * report). The wording keeps the no-blind-force contract explicit.
+ */
+export declare function formatReapReport(report: ReapReport): string[];
+/**
+ * Convert a type-encoded lock `<entry>` (`<type>-<slug>`) back into the namespaced
+ * item form (`<namespace>:<slug>`) that {@link lockEntryFor} /
+ * {@link resolveSidecarIdentity} accept — so the report's suggested `release-lock`
+ * command is copy-pasteable and the classifier can re-key off the SAME identity.
+ * Unknown prefixes fall back to the raw entry (still copyable). The inverse of
+ * {@link lockEntryFor} for the three known namespaces.
+ */
+export declare function itemFromLockEntry(entry: string): string;
+/** List the entries (`<type>-<slug>`) currently locked on the arbiter (the
+ * stuck-lock report / `status` read path). */
+export declare function listItemLocks(cwd: string, arbiter?: string, env?: NodeJS.ProcessEnv): Promise<string[]>;
+/**
+ * Read the FULL lock entries currently held on the arbiter — the `status`/`scan`
+ * in-flight read path (prd `ledger-status-per-item-lock-refs` US #8; task
+ * `needs-attention-as-stuck-lock-state`). One fetch of the lock refs, then read
+ * each held entry's `lock.md` blob, returning the parsed {@link LockEntry} for
+ * every ref (so a caller can surface `active` (in-progress) and `stuck`
+ * (needs-attention) holds + their reasons WITHOUT N fetches). Sorted by `entry`.
+ * Best-effort: a fetch/read fault yields an EMPTY list, so the read-only
+ * `status`/`scan` views degrade to "no in-flight locks" rather than erroring
+ * (parity with {@link heldTaskSlugs}).
+ */
+export declare function listItemLockEntries(cwd: string, arbiter?: string, env?: NodeJS.ProcessEnv): Promise<LockEntry[]>;
+/**
+ * List the TASK slugs currently lock-held on the arbiter — the held-slug set the
+ * `ready/` pool readers SUBTRACT (prd `ledger-status-per-item-lock-refs` US #15;
+ * task `claim-acquires-unified-lock-no-body-move`). Enumerates {@link listItemLocks}
+ * and keeps only the `task-<slug>` entries (a prd/observation lock does not gate
+ * the TASK pool), mapping each to its bare `<slug>`.
+ *
+ * LOAD-BEARING since the lock cut-over: the claim NO LONGER moves the body to
+ * `in-progress/` (it stays in the pool on `main`; the held lock IS the claim), so
+ * this held-slug set is the ONLY signal that keeps a claimed / in-flight item out
+ * of the eligible pool, NOT the redundant subtraction it was while the body-move
+ * still removed claimed items.
+ *
+ * GRACEFUL (fail-OPEN) by design — this is the SURFACE reader: a fetch fault
+ * yields an EMPTY set so the read-only `status`/`scan` views degrade to "no
+ * in-flight locks" rather than erroring. That is WRONG for SELECTION (an empty set
+ * on a read FAULT lets a continuously-held in-flight item leak back into the
+ * eligible pool → re-claimed → empty diff → spurious `stuck`). The SELECTION path
+ * must instead use {@link heldTaskSlugsStrict}, which THROWS on a read fault so
+ * the caller can fail CLOSED (refuse to enumerate an untrusted pool) rather than
+ * subtract nothing. This graceful variant delegates to the strict one and only
+ * swallows the fault.
+ */
+export declare function heldTaskSlugs(cwd: string, arbiter?: string, env?: NodeJS.ProcessEnv): Promise<Set<string>>;
+/**
+ * STRICT (fail-CLOSED) twin of {@link heldTaskSlugs} for the SELECTION path: read
+ * the held TASK slugs from the arbiter and THROW on any read fault (offline / dead
+ * arbiter / unreadable lock refs) instead of degrading to an empty set. The
+ * held-lock set lives ONLY on the arbiter and is the LOAD-BEARING signal that
+ * keeps a claimed / in-flight item out of the eligible pool, so a SELECTION read
+ * that cannot reach the arbiter must NOT pretend "no locks held" — it must fail so
+ * the caller refuses to enumerate a pool it cannot trust (the
+ * `scan-cwd-selection-pool-read-local-skips-held-lock-subtraction-offline-must-fail`
+ * decision: offline selection FAILS, there is no `--local` fallback). The
+ * read-only surface keeps the graceful {@link heldTaskSlugs}.
+ */
+export declare function heldTaskSlugsStrict(cwd: string, arbiter?: string, env?: NodeJS.ProcessEnv): Promise<Set<string>>;
+/**
+ * Parse a serialised lock entry body back into a {@link LockEntry} — the exact
+ * inverse of {@link serialiseLockEntry}. Reads the two-axis state from the
+ * frontmatter and, for a stuck entry, the FULL reason prose + any questions from
+ * the body (`## Reason` / `## Questions`). Tolerates a LEGACY entry whose reason
+ * lived in a one-line frontmatter `reason:` field (the pre-cutover shape) so a
+ * lock written by an older binary still reads.
+ */
+export declare function parseLockEntry(body: string): LockEntry | undefined;
+/**
+ * Advisory holder id: git user.name, else $USER, else a uuid fragment. Exported
+ * as {@link resolveLockHolder} so callers (e.g. claim's stale-lock self-heal) can
+ * resolve THE SAME holder string the lock would stamp, to compare against a held
+ * entry's `holder` without duplicating the resolution order.
+ */
+export declare function resolveLockHolder(cwd: string, env?: NodeJS.ProcessEnv): Promise<string>;
+//# sourceMappingURL=item-lock.d.ts.map

package/dist/item-lock.d.ts.map

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