dorfl 0.1.2 → 0.2.1

package/dist/item-lock.d.ts

@@ -64,26 +64,40 @@ export declare const LOCK_REF_PREFIX = "refs/dorfl/lock";
 export declare function lockEntryFor(item: string): string;
 /** The lock ref for a type-encoded `<entry>` (`<type>-<slug>`). */
 export declare function itemLockRef(entry: string): string;
+/**
+ * The character class a LITERAL lock-entry name must match to be addressable
+ * through `release-lock --entry <literal>` (task
+ * `release-lock-entry-escape-hatch-and-literal-entry-reporting`): a NON-EMPTY run
+ * of `[A-Za-z0-9._-]` — the SAME shape the minting side produces (`<type>-<slug>`,
+ * and the pre-cutover `slice-<slug>` / `prd-<slug>` entries it must be able to
+ * name). It deliberately EXCLUDES `/` and whitespace so a literal can never escape
+ * the `refs/dorfl/lock/` namespace (a `/` would address a different ref path; a
+ * space would break the push refspec). This is the ONLY validation the `--entry`
+ * escape hatch performs before the git operation — the entry name is taken
+ * literally otherwise, bypassing the namespace mapping the item-form path uses.
+ */
+export declare function isValidLockEntryName(entry: string): boolean;
 /** 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.
+ * Health of the hold. Post-CONTRACT step (task `retire-stuck-lock-state`, spec
+ * `surface-stuck-as-questions-and-retire-stuck-lock-state`) this collapses to a
+ * single value: `active` = the in-flight hold. The formerly-second value
+ * `stuck` (needs-attention) is RETIRED — a bounce now SURFACES a question
+ * sidecar + `needsAnswers:true` on `<arbiter>/main` and RELEASES the lock, so a
+ * parked item is a `needsAnswers:true` pool item on `main`, NEVER a `stuck`
+ * lock. The `state` field is kept (single-value) so serialised entries continue
+ * to round-trip and downstream readers still see a stable shape. The `reason`
+ * and `questions` fields that USED to ride on a `stuck` entry are gone — that
+ * prose lives on the surfaced sidecar on `main`, not on the lock entry.
+ */
+export type LockState = 'active';
+/**
+ * The lock entry: `action` × `state` (the state axis is now degenerate — see
+ * {@link LockState}) plus the holder/since stamps. Post-CONTRACT step (task
+ * `retire-stuck-lock-state`) it carries NO `reason`/`questions` — the sole
+ * parked-item mechanism is the surfaced `needsAnswers:true` sidecar on
+ * `<arbiter>/main`.
  */
 export interface LockEntry {
     entry: string;
@@ -91,8 +105,6 @@ export interface LockEntry {
     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. */
@@ -113,21 +125,20 @@ export interface ReleaseResult {
     message: string;
 }
 /**
- * Outcome of an AMEND-style transition (mark-stuck / resume / requeue) — the
- * lock-entry STATE MACHINE's interior moves (spec `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, …).
+ * Outcome of an AMEND-style transition (resume-crash-orphan / requeue) — the
+ * lock-entry STATE MACHINE's interior moves. Post-CONTRACT step (task
+ * `retire-stuck-lock-state`) the `mark-stuck` transition + the `wrong-state`
+ * verdict are retired with the `stuck` state itself.
+ *   - `transitioned` — we won the CAS; the entry is now at the target state
+ *                      (or removed, for requeue).
+ *   - `not-held`     — there is no entry to transition (the move's precondition
+ *                      is a held entry; absent ⇒ illegal here).
+ *   - `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, …).
  */
-export type TransitionOutcome = 'transitioned' | 'not-held' | 'wrong-state' | 'lost' | 'error';
+export type TransitionOutcome = 'transitioned' | 'not-held' | 'lost' | 'error';
 export interface TransitionResult {
     outcome: TransitionOutcome;
     /** The type-encoded lock entry (`<type>-<slug>`) the transition keyed onto. */
@@ -139,13 +150,11 @@ export interface TransitionResult {
 }
 /**
  * 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.
+ * advancing marker, so it round-trips and is previewable). Post-CONTRACT step
+ * (task `retire-stuck-lock-state`) the body carries ONLY the identity block —
+ * no `## Reason` / `## Questions` sections, because the retired `stuck` state
+ * was the only state that populated them. {@link parseLockEntry} is the inverse
+ * and tolerates a legacy body with those headings by ignoring them.
  */
 export declare function serialiseLockEntry(e: LockEntry): string;
 export interface AcquireOptions {
@@ -184,6 +193,40 @@ export interface ReleaseOptions {
  * becomes unreachable for gc. Idempotent: deleting an absent ref is `not-held`.
  */
 export declare function releaseItemLock(opts: ReleaseOptions): Promise<ReleaseResult>;
+export interface ReleaseLiteralOptions {
+    /**
+     * The LITERAL lock-entry name (`<type>-<slug>`, or a pre-cutover
+     * `slice-<slug>` / `prd-<slug>`) to release VERBATIM — taken as-is, bypassing
+     * the namespace mapping {@link lockEntryFor} applies. MUST pass
+     * {@link isValidLockEntryName}.
+     */
+    entry: string;
+    cwd: string;
+    arbiter?: string;
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * The `release-lock --entry <literal>` ESCAPE HATCH (task
+ * `release-lock-entry-escape-hatch-and-literal-entry-reporting`): release a lock
+ * whose `<entry>` name is NOT derivable from any CURRENT item-form — a lock minted
+ * BEFORE the slice→task / `prd-to-spec` vocabulary cutover (`slice-<slug>`,
+ * `prd-<slug>`), which the item-form path can no longer name because there is no
+ * item-form that produces those entries anymore.
+ *
+ * It takes the `<entry>` LITERALLY (bypassing {@link lockEntryFor} /
+ * {@link resolveSidecarIdentity}, the namespace mapping the item-form path uses)
+ * and targets `refs/dorfl/lock/<entry>` directly, then reuses the SAME entry-keyed
+ * leased-delete core {@link releaseItemLock} uses ({@link releaseLockEntry}) — the
+ * SAME lock-lease acquisition, push, absent-is-success no-op, exit codes, and
+ * mirror handling. There is NO second delete path.
+ *
+ * The trust model is UNCHANGED: a human still asserts the lock is dead by NAMING
+ * it; the only thing `--entry` drops is the assumption that the entry name is
+ * derivable from a current item-form. Rejects (`error`) an `<entry>` that fails
+ * {@link isValidLockEntryName} BEFORE any git operation, so a literal can never
+ * escape the `refs/dorfl/lock/` namespace.
+ */
+export declare function releaseLiteralLockEntry(opts: ReleaseLiteralOptions): 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). */
@@ -219,34 +262,25 @@ export declare function releaseHeldItemLock(opts: ReleaseOptions): Promise<Relea
  * 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';
+/**
+ * COMPATIBILITY SHIM (post `retire-stuck-lock-state`): the `stuck` lock STATE
+ * is retired — there is no `active → stuck` amend to perform any more, and no
+ * live path calls this. It is kept exported as a NO-OP that returns success
+ * (`transitioned` when a held entry is present, `not-held` otherwise) so
+ * downstream test suites that USED to seed a "stuck" scenario via this
+ * primitive continue to build. A shim'd `stuck` lock does NOT actually flip
+ * state; the lock stays `active` (which is the only admitted state) and any
+ * assertion that keys off `state === 'stuck'` is now vacuously false — the
+ * point of the migration.
+ */
 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.
-     */
+    reason?: string;
     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}). */
@@ -258,26 +292,29 @@ export interface ResumeOptions {
     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.
+ * resume (crash-orphan recovery only, post `retire-stuck-lock-state`): with the
+ * `stuck` lock state retired, the ONLY thing to "resume" is the crash-window
+ * orphan the ordered bounce transition (surface-FIRST-release-SECOND) leaves
+ * when the surface lands on `<arbiter>/main` but the release never runs. If the
+ * held lock is `active` AND the item is SURFACED on `<arbiter>/main`
+ * (`needsAnswers:true` + sidecar) AND not terminal, `main` is authoritative:
+ * clear the ref via the SHARED leased delete (never `--force`) so the lock
+ * converges rather than dangling forever. Every OTHER combination is a no-op
+ * from this verb's perspective: an in-flight active hold that is NOT surfaced
+ * is a healthy build (`wrong-state` — nothing to resume); no lock is
+ * `not-held`. There is no `stuck → active` transition anymore: a parked item
+ * is a `needsAnswers:true` pool item on `main`, drained by answering the
+ * sidecar (via the apply rung), not by "resuming" a lock.
  */
 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`).
+ * requeue: give up on a held lock and return the item to the pool by REMOVING
+ * the entry. Post-CONTRACT step (task `retire-stuck-lock-state`) there is NO
+ * `stuck` state to guard against — the held lock is always `active`, so
+ * requeue works on any held entry (a leased delete; a concurrent change ⇒
+ * `lost`). The body never moved (it rests in the pool on `main`), so requeue
+ * is purely "release the lock"; the kept `work/<slug>` branch remains for
+ * recovery.
  */
 export declare function requeueItemLock(opts: ReleaseOptions): Promise<TransitionResult>;
 /**
@@ -304,8 +341,13 @@ export declare function readItemLock(opts: ReleaseOptions): Promise<LockEntry |
 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 (spec `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';
+ * US #9/#10; ADR `ledger-status-on-per-item-lock-refs`). Post-CONTRACT step
+ * (task `retire-stuck-lock-state`) the two `stuck`-flavoured outcomes
+ * (`cleared-stuck-terminal`, `kept-stuck`) are gone with the state itself; a
+ * parked item is now a `needsAnswers:true` pool item on `main`, so the
+ * `cleared-stale` verdict now ALSO covers the crash-window orphan (active +
+ * surfaced-on-main). */
+export type ReconcileOutcome = 'cleared-stale' | 'kept-in-flight' | 'no-lock' | 'error';
 export interface ReconcileResult {
     outcome: ReconcileOutcome;
     /** The type-encoded lock entry (`<type>-<slug>`) reconciled. */
@@ -328,17 +370,23 @@ export interface ReconcileResult {
  * 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
+ * THE RECOVERY RULE (the `main` record is authoritative over an ORPHAN lock,
+ * broadened by task `reaper-reap-terminal-stuck-lock-orphans`; ADR
+ * `ledger-status-on-per-item-lock-refs` § Addendum 2026-07-10):
+ *   - `main` is TERMINAL + the held lock is `active` → STRANDED (the crash was
+ *     after the durable move, before the release) → CLEAR it (`cleared-stale`).
+ *   - `main` is TERMINAL + the held lock is `stuck`  → CRASH-ORPHAN (`done` +
+ *     `stuck` LEGITIMATELY co-existed during a rebase-conflict bounce, US #10,
+ *     but the item then reached its terminal folder by ANY path — human finish,
+ *     re-drive, manual fixup+merge — leaving the stuck lock as an orphan the
+ *     `main` record supersedes) → CLEAR it (`cleared-stuck-terminal`).
+ *   - `main` is NOT terminal + the held lock is `stuck` → the GENUINE
+ *     human-attention case (`kept-stuck`); NEVER auto-cleared here (a human
+ *     resolves via `resume`/`requeue`/`release-lock`). This is the invariant
+ *     the contract loosening MUST preserve.
+ *   - `main` is NOT terminal + the held lock is `active` → the NORMAL in-flight
  *     state (`kept-in-flight`); the lock is doing its job, leave it.
- *   - no lock at all                                   → `no-lock` (at rest).
+ *   - 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
@@ -388,27 +436,30 @@ export declare function reconcileItemLockAgainstMain(opts: ReleaseOptions): Prom
  * `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. */
+/** One lingering lock in the `gc --ledger` orphaned-lock REPORT: the held entry
+ * plus the read-only cross-substrate {@link ReconcileOutcome} classification of
+ * it against the authoritative `main` durable record. Reported, NEVER cleared
+ * by the report itself. */
 export interface LockReportEntry {
-    /** The full held lock entry (action × state + holder/since/reason). */
+    /** The full held lock entry (action × state + holder/since). */
     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).
+     *   - `kept-in-flight` — a normal in-flight hold (active, not terminal on `main`).
+     *   - `cleared-stale`  — the lock is reconcilable: terminal on `main` (stranded)
+     *     OR non-terminal + SURFACED (`needsAnswers:true` + sidecar) = crash-window
+     *     orphan; a reaper (or `release-lock`) clears it (NOT auto-cleared by the
+     *     report — no auto-sweep here).
      *   - `error`          — a per-item classification fault (kept verbatim).
      */
     reconcile: ReconcileOutcome;
 }
+/** True iff a {@link ReconcileOutcome} names an ORPHAN class the
+ * `--reap-stale-locks` sweep can auto-clear via the shared leased delete.
+ * Post-`retire-stuck-lock-state` this is just `cleared-stale`. */
+export declare function isReapableTerminalOrphan(outcome: ReconcileOutcome): boolean;
 /** The `gc --ledger` stuck/orphaned-lock REPORT (spec
  * `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
@@ -462,22 +513,19 @@ export declare function reportItemLocks(cwd: string, arbiter?: string, env?: Nod
  */
 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.
+/** Per-lock outcome of the human-invoked {@link reapStaleItemLocks} SWEEP.
+ * Post-`retire-stuck-lock-state` the `stuck`-flavoured verdicts
+ * (`reaped-stuck-terminal`, `kept-stuck`) are gone with the state itself.
+ *   - `reaped`         — a `cleared-stale` lock 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
+ *                        re-read the ref (`no-lock`).
+ *   - `kept-in-flight` — left untouched (active, non-terminal, not surfaced — a
+ *                        healthy build).
+ *   - `lost`           — a reapable-orphan 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';
+export type ReapOutcome = 'reaped' | 'already-reaped' | '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). */
@@ -495,10 +543,10 @@ export interface ReapEntry {
  * race); a `kept-in-flight` is the normal healthy state and does NOT. */
 export interface ReapReport {
     entries: ReapEntry[];
+    /** Count of `cleared-stale` locks reaped (terminal-on-main + active, OR
+     * non-terminal + surfaced = crash-window orphan). */
     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. */
+    /** BENIGN already-reaped count: the sweep found the ref already gone (`no-lock`). */
     alreadyReaped: number;
     kept: number;
     lost: number;
@@ -514,13 +562,19 @@ export interface ReapReport {
  * {@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).
+ * SCOPE FENCE (the trust model the default preserves; broadened by task
+ * `reaper-reap-terminal-stuck-lock-orphans`; ADR
+ * `ledger-status-on-per-item-lock-refs` § Addendum 2026-07-10):
+ *   - it clears the TWO terminal-on-`main` ORPHAN classes ONLY: `cleared-stale`
+ *     (terminal + `active` = stranded between move and release) AND
+ *     `cleared-stuck-terminal` (terminal + `stuck` = crash-orphan the auto-reaper
+ *     used to leave forever). A `kept-stuck` (STUCK + NON-terminal — the
+ *     genuine human-attention case) 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 whose item was un-completed on
+ *     `main` 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`.
  *
@@ -555,6 +609,17 @@ export declare function formatReapReport(report: ReapReport): string[];
  * {@link lockEntryFor} for the three known namespaces.
  */
 export declare function itemFromLockEntry(entry: string): string;
+/**
+ * Does `<entry>` reverse-derive to a CURRENT item-form (`<type>:<slug>`), i.e.
+ * does it carry a known post-cutover type prefix (`task-`/`spec-`/`observation-`)?
+ * FALSE for a pre-cutover `slice-<slug>` / `prd-<slug>` entry (task
+ * `release-lock-entry-escape-hatch-and-literal-entry-reporting`): such an entry is
+ * UN-NAMEABLE through the item-form `release-lock <item>` path and must be cleared
+ * via the `release-lock --entry <literal>` escape hatch instead. This is the
+ * predicate the `gc --ledger` report keys off to decide whether to print the
+ * copy-pasteable item-form hint or the literal-`--entry` hint.
+ */
+export declare function hasCurrentItemForm(entry: string): boolean;
 /** 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[]>;
@@ -574,7 +639,7 @@ export declare function listItemLockEntries(cwd: string, arbiter?: string, env?:
  * List the TASK slugs currently lock-held on the arbiter — the held-slug set the
  * `ready/` pool readers SUBTRACT (spec `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
+ * and keeps only the `task-<slug>` entries (a spec/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
@@ -609,11 +674,13 @@ export declare function heldTaskSlugs(cwd: string, arbiter?: string, env?: NodeJ
 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.
+ * inverse of {@link serialiseLockEntry}. Post-`retire-stuck-lock-state` a lock
+ * entry whose serialised state is not the single admitted `'active'` value
+ * (e.g. a legacy `state: stuck` blob written by an older binary before the
+ * one-shot migration ran) is COERCED to `'active'` on read — the state is
+ * degenerate, and a lingering stuck ref is left for the migration/recovery
+ * verbs to clear via `main`-authoritative reconciliation rather than surfaced
+ * as a second live state.
  */
 export declare function parseLockEntry(body: string): LockEntry | undefined;
 /**

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

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