dorfl 0.0.0 → 0.1.0

package/dist/tasking-eligibility.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Pure tasking-eligibility resolution — the auto-task decision layer, one level
+ * UP from the build gate (`eligibility.ts`). No I/O: callers pass in the prd's
+ * two autonomy axes (`humanOnly`, `needsAnswers`), the repo's `autoTask` policy,
+ * the prd's `taskedAfter` slugs, and the set of slugs whose prds are already
+ * TASKED (resolved against `work/prds/tasked/` residence, NOT `work/done/`).
+ *
+ * This mirrors the build-gate shape deliberately (CONTEXT.md / the `auto-slice`
+ * prd): the same `needsAnswers !== true && humanOnly !== true && <repo policy>`
+ * predicate, applied to a prd's two axes + the repo's `autoTask` toggle — and a
+ * cross-prd ordering check that resolves against tasked-ness rather than done-ness.
+ */
+import type { HumanOnlyGate } from './eligibility.js';
+export type { HumanOnlyGate };
+/** Resolution of a prd's `taskedAfter` against the set of already-tasked prds. */
+export interface TaskedAfterResult {
+    /** True when every listed prd is already tasked. */
+    satisfied: boolean;
+    /** Listed prd slugs not yet tasked, in declaration order. */
+    missing: string[];
+}
+export interface TaskingEligibilityInput {
+    /** Autonomy axis 1 (DECIDED): a human must drive THIS prd's tasking. */
+    humanOnly: HumanOnlyGate;
+    /** Autonomy axis 2 (DISCOVERED): the prd has unresolved questions. */
+    needsAnswers: HumanOnlyGate;
+    /** Cross-prd order: prd slugs that must already be tasked before this one. */
+    taskedAfter: string[];
+    /** Slugs of prds that are already TASKED (residence in `work/prds/tasked/`). */
+    taskedSlugs: Set<string>;
+    /** Per-repo policy: may an agent auto-task *undeclared* prds in this repo? */
+    autoTask: boolean;
+    /**
+     * The target was named EXPLICITLY by the operator (`do prd:<slug>`), so the
+     * `autoTask` POLICY is already satisfied — naming the prd IS the authorization,
+     * exactly as `do <task>` builds a named task regardless of `autoBuild` (the
+     * `autoBuild` precedent: the pool/scan gates the policy, the explicit claim path
+     * never re-checks it). When `true`, the policy term drops from the gate and ONLY
+     * the prd's own readiness axes (`humanOnly`/`needsAnswers`) + `taskedAfter` bind.
+     * Defaults `false` (the AUTO-PICK pool path, where the `autoTask` policy DOES
+     * gate). The pool is the single policy-enforcement point; the per-invocation gate
+     * applies the policy only when NOT explicit.
+     */
+    explicit?: boolean;
+}
+export interface TaskingEligibilityResult {
+    /** Taskable now = gate passes AND every `taskedAfter` prd is already tasked. */
+    taskable: boolean;
+    /** Whether the autonomy gate alone passes (agent-taskable on its own axes). */
+    gatePass: boolean;
+    taskedAfter: TaskedAfterResult;
+}
+/**
+ * Resolve the tasking autonomy gate: agent-taskable iff `needsAnswers` is not
+ * `true` AND `humanOnly` is not `true` AND the repo's `autoTask` POLICY is
+ * satisfied — where the policy is satisfied either by the repo's `autoTask`
+ * toggle being on (the AUTO-PICK pool path) OR by the target being named
+ * EXPLICITLY (`explicit: true` — `do prd:<slug>`, where naming IS the
+ * authorization, mirroring `do <task>` vs `autoBuild`). Both readiness axes
+ * block orthogonally and are never agent-taskable regardless of policy; a human
+ * is never bound by either. The exact mirror of `resolveGate` (the build gate),
+ * one level up.
+ */
+export declare function resolveTaskGate(humanOnly: HumanOnlyGate, needsAnswers: HumanOnlyGate, autoTask: boolean, explicit?: boolean): boolean;
+/**
+ * Resolve a prd's `taskedAfter` against the slugs of prds already TASKED (NOT
+ * `done/`): satisfied iff every listed prd is present in `taskedSlugs`. An
+ * untasked blocker ⇒ not yet taskable (so this prd's emitted tasks can
+ * reference the real slugs of those prds' tasks).
+ */
+export declare function resolveTaskedAfter(taskedAfter: string[], taskedSlugs: Set<string>): TaskedAfterResult;
+/** Combine the tasking gate and `taskedAfter` resolution into a verdict. */
+export declare function resolveTaskingEligibility(input: TaskingEligibilityInput): TaskingEligibilityResult;
+//# sourceMappingURL=tasking-eligibility.d.ts.map

package/dist/tasking-eligibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasking-eligibility.d.ts","sourceRoot":"","sources":["../src/tasking-eligibility.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,kBAAkB,CAAC;AAEpD,YAAY,EAAC,aAAa,EAAC,CAAC;AAE5B,kFAAkF;AAClF,MAAM,WAAW,iBAAiB;IACjC,oDAAoD;IACpD,SAAS,EAAE,OAAO,CAAC;IACnB,6DAA6D;IAC7D,OAAO,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,uBAAuB;IACvC,wEAAwE;IACxE,SAAS,EAAE,aAAa,CAAC;IACzB,sEAAsE;IACtE,YAAY,EAAE,aAAa,CAAC;IAC5B,8EAA8E;IAC9E,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,gFAAgF;IAChF,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACzB,8EAA8E;IAC9E,QAAQ,EAAE,OAAO,CAAC;IAClB;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,wBAAwB;IACxC,gFAAgF;IAChF,QAAQ,EAAE,OAAO,CAAC;IAClB,+EAA+E;IAC/E,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,iBAAiB,CAAC;CAC/B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC9B,SAAS,EAAE,aAAa,EACxB,YAAY,EAAE,aAAa,EAC3B,QAAQ,EAAE,OAAO,EACjB,QAAQ,UAAQ,GACd,OAAO,CAOT;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CACjC,WAAW,EAAE,MAAM,EAAE,EACrB,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,GACtB,iBAAiB,CAGnB;AAED,4EAA4E;AAC5E,wBAAgB,yBAAyB,CACxC,KAAK,EAAE,uBAAuB,GAC5B,wBAAwB,CAa1B"}

package/dist/tasking-eligibility.js

@@ -0,0 +1,52 @@
+/**
+ * Pure tasking-eligibility resolution — the auto-task decision layer, one level
+ * UP from the build gate (`eligibility.ts`). No I/O: callers pass in the prd's
+ * two autonomy axes (`humanOnly`, `needsAnswers`), the repo's `autoTask` policy,
+ * the prd's `taskedAfter` slugs, and the set of slugs whose prds are already
+ * TASKED (resolved against `work/prds/tasked/` residence, NOT `work/done/`).
+ *
+ * This mirrors the build-gate shape deliberately (CONTEXT.md / the `auto-slice`
+ * prd): the same `needsAnswers !== true && humanOnly !== true && <repo policy>`
+ * predicate, applied to a prd's two axes + the repo's `autoTask` toggle — and a
+ * cross-prd ordering check that resolves against tasked-ness rather than done-ness.
+ */
+/**
+ * Resolve the tasking autonomy gate: agent-taskable iff `needsAnswers` is not
+ * `true` AND `humanOnly` is not `true` AND the repo's `autoTask` POLICY is
+ * satisfied — where the policy is satisfied either by the repo's `autoTask`
+ * toggle being on (the AUTO-PICK pool path) OR by the target being named
+ * EXPLICITLY (`explicit: true` — `do prd:<slug>`, where naming IS the
+ * authorization, mirroring `do <task>` vs `autoBuild`). Both readiness axes
+ * block orthogonally and are never agent-taskable regardless of policy; a human
+ * is never bound by either. The exact mirror of `resolveGate` (the build gate),
+ * one level up.
+ */
+export function resolveTaskGate(humanOnly, needsAnswers, autoTask, explicit = false) {
+    if (needsAnswers === true || humanOnly === true) {
+        return false;
+    }
+    // EXPLICIT naming satisfies the policy term (the build path's autoBuild
+    // precedent); otherwise the repo's autoTask toggle gates the auto-pick pool.
+    return explicit || autoTask;
+}
+/**
+ * Resolve a prd's `taskedAfter` against the slugs of prds already TASKED (NOT
+ * `done/`): satisfied iff every listed prd is present in `taskedSlugs`. An
+ * untasked blocker ⇒ not yet taskable (so this prd's emitted tasks can
+ * reference the real slugs of those prds' tasks).
+ */
+export function resolveTaskedAfter(taskedAfter, taskedSlugs) {
+    const missing = taskedAfter.filter((slug) => !taskedSlugs.has(slug));
+    return { satisfied: missing.length === 0, missing };
+}
+/** Combine the tasking gate and `taskedAfter` resolution into a verdict. */
+export function resolveTaskingEligibility(input) {
+    const gatePass = resolveTaskGate(input.humanOnly, input.needsAnswers, input.autoTask, input.explicit);
+    const taskedAfter = resolveTaskedAfter(input.taskedAfter, input.taskedSlugs);
+    return {
+        taskable: gatePass && taskedAfter.satisfied,
+        gatePass,
+        taskedAfter,
+    };
+}
+//# sourceMappingURL=tasking-eligibility.js.map

package/dist/tasking-eligibility.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tasking-eligibility.js","sourceRoot":"","sources":["../src/tasking-eligibility.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AA+CH;;;;;;;;;;GAUG;AACH,MAAM,UAAU,eAAe,CAC9B,SAAwB,EACxB,YAA2B,EAC3B,QAAiB,EACjB,QAAQ,GAAG,KAAK;IAEhB,IAAI,YAAY,KAAK,IAAI,IAAI,SAAS,KAAK,IAAI,EAAE,CAAC;QACjD,OAAO,KAAK,CAAC;IACd,CAAC;IACD,wEAAwE;IACxE,6EAA6E;IAC7E,OAAO,QAAQ,IAAI,QAAQ,CAAC;AAC7B,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,kBAAkB,CACjC,WAAqB,EACrB,WAAwB;IAExB,MAAM,OAAO,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;IACrE,OAAO,EAAC,SAAS,EAAE,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,OAAO,EAAC,CAAC;AACnD,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,yBAAyB,CACxC,KAA8B;IAE9B,MAAM,QAAQ,GAAG,eAAe,CAC/B,KAAK,CAAC,SAAS,EACf,KAAK,CAAC,YAAY,EAClB,KAAK,CAAC,QAAQ,EACd,KAAK,CAAC,QAAQ,CACd,CAAC;IACF,MAAM,WAAW,GAAG,kBAAkB,CAAC,KAAK,CAAC,WAAW,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;IAC7E,OAAO;QACN,QAAQ,EAAE,QAAQ,IAAI,WAAW,CAAC,SAAS;QAC3C,QAAQ;QACR,WAAW;KACX,CAAC;AACH,CAAC"}

package/dist/tasking-lock.d.ts

@@ -0,0 +1,111 @@
+/** A semantic label for the lock-acquire outcome (never the verdict itself). */
+export type AcquireTaskingLockOutcome = 'acquired' | 'usage-error' | 'lost' | 'contended';
+/** Maps onto the claim-CAS exit codes (identical semantics). */
+export type AcquireTaskingLockExitCode = 0 | 1 | 2 | 3;
+export interface AcquireTaskingLockOptions {
+    /** The prd slug to lock (`work/prds/ready/<slug>.md`). */
+    slug: string;
+    /** Working clone/worktree the lock acquire runs in. */
+    cwd: string;
+    /** Name of the arbiter remote (`--arbiter`). Defaults to `origin`. */
+    arbiter?: string;
+    /** Advisory locker id. Defaults to git user.name, then $USER. */
+    by?: string;
+    /** Cap on push retries when main merely advanced. Default 3. (Unified lock is retry-free; retained for API parity.) */
+    retries?: number;
+    /** Show the intended acquire without mutating the arbiter (`--dry-run`). */
+    dryRun?: boolean;
+    /** Environment for child git processes. */
+    env?: NodeJS.ProcessEnv;
+    /** Sink for human-readable progress notes. */
+    note?: (message: string) => void;
+}
+export interface AcquireTaskingLockResult {
+    exitCode: AcquireTaskingLockExitCode;
+    outcome: AcquireTaskingLockOutcome;
+    /** Human-readable summary of the terminal condition. */
+    message: string;
+    /**
+     * On a successful acquire (`acquired`), the git BLOB sha of the prd body that
+     * the lock TOOK (`work/prds/ready/<slug>.md` on the arbiter). This IS the snapshot the
+     * tasker reads + tasks from; the integrate transition compares the current
+     * `work/prds/ready/<slug>.md` blob against it to fail loud on a concurrent edit (the
+     * read-stability backstop). `undefined` unless `outcome === 'acquired'` (and on
+     * dry-run, where nothing was published).
+     */
+    lockedBlob?: string;
+}
+/**
+ * Acquire the tasking lock for `slug`: take the item's unified `action: task`
+ * lock (a parentless ref CAS). Never throws for the expected "lost the race"
+ * (exit 2) case — it is returned. Usage/environment problems surface as exit 1; a
+ * held lock is exit 0.
+ */
+export declare function acquireTaskingLock(options: AcquireTaskingLockOptions): Promise<AcquireTaskingLockResult>;
+/** A semantic label for the lock-release outcome. */
+export type ReleaseTaskingLockOutcome = 'released' | 'usage-error' | 'lost' | 'contended' | 'stale';
+/** Maps onto the claim-CAS exit codes, plus `4` for a STALE (conflicting) lock. */
+export type ReleaseTaskingLockExitCode = 0 | 1 | 2 | 3 | 4;
+export interface ReleaseTaskingLockOptions {
+    /** The prd slug whose lock to release. */
+    slug: string;
+    /** Working clone/worktree the release runs in. */
+    cwd: string;
+    /** Name of the arbiter remote (`--arbiter`). Defaults to `origin`. */
+    arbiter?: string;
+    /**
+     * The git BLOB sha the lock TOOK ({@link AcquireTaskingLockResult.lockedBlob}).
+     * RETAINED for API parity; the content-identity stale check now lives at the
+     * integrate seam (`tasking.ts` `heldSpecIsStale`), which runs BEFORE the
+     * completing commit. The release itself no longer reads the held body (there is
+     * no `tasking/` marker), so it does not consult this.
+     */
+    lockedBlob?: string;
+    /** Advisory releaser id. Defaults to git user.name, then $USER. */
+    by?: string;
+    /** Cap on push retries when main merely advanced. Default 3. */
+    retries?: number;
+    /**
+     * The tasker review→edit LOOP's **decomposition-unclear** verdict
+     * (`slicer-review-edit-loop`), or the task-SET acceptance gate's `block`:
+     * instead of DELETING the lock (returning the prd to the claimable/taskable
+     * pool), amend it `active → stuck` with this reason recorded on the entry,
+     * emitting NO guessed tasks. The prd body stays in `work/prds/ready/` (it never moved
+     * under the lock); the stuck lock IS the tasking needs-attention surface (no
+     * `work/needs-attention/` folder write), so it is NOT re-taskable until a human
+     * resolves it via `release-lock`/`resume`. Omitted ⇒ the normal release DELETES
+     * the lock ref.
+     */
+    routeToNeedsAttention?: {
+        reason: string;
+    };
+    /** Environment for child git processes. */
+    env?: NodeJS.ProcessEnv;
+    /** Sink for human-readable progress notes. */
+    note?: (message: string) => void;
+}
+export interface ReleaseTaskingLockResult {
+    exitCode: ReleaseTaskingLockExitCode;
+    outcome: ReleaseTaskingLockOutcome;
+    /** Human-readable summary of the terminal condition. */
+    message: string;
+}
+/**
+ * Release the tasking lock for `slug`: DELETE the unified `action: task` lock ref
+ * (idempotent — an already-absent ref is a clean `released`). It moves NO lifecycle
+ * file: the durable `prd → prd-tasked` success move is owned by the integrate band,
+ * and the prd body never left `work/prds/ready/` under the lock, so there is no
+ * `tasking/ → prd/` restore.
+ *
+ * When `routeToNeedsAttention` is set (the tasker decomposition-unclear verdict /
+ * the task-SET acceptance gate `block`), the lock is AMENDED `active → stuck`
+ * with the reason on the entry INSTEAD of deleted — the stuck per-item lock IS the
+ * tasking needs-attention surface now (no folder write).
+ *
+ * Outcomes:
+ *   - `released` (0): the lock ref is deleted (or amended stuck), the tasking is done.
+ *   - `usage-error` (1): bad input / environment / a lock-amend fault.
+ *   - `lost` (2): the lock is not held (nothing to release).
+ */
+export declare function releaseTaskingLock(options: ReleaseTaskingLockOptions): Promise<ReleaseTaskingLockResult>;
+//# sourceMappingURL=tasking-lock.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tasking-lock.d.ts","sourceRoot":"","sources":["../src/tasking-lock.ts"],"names":[],"mappings":"AAiEA,gFAAgF;AAChF,MAAM,MAAM,yBAAyB,GAClC,UAAU,GACV,aAAa,GACb,MAAM,GACN,WAAW,CAAC;AAEf,gEAAgE;AAChE,MAAM,MAAM,0BAA0B,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEvD,MAAM,WAAW,yBAAyB;IACzC,0DAA0D;IAC1D,IAAI,EAAE,MAAM,CAAC;IACb,uDAAuD;IACvD,GAAG,EAAE,MAAM,CAAC;IACZ,sEAAsE;IACtE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iEAAiE;IACjE,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,uHAAuH;IACvH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4EAA4E;IAC5E,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,2CAA2C;IAC3C,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,8CAA8C;IAC9C,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AAED,MAAM,WAAW,wBAAwB;IACxC,QAAQ,EAAE,0BAA0B,CAAC;IACrC,OAAO,EAAE,yBAAyB,CAAC;IACnC,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAKD;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACvC,OAAO,EAAE,yBAAyB,GAChC,OAAO,CAAC,wBAAwB,CAAC,CAWnC;AAsFD,qDAAqD;AACrD,MAAM,MAAM,yBAAyB,GAClC,UAAU,GACV,aAAa,GACb,MAAM,GACN,WAAW,GACX,OAAO,CAAC;AAEX,mFAAmF;AACnF,MAAM,MAAM,0BAA0B,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAE3D,MAAM,WAAW,yBAAyB;IACzC,0CAA0C;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,kDAAkD;IAClD,GAAG,EAAE,MAAM,CAAC;IACZ,sEAAsE;IACtE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,mEAAmE;IACnE,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,gEAAgE;IAChE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;;;;;;OAUG;IACH,qBAAqB,CAAC,EAAE;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC;IACzC,2CAA2C;IAC3C,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,8CAA8C;IAC9C,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACjC;AAED,MAAM,WAAW,wBAAwB;IACxC,QAAQ,EAAE,0BAA0B,CAAC;IACrC,OAAO,EAAE,yBAAyB,CAAC;IACnC,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,kBAAkB,CACvC,OAAO,EAAE,yBAAyB,GAChC,OAAO,CAAC,wBAAwB,CAAC,CAWnC"}

package/dist/tasking-lock.js

@@ -0,0 +1,256 @@
+import { runAsync } from './git.js';
+import { acquireItemLock, releaseItemLock, markStuckItemLock, } from './item-lock.js';
+import { workItemRel } from './work-layout.js';
+/**
+ * The **tasking concurrency lock** (prd `auto-slice`, task `autoslice-lock`).
+ *
+ * Serialises *concurrent* taskers (two CI runs, or human + CI) so a prd is never
+ * double-tasked. As of the capstone cut-over (task
+ * `cutover-retire-slicing-advancing-markers-and-trim-folder-sets`, prd
+ * `ledger-status-per-item-lock-refs`; ADR `ledger-status-on-per-item-lock-refs`)
+ * the legacy `git mv work/prds/ready/<slug>.md → work/tasking/<slug>.md` MARKER on `main`
+ * is GONE: the body NEVER relocates until the durable promotion, exactly as claim
+ * no longer moves the task body (task
+ * `cutover-claim-body-stays-and-complete-sources-from-backlog`). The tasking lock
+ * is now ONLY the UNIFIED per-item lock (`refs/dorfl/lock/<entry>`,
+ * `action: task`, keyed `prd:<slug>`) — the SAME ref claim and advance use for
+ * the same item, so tasking a prd is mutually exclusive with claiming/advancing
+ * the SAME item BY CONSTRUCTION (the second acquirer loses the SAME create-only
+ * ref CAS, with NO retry budget and NO false contention). There is no transient
+ * status in `main`'s tree anymore, so a work branch cut from `main` inherits no
+ * stale `tasking/` marker.
+ *
+ * - **Acquire** ({@link acquireTaskingLock}) acquires the unified per-item lock.
+ *   A `lost` (the item is already held for implement/task/advance) makes the
+ *   tasking acquire lose DEFINITIVELY (exit 2, no retry). On a successful acquire
+ *   it returns {@link AcquireTaskingLockResult.lockedBlob}: the git blob sha of the
+ *   prd body the lock TOOK, read from `work/prds/ready/<slug>.md` on the arbiter — the
+ *   snapshot the tasker reads + tasks from, handed back so the integrate
+ *   transition can fail loud if the held prd was edited concurrently (the
+ *   read-stability backstop). A dry-run takes no lock (it mutates nothing).
+ *
+ * - **Release** ({@link releaseTaskingLock}) DELETES the unified lock ref. It
+ *   moves NO lifecycle file: the durable `prd → prd-tasked` success move is owned
+ *   by the integrate band (`tasking.ts`/`integration-core.ts`), and there is no
+ *   `tasking/ → prd/` abort bounce anymore (the body never left `prd/`). When
+ *   `routeToNeedsAttention` is set (the tasker review/edit loop's
+ *   decomposition-unclear verdict, or the task-SET acceptance gate's `block`),
+ *   release amends the lock `active → stuck` with the reason on the entry INSTEAD
+ *   of deleting it — the per-item-lock stuck state IS the tasking needs-attention
+ *   surface now (no `work/needs-attention/` folder write), consistent with the
+ *   needs-attention cut-over (task
+ *   `cutover-needs-attention-becomes-lock-stuck-recovery-surface`). A human reads
+ *   it via `dorfl status` / `gc --ledger` and resolves via
+ *   `release-lock`/`resume`.
+ *
+ * The READ-STABILITY backstop (the content-identity stale check that used to live
+ * in the release, comparing the held `work/tasking/<slug>.md` blob against the
+ * acquire-time snapshot) now lives at the integrate seam (`tasking.ts`
+ * `heldSpecIsStale`, comparing `work/prds/ready/<slug>.md`) — relocated because the
+ * completing transition, not the release, owns the commit. See
+ * `work/notes/observations/tasking-lock-does-not-stabilise-prd-content.md`.
+ *
+ * This module provides the lock PRIMITIVES only. The orchestrating `do prd:<slug>`
+ * tasking command (`tasking.ts`) acquires, drives the agent's tasking, integrates
+ * the emitted tasks + the durable `prd → prd-tasked` move, and releases. The
+ * human path (no contention) may task on `main` directly without the lock.
+ */
+const DEFAULT_ARBITER = 'origin';
+/** Raised for usage/environment errors (exit 1). */
+class TaskingLockUsageError extends Error {
+}
+/**
+ * Acquire the tasking lock for `slug`: take the item's unified `action: task`
+ * lock (a parentless ref CAS). Never throws for the expected "lost the race"
+ * (exit 2) case — it is returned. Usage/environment problems surface as exit 1; a
+ * held lock is exit 0.
+ */
+export async function acquireTaskingLock(options) {
+    const note = options.note ?? (() => { });
+    try {
+        return await runAcquire(options, note);
+    }
+    catch (err) {
+        if (err instanceof TaskingLockUsageError) {
+            return { exitCode: 1, outcome: 'usage-error', message: err.message };
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        return { exitCode: 1, outcome: 'usage-error', message };
+    }
+}
+async function runAcquire(options, note) {
+    const slug = options.slug;
+    const arbiter = options.arbiter ?? DEFAULT_ARBITER;
+    const dryRun = options.dryRun ?? false;
+    const cwd = options.cwd;
+    const env = options.env;
+    if (!slug) {
+        throw new TaskingLockUsageError('missing <slug>. usage: acquireTaskingLock({slug, cwd, arbiter})');
+    }
+    if ((await gitSoft(['rev-parse', '--git-dir'], cwd, env)).status !== 0) {
+        throw new TaskingLockUsageError('not inside a git repository');
+    }
+    if ((await gitSoft(['remote', 'get-url', arbiter], cwd, env)).status !== 0) {
+        throw new TaskingLockUsageError(`no git remote named '${arbiter}' (set one, or pass --arbiter)`);
+    }
+    const by = options.by || (await resolveBy(cwd, env));
+    // Is the prd still lockable (present in work/prds/ready/ on the arbiter's main)?
+    await gitHard(['fetch', '--quiet', arbiter], cwd, env);
+    const spec = workItemRel('specs-ready', `${slug}.md`);
+    const specBlob = await gitSoft(['rev-parse', `${arbiter}/main:${spec}`], cwd, env);
+    if (specBlob.status !== 0) {
+        const message = `'${spec}' not found on ${arbiter}/main (no such prd, or it was already moved/tasked).`;
+        note(message);
+        return { exitCode: 2, outcome: 'lost', message };
+    }
+    const lockedBlob = specBlob.stdout.trim();
+    // A dry-run takes no lock (it mutates nothing) but still reports the lockable
+    // snapshot it WOULD take.
+    if (dryRun) {
+        const message = `[dry-run] would acquire the tasking lock for '${slug}' (${spec} present on ${arbiter}/main).`;
+        note(message);
+        return { exitCode: 0, outcome: 'acquired', message, lockedBlob };
+    }
+    // Acquire the UNIFIED per-item lock (`action: task`, keyed `prd:<slug>` so it
+    // shares the ONE ref with claim/advance of the SAME item). A create-only ref
+    // CAS: the winner holds it, the loser is DEFINITIVELY `lost` (exit 2, no retry
+    // budget). No auto-steal of an orphaned lock, consistent with claim/advance and
+    // the ADR's recovery model (no liveness heartbeat / auto-sweep; a human asserts
+    // a lock is dead via `release-lock` + `gc --ledger`).
+    // MIGRATE step (prd `prd-to-spec-vocabulary-cutover-and-migration-command`):
+    // EMIT the parent-spec item identity as `spec:<slug>` so the unified per-item
+    // lock ref is `refs/dorfl/lock/spec-<slug>` (the expand-lock task made
+    // `spec:<slug>` resolve to a `spec-<slug>` entry). The resolver still ACCEPTS
+    // `prd:<slug>`, so any lock taken under the old identity stays readable; the
+    // contract task removes the legacy form.
+    const lock = await acquireItemLock({
+        item: `spec:${slug}`,
+        action: 'task',
+        cwd,
+        arbiter,
+        holder: by,
+        env,
+    });
+    if (lock.outcome === 'error') {
+        throw new TaskingLockUsageError(`failed to acquire the item lock for '${slug}': ${lock.message}`);
+    }
+    if (lock.outcome === 'lost') {
+        note(lock.message);
+        return { exitCode: 2, outcome: 'lost', message: lock.message };
+    }
+    const message = `LOCKED '${slug}' for tasking on ${arbiter} (unified lock).`;
+    note(message);
+    return { exitCode: 0, outcome: 'acquired', message, lockedBlob };
+}
+/**
+ * Release the tasking lock for `slug`: DELETE the unified `action: task` lock ref
+ * (idempotent — an already-absent ref is a clean `released`). It moves NO lifecycle
+ * file: the durable `prd → prd-tasked` success move is owned by the integrate band,
+ * and the prd body never left `work/prds/ready/` under the lock, so there is no
+ * `tasking/ → prd/` restore.
+ *
+ * When `routeToNeedsAttention` is set (the tasker decomposition-unclear verdict /
+ * the task-SET acceptance gate `block`), the lock is AMENDED `active → stuck`
+ * with the reason on the entry INSTEAD of deleted — the stuck per-item lock IS the
+ * tasking needs-attention surface now (no folder write).
+ *
+ * Outcomes:
+ *   - `released` (0): the lock ref is deleted (or amended stuck), the tasking is done.
+ *   - `usage-error` (1): bad input / environment / a lock-amend fault.
+ *   - `lost` (2): the lock is not held (nothing to release).
+ */
+export async function releaseTaskingLock(options) {
+    const note = options.note ?? (() => { });
+    try {
+        return await runRelease(options, note);
+    }
+    catch (err) {
+        if (err instanceof TaskingLockUsageError) {
+            return { exitCode: 1, outcome: 'usage-error', message: err.message };
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        return { exitCode: 1, outcome: 'usage-error', message };
+    }
+}
+async function runRelease(options, note) {
+    const slug = options.slug;
+    const arbiter = options.arbiter ?? DEFAULT_ARBITER;
+    const cwd = options.cwd;
+    const env = options.env;
+    if (!slug) {
+        throw new TaskingLockUsageError('missing <slug>. usage: releaseTaskingLock({slug, cwd, arbiter})');
+    }
+    if ((await gitSoft(['rev-parse', '--git-dir'], cwd, env)).status !== 0) {
+        throw new TaskingLockUsageError('not inside a git repository');
+    }
+    if ((await gitSoft(['remote', 'get-url', arbiter], cwd, env)).status !== 0) {
+        throw new TaskingLockUsageError(`no git remote named '${arbiter}' (set one, or pass --arbiter)`);
+    }
+    // DECOMPOSITION-UNCLEAR / TASK-GATE BLOCK: amend the lock `active → stuck` with
+    // the reason on the entry (the tasking needs-attention surface), NOT delete it.
+    // The prd body stays in `work/prds/ready/`; the stuck lock keeps it out of the
+    // taskable pool until a human resolves it (`release-lock`/`resume`).
+    if (options.routeToNeedsAttention !== undefined) {
+        // MIGRATE: EMIT `spec:<slug>` (keyed to the `spec-<slug>` lock entry).
+        const stuck = await markStuckItemLock({
+            item: `spec:${slug}`,
+            reason: options.routeToNeedsAttention.reason,
+            cwd,
+            arbiter,
+            env,
+        });
+        if (stuck.outcome === 'transitioned' || stuck.outcome === 'wrong-state') {
+            // `wrong-state` (already stuck) is a tolerated idempotent re-surface.
+            const message = `Routed the tasking of '${slug}' to needs-attention (per-item lock marked stuck).`;
+            note(message);
+            return { exitCode: 0, outcome: 'released', message };
+        }
+        if (stuck.outcome === 'not-held') {
+            const message = `'${slug}' is not locked for tasking — nothing to mark stuck.`;
+            note(message);
+            return { exitCode: 2, outcome: 'lost', message };
+        }
+        const message = `could not mark the per-item lock for '${slug}' stuck (${stuck.outcome}: ${stuck.message}).`;
+        note(message);
+        return { exitCode: 1, outcome: 'usage-error', message };
+    }
+    // NORMAL release: delete the lock ref (idempotent).
+    // MIGRATE: EMIT `spec:<slug>` (keyed to the `spec-<slug>` lock entry).
+    const released = await releaseItemLock({
+        item: `spec:${slug}`,
+        cwd,
+        arbiter,
+        env,
+    });
+    if (released.outcome === 'error') {
+        throw new TaskingLockUsageError(`failed to release the item lock for '${slug}': ${released.message}`);
+    }
+    const message = released.outcome === 'not-held'
+        ? `'${slug}' was not locked for tasking (already released).`
+        : `RELEASED the tasking lock for '${slug}' on ${arbiter}.`;
+    note(message);
+    return { exitCode: 0, outcome: 'released', message };
+}
+// --- Shared helpers -------------------------------------------------------
+/** Resolve the advisory locker: git user.name, else $USER/$USERNAME, else ''. */
+async function resolveBy(cwd, env) {
+    const name = await gitSoft(['config', 'user.name'], cwd, env);
+    if (name.status === 0 && name.stdout.trim() !== '') {
+        return name.stdout.trim();
+    }
+    const e = env ?? process.env;
+    return e.USER ?? e.USERNAME ?? '';
+}
+/** Run git, returning the raw result (no throw) — for soft checks. */
+function gitSoft(args, cwd, env) {
+    return runAsync('git', args, cwd, { env });
+}
+/** Run git; throw on non-zero (genuinely unexpected plumbing failures). */
+async function gitHard(args, cwd, env) {
+    const result = await runAsync('git', args, cwd, { env });
+    if (result.status !== 0) {
+        throw new Error(`git ${args.join(' ')} failed (exit ${result.status}): ${result.stderr.trim()}`);
+    }
+    return result;
+}
+//# sourceMappingURL=tasking-lock.js.map

package/dist/tasking-lock.js.map

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