dorfl 0.0.0 → 0.1.0

package/dist/needs-attention.d.ts

@@ -0,0 +1,341 @@
+import { type BackoffOptions, type Sleep } from './retry-backoff.js';
+export interface RouteToNeedsAttentionOptions {
+    /** The working clone / job worktree the `work/<slug>` branch lives in. */
+    cwd: string;
+    /** The slug of the in-progress item to bounce. */
+    slug: string;
+    /** Why the item is stuck (red gate, rebase conflict, ambiguity, timeout, …). */
+    reason: string;
+    /** Any questions the agent surfaced for the human, recorded under the reason. */
+    questions?: string[];
+    /**
+     * The arbiter remote to push the transition to (like the done-move). When
+     * omitted, the move is committed locally only (the caller pushes the branch as
+     * part of its own flow, e.g. the runner's integration step).
+     */
+    arbiter?: string;
+    /**
+     * The work branch to push to the arbiter (the RECOVERABLE half — see the seam
+     * docstring). DEFAULT `work/<slug>`: the build-bounce branch the wip/move
+     * commits landed on. A tasking bounce passes its own branch (`work/prds/
+     * ready-<slug>`). The supplied branch MUST be the one HEAD is on (the branch the
+     * wip/move commits landed on) — NEVER a default that differs from HEAD; a
+     * caller NOT checked out on the work branch (e.g. a temp branch off main) must
+     * be SURFACE-ONLY ({@link pushBranch} `false`) so no wrong-branch ref is
+     * pushed. Only consulted when {@link arbiter} is given and {@link pushBranch}
+     * is not `false`.
+     */
+    branch?: string;
+    /**
+     * SURFACE-ONLY when `false`: publish the ledger surface (when an `arbiter` is
+     * given) but push NO work branch. For a caller that is NOT checked out on the
+     * work branch (a throwaway temp branch off main — e.g. `start.ts`'s
+     * `routeContinueConflict`, whose real `work/<slug>` is already on the arbiter
+     * from the prior requeue). Defaults to pushing (the build-bounce common case).
+     */
+    pushBranch?: boolean;
+    /** Environment for child git processes (identity etc.). */
+    env?: NodeJS.ProcessEnv;
+    /** Sink for human-readable progress notes. */
+    note?: (message: string) => void;
+    /**
+     * Bounded-backoff bounds for the RECOVERABLE branch push (the OUTAGE-retry,
+     * NOT the instant-contention loop). Defaults to {@link DEFAULT_BACKOFF}.
+     */
+    backoff?: BackoffOptions;
+    /**
+     * Injectable sleep for the backoff (tests drive the retry timeline with NO
+     * real waits — the `run.ts` `sleep`/`realSleep` seam). Defaults to a real
+     * `setTimeout`. Threaded into {@link backoff} when the latter omits its own.
+     */
+    sleep?: Sleep;
+}
+/** The outcome of the RECOVERABLE branch push (the per-op honest report). */
+export type BranchPushOutcome = 
+/** Pushed to the arbiter (cross-machine recoverable). */
+'pushed'
+/** Skipped by the emptiness guard — nothing beyond main to recover YET. */
+ | 'skipped-empty'
+/** Retried with backoff, then gave up — saved LOCALLY only. */
+ | 'failed'
+/** No arbiter / surface-only — no push was attempted. */
+ | 'not-attempted';
+export interface RouteToNeedsAttentionResult {
+    /** True iff the item was moved + committed. */
+    moved: boolean;
+    /** When `moved`, the committed transition message (of the MOVE-ONLY commit). */
+    commitMessage?: string;
+    /**
+     * The per-op outcome of the RECOVERABLE branch push (honest reporting — the
+     * message reads THIS, never assumes "pushed" off the local move). Absent when
+     * the item did not move.
+     */
+    branchPush?: BranchPushOutcome;
+    /** When the branch push FAILED after retries, the last git error (for the report). */
+    pushError?: string;
+    /**
+     * When `moved`, the sha of the **move-only** commit — the tip of `work/<slug>`
+     * that carries PURELY the `git mv → needs-attention/` + the reason (the wip
+     * commit holding the aborted agent work sits BELOW it). A surfacing strategy
+     * cherry-picks THIS commit to make the stuck state observable, so the wip never
+     * reaches the ledger.
+     */
+    moveCommit?: string;
+    /** When NOT moved, why (e.g. the slug was not in-progress). */
+    reasonNotMoved?: string;
+}
+export interface ReturnToBacklogOptions {
+    /** The working clone the `work/` tree lives in. */
+    cwd: string;
+    /**
+     * The slug of the stuck item to re-queue — recovered from `needs-attention/`
+     * OR `in-progress/` (the actual current folder is resolved on the arbiter).
+     */
+    slug: string;
+    /** The arbiter remote to push the transition to. Optional (see above). */
+    arbiter?: string;
+    /**
+     * `requeue --reset` (the destructive opt-out): DISCARD the kept work, so the
+     * NEXT claim starts FRESH. At requeue-time — BEFORE the backlog move — delete
+     * the remote `work/<slug>` branch on `arbiter`
+     * (`git push <arbiter> --delete work/<slug>`, plain provider-agnostic git that
+     * works against a local `--bare` arbiter) and drop any stale LOCAL `work/<slug>`.
+     * Delete-before-move closes the claim-race window (no backlog item exists while
+     * the to-be-discarded branch still does). A FAILED delete ABORTS the requeue
+     * (no backlog move) — the item stays in needs-attention rather than become
+     * claimable while continuing from a branch you meant to throw away. Requires
+     * `arbiter`. Explicit/guarded — a deliberate departure from the loud "never
+     * delete the remote branch" invariant; never on the default (keep+continue)
+     * path.
+     */
+    reset?: boolean;
+    /**
+     * `requeue -m "<note>"` (the handoff note): an optional human steer for the
+     * NEXT agent. APPENDED (never overwritten) as a dated `## Requeue YYYY-MM-DD`
+     * section to the item BODY before the move — the ledger file is the durable,
+     * conflict-safe, cross-machine home (same place the needs-attention reason
+     * lives). Repeated requeues ACCUMULATE a handoff log. Applies to BOTH modes
+     * (a steer is relevant even on `--reset`).
+     */
+    message?: string;
+    /** Environment for child git processes. */
+    env?: NodeJS.ProcessEnv;
+    /** Sink for human-readable progress notes. */
+    note?: (message: string) => void;
+}
+export interface ReturnToBacklogResult {
+    /** True iff the item was moved back + committed. */
+    moved: boolean;
+    /** When `moved`, the committed transition message. */
+    commitMessage?: string;
+    /** True iff `--reset` deleted the remote `work/<slug>` branch on the arbiter. */
+    deletedRemoteBranch?: boolean;
+    /** When NOT moved, why (e.g. the slug was in neither needs-attention/ nor in-progress/, or a failed --reset delete). */
+    reasonNotMoved?: string;
+}
+export interface SurfaceToNeedsAttentionOptions {
+    /**
+     * The working clone the move is ORIGINATED from — purely the ORIGIN SOURCE
+     * (it resolves the arbiter remote + holds the object store the plumbing writes
+     * into), NEVER a write TARGET. Tree-less: the cwd index/HEAD/working tree are
+     * never touched (parity with {@link returnToBacklog}).
+     */
+    cwd: string;
+    /** The slug of the in-progress item to surface to needs-attention. */
+    slug: string;
+    /** Why the item is stuck (terminal continue-push failure, rebase conflict, …). */
+    reason: string;
+    /** Any questions the agent surfaced for the human, recorded under the reason. */
+    questions?: string[];
+    /**
+     * The arbiter remote the surface move is CAS-published to. REQUIRED — like
+     * {@link returnToBacklog}, the move is a tree-less compare-and-swap to the
+     * arbiter ref, so there is no local-only mode.
+     */
+    arbiter: string;
+    /** Environment for child git processes (identity etc.). */
+    env?: NodeJS.ProcessEnv;
+    /** Sink for human-readable progress notes. */
+    note?: (message: string) => void;
+}
+export interface SurfaceToNeedsAttentionResult {
+    /** True iff the item was surfaced (moved + CAS-published) on the arbiter. */
+    moved: boolean;
+    /** When `moved`, the committed transition message. */
+    commitMessage?: string;
+    /** When NOT moved, why (no arbiter, item not on the arbiter, contention exhausted). */
+    reasonNotMoved?: string;
+}
+/**
+ * Save the RECOVERABLE half of a stuck-item bounce (ADR §12). The RUNNER calls
+ * this; the build agent never does.
+ *
+ * **Post `ledger-status-per-item-lock-refs` cut-over (tasks 9a–9d, decision i+):**
+ * a bounce is now a PURE LOCK AMEND — the seam (`bounceToStuckLock` →
+ * `markStuckItemLock`) marks the per-item lock `state: stuck` and records the
+ * reason/questions ON THE LOCK ENTRY. There is NO `git mv` to a
+ * `needs-attention/` folder and NO on-`main` surface commit. The item body never
+ * moves (it rests in `backlog/` since claim stopped moving it, task 9a). So what
+ * REMAINS here is purely the never-lose-work half:
+ *
+ *   1. A **wip** commit on the `work/<slug>` branch tip holding whatever the agent
+ *      left uncommitted (`git add -A`). Skipped when the tree is already clean
+ *      (no aborted work to save). No bookkeeping trailer — after the cut-over NO
+ *      transient-status move-only commit lands on a branch, so a branch rebases
+ *      PLAINLY with nothing to drop (`drop-bookkeeping-rebase` is deleted, 9d).
+ *   2. Optionally PUSH the work branch to the arbiter so the saved wip travels
+ *      cross-machine and a `requeue` continues from the branch tip. BEST-EFFORT
+ *      (an unreachable arbiter leaves the local branch standing — recovery
+ *      degrades, never crashes the bounce; retried with bounded backoff on an
+ *      outage), BRANCH-PARAMETERISED (default `work/<slug>`; an explicit `branch`
+ *      overrides — the tasking bounce passes `work/prds/ready-<slug>`; `pushBranch: false`
+ *      ⇒ push NOTHING), and EMPTINESS-GUARDED (a branch with no commits beyond
+ *      main, or an absent branch, is skipped). The branch MUST be the one HEAD is
+ *      on. The work-branch push is NOT a `main` write.
+ *
+ * The stuck STATE itself (the `state: stuck` + reason/questions) is owned by the
+ * lock amend in the seam, not by this function. NEVER throws for the expected
+ * case — returns `{moved, ...}` so consumers can branch cleanly; genuine git
+ * plumbing failures still throw (they are unexpected).
+ */
+export declare function routeToNeedsAttention(options: RouteToNeedsAttentionOptions): Promise<RouteToNeedsAttentionResult>;
+export declare function returnToBacklog(options: ReturnToBacklogOptions): Promise<ReturnToBacklogResult>;
+/**
+ * **Promote a STAGED task into the agent-eligible pool** (prd
+ * `staging-pool-position-gate-and-trust-model`, task
+ * `pre-backlog-staging-folder-and-promote-step-a`, governing ADR
+ * `placement-is-runner-deterministic-humanonly-is-agent-judgement`). Moves
+ * `work/pre-backlog/<slug>.md → work/backlog/<slug>.md` as a durable `main`
+ * move, the same category as {@link returnToBacklog} (tree-less CAS via
+ * {@link runTreelessLedgerMove}). After this transition the task is in the
+ * pool and claimable.
+ *
+ * **RUNNER/human-owned.** There is no agent-facing path that performs this:
+ * the agent's tasking output lands STAGED in `work/pre-backlog/` (the runner's
+ * deterministic placement decision), and only a runner/human invocation moves
+ * it into the pool. The agent does no git here, as everywhere.
+ *
+ * Storage-agnostic: it names the slug + the arbiter, NOT *where* the move
+ * lands; the sole strategy publishes to `<arbiter>/main`. Like
+ * {@link returnToBacklog} the tree-less CAS needs a ref to push to, so an
+ * `arbiter` is REQUIRED. NEVER throws for the expected
+ * "not in pre-backlog/" / contention-exhausted cases — it returns
+ * `{moved: false, reasonNotMoved}` so callers can branch cleanly.
+ */
+export interface PromoteFromPreBacklogOptions {
+    /**
+     * The working clone the move is ORIGINATED from — purely the ORIGIN SOURCE
+     * (it resolves the arbiter remote + holds the object store the plumbing
+     * writes into), NEVER a write TARGET. Tree-less: the cwd index/HEAD/working
+     * tree are never touched (parity with {@link returnToBacklog}).
+     */
+    cwd: string;
+    /** The slug of the staged task to promote into the pool. */
+    slug: string;
+    /**
+     * The arbiter remote the promotion is CAS-published to. REQUIRED — the
+     * tree-less CAS needs a ref to push to (parity with `requeue`/`claim`).
+     */
+    arbiter: string;
+    /** Environment for child git processes (identity etc.). */
+    env?: NodeJS.ProcessEnv;
+    /** Sink for human-readable progress notes. */
+    note?: (message: string) => void;
+}
+export interface PromoteFromPreBacklogResult {
+    /** True iff the staged task was moved into the pool + committed. */
+    moved: boolean;
+    /** When `moved`, the committed transition message. */
+    commitMessage?: string;
+    /** When NOT moved, why (no such pre-backlog item, already in backlog, contention). */
+    reasonNotMoved?: string;
+}
+export declare function promoteFromPreBacklog(options: PromoteFromPreBacklogOptions): Promise<PromoteFromPreBacklogResult>;
+/**
+ * **Promote a STAGED prd into the auto-task pool** (prd
+ * `staging-pool-position-gate-and-trust-model`, task
+ * `pre-prd-staging-pool-split-and-untrusted-prd-placement`, governing ADR
+ * `placement-is-runner-deterministic-humanonly-is-agent-judgement`). The prd
+ * twin of {@link promoteFromPreBacklog}: moves
+ * `work/prds/proposed/<slug>.md → work/prds/ready/<slug>.md` as a durable `main` move
+ * (tree-less CAS via {@link runTreelessLedgerMove}). After this transition
+ * the prd is in the auto-task POOL and eligible to be auto-tasked (subject
+ * to the existing `autoTask`/`humanOnly`/`needsAnswers`/`taskedAfter` gates,
+ * which are UNCHANGED — the staging/pool split changes only WHICH folder is
+ * the auto-task pool, not the gates).
+ *
+ * **RUNNER/human-owned.** There is no agent-facing path that performs this:
+ * `intake`'s `prd` dispatch lands the prd STAGED in `work/prds/proposed/` (the
+ * runner's deterministic placement decision), and only a runner/human
+ * invocation moves it into the pool. The agent does no git here, as
+ * everywhere; this function is not reachable from any agent surface.
+ *
+ * Storage-agnostic + tree-less, exactly like {@link promoteFromPreBacklog}:
+ * cwd index/HEAD/working tree are never touched, an arbiter remote is
+ * REQUIRED, and "not in prds/proposed/" / contention-exhausted cases are returned
+ * (NEVER thrown) via `{moved: false, reasonNotMoved}` so callers branch
+ * cleanly. Idempotent: re-running after the move LANDED is a no-op success.
+ */
+export interface PromoteFromPreSpecOptions {
+    /** The working clone the move is originated from (origin source only; never written). */
+    cwd: string;
+    /** The slug of the staged prd to promote into the pool. */
+    slug: string;
+    /** The arbiter remote the promotion is CAS-published to. REQUIRED. */
+    arbiter: string;
+    /** Environment for child git processes (identity etc.). */
+    env?: NodeJS.ProcessEnv;
+    /** Sink for human-readable progress notes. */
+    note?: (message: string) => void;
+}
+export interface PromoteFromPreSpecResult {
+    /** True iff the staged prd was moved into the pool + committed. */
+    moved: boolean;
+    /** When `moved`, the committed transition message. */
+    commitMessage?: string;
+    /** When NOT moved, why (no such prds/proposed item, already in prds/ready/, contention). */
+    reasonNotMoved?: string;
+}
+export declare function promoteFromPreSpec(options: PromoteFromPreSpecOptions): Promise<PromoteFromPreSpecResult>;
+/** One staged item awaiting promotion (a task in `pre-backlog/` or a spec in `specs/proposed/`). */
+export interface PromotableItem {
+    /** `'task'` (staged in `work/pre-backlog/`) or `'spec'` (staged in `work/specs/proposed/`). */
+    namespace: 'task' | 'spec';
+    /** The slug (filename minus `.md`). */
+    slug: string;
+}
+export interface ListPromotableOptions {
+    /** The working clone the arbiter remote is resolved FROM (origin source only). */
+    cwd: string;
+    /** The arbiter remote whose `main` the staging folders are read from. REQUIRED. */
+    arbiter: string;
+    /** Environment for child git processes. */
+    env?: NodeJS.ProcessEnv;
+}
+export interface ListPromotableResult {
+    /** Every staged item awaiting promotion, tasks then prds, each sorted by slug. */
+    items: PromotableItem[];
+    /** When the listing could not run (no such remote), why. */
+    error?: string;
+}
+/**
+ * LIST every staged item awaiting a runner/human promotion — the tasks in
+ * `work/pre-backlog/` and the prds in `work/prds/proposed/` on `<arbiter>/main` (the
+ * discovery half of the `promote` verb, so `promote` with no argument answers
+ * "what is staged waiting for me?"). It reads the ARBITER's truth (a fetch + a
+ * tree read), NOT the local working tree (which may be stale) — the same source
+ * the promotion functions act against, so the list and the move never disagree.
+ * Read-only: it never fetches a checkout, never moves anything.
+ */
+export declare function listPromotable(options: ListPromotableOptions): Promise<ListPromotableResult>;
+/**
+ * Extract the prose written under the `## Needs attention` heading from an item
+ * body. Returns the first non-empty line(s) of the block as a single line
+ * (stops at the next `## ` heading); '' when no block is present. The
+ * needs-attention REASON is now recorded on the per-item lock entry (task
+ * `cutover-needs-attention-becomes-lock-stuck-recovery-surface`, decision i+),
+ * NOT in the body, but this extractor stays for any historical body text that
+ * still carries the heading (a tolerant best-effort read).
+ */
+export declare function extractReason(content: string): string;
+//# sourceMappingURL=needs-attention.d.ts.map

package/dist/needs-attention.d.ts.map

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