dorfl 0.0.0 → 0.1.0

package/dist/ledger-write.d.ts

@@ -0,0 +1,330 @@
+import { type IntegrateResult, type ReviewProvider } from './integrator.js';
+import type { IntegrationMode } from './config.js';
+import { type RouteToNeedsAttentionOptions, type RouteToNeedsAttentionResult, type ReturnToBacklogOptions, type ReturnToBacklogResult, type SurfaceToNeedsAttentionOptions, type SurfaceToNeedsAttentionResult } from './needs-attention.js';
+/**
+ * The **write half** of the ledger-transition seam (ADR
+ * `docs/adr/claim-ledger-vs-protected-main.md`, status: accepted — the "Write
+ * seam"). ONE entry point — "apply this `work/` transition" — that every
+ * transition (claim / complete / needs-attention) routes through, so a FUTURE
+ * strategy could publish a transition elsewhere (e.g. a dedicated `main`-free
+ * ledger ref) without the transition call sites learning a new mechanism.
+ *
+ * It is a PURE REFACTOR: there is exactly ONE strategy ({@link
+ * currentLedgerWrite}) and it does EXACTLY what the code did before — it
+ * CAS-publishes the prepared transition commit to the arbiter's `main` with
+ * `--force-with-lease` and then verifies `<arbiter>/main` is now that commit. No
+ * mode, no config, no `ledgerMode`, no new ref.
+ *
+ * The seam stays at the SEMANTIC level: the caller hands the seam a *prepared*
+ * transition (a local branch carrying the commit, the base the ledger must still
+ * be at for the CAS, and the commit it expects to land) plus the transition
+ * KIND, and asks the seam to publish it. The public input is storage-agnostic —
+ * it does NOT name `main`; that `main` is the publish/verify target is an
+ * implementation detail of the sole strategy below.
+ *
+ * This task routes the CLAIM transition through the seam (see `claim-cas.ts`).
+ * The `complete` and `needs-attention` kinds are named here so the companion
+ * tasks route through the SAME entry point; they are not yet wired.
+ *
+ * The NEEDS-ATTENTION transition is wired here too: the abort paths in
+ * `complete.ts` (red gate, rebase conflict), the runner's stuck routing in
+ * `run.ts`, and the human `return` command all drive the
+ * `* → needs-attention` move (and its `needs-attention → backlog` re-queue)
+ * through this SAME seam rather than calling the move helpers directly. The
+ * sole strategy delegates to the folder-native mechanism in
+ * `needs-attention.ts` UNCHANGED (reason-in-the-body — WORK-CONTRACT rule 3,
+ * bounce from in-progress OR done, ONE atomic commit, optional branch push); the
+ * seam only relocates WHERE the "apply the needs-attention transition" call is
+ * expressed, so the later cherry-pick-to-`main` surfacing is built AGAINST the
+ * seam, not bolted onto the move code.
+ */
+/**
+ * The `work/` lifecycle transitions the write seam can apply.
+ *
+ * `tasking` is the legacy tasking-lock MARKER transition. It is now VESTIGIAL: the
+ * capstone cut-over (task
+ * `cutover-retire-slicing-advancing-markers-and-trim-folder-sets`) retired the
+ * `git mv work/prd/<slug>.md → work/tasking/<slug>.md` marker (the historical
+ * marker paths), so the tasking lock
+ * is the unified per-item lock ref (`tasking-lock.ts`) and no longer routes through
+ * {@link applyTransition} with this kind. The member is kept so the strategy
+ * interface and any historical reference stay valid; nothing publishes it.
+ *
+ * `advancing` is the kind {@link createItemThroughCas} (`advancing-lock.ts`) uses
+ * to publish a NEW `work/` item (the triage observation→promote path) through the
+ * SAME CAS the `claim` transition uses, keyed on the new item's identity (its
+ * path). The advancing-lock BORROW itself no longer rides this kind: the
+ * `work/advancing/<entry>.md` presence-marker is retired (the borrow is the unified
+ * `action: advance` lock ref now). So `advancing` survives only as the create-item
+ * CAS kind.
+ */
+export type LedgerTransitionKind = 'claim' | 'complete' | 'needs-attention' | 'requeue' | 'tasking' | 'advancing'
+/**
+ * The **promote** transition (prd `staging-pool-position-gate-and-trust-model`,
+ * task `pre-backlog-staging-folder-and-promote-step-a`): move a STAGED task
+ * `work/pre-backlog/<slug>.md → work/backlog/<slug>.md` to enter the
+ * agent-eligible pool. A durable `main` move, the same category as `requeue`
+ * (tree-less CAS via {@link applyTransition}). RUNNER/human-owned — no
+ * agent-facing path performs it (governing ADR
+ * `placement-is-runner-deterministic-humanonly-is-agent-judgement`).
+ */
+ | 'promote';
+/**
+ * A *prepared* COMPLETE transition the caller asks the seam to publish: a
+ * finished work branch whose code should be integrated back to the arbiter. Like
+ * {@link ApplyTransitionInput} it is storage-agnostic — it names the work branch
+ * + the integration MODE + the review provider, NOT *where* the integration
+ * lands (the sole strategy decides that; today `merge` ff's to the arbiter's
+ * `main`, `propose` pushes the branch + requests review). The caller has already
+ * done the gate / done-move / commit / rebase-onto-arbiter — the seam only
+ * APPLIES the integration of that prepared branch.
+ */
+export interface ApplyCompleteTransitionInput {
+    /** Name of the arbiter git remote the integration is published to. */
+    arbiter: string;
+    /** The prepared (gated, committed, rebased) work branch to integrate. */
+    branch: string;
+    /** Integration mode: `merge` (ff to the ledger) or `propose` (push + review). */
+    mode: IntegrationMode;
+    /** The review-request provider (propose mode); push-only `none` otherwise. */
+    provider: ReviewProvider;
+    /**
+     * **The PR-INTENT axis** (config `noPR`, ADR §6): when `true` on the propose
+     * path, push the branch but SKIP the review request (the explicit suppress-PR
+     * intent). Threaded to {@link Integrator.integrate}. Ignored in `merge` mode.
+     */
+    noPR?: boolean;
+    /**
+     * Optional single-line review-request TITLE (propose mode), threaded straight
+     * to the provider. Absent ⇒ the provider's `--fill` default (no regression).
+     */
+    title?: string;
+    /**
+     * Optional review-request BODY (propose mode) — advisory prose, gates nothing —
+     * threaded straight to the provider. Absent ⇒ the provider's `--fill` default.
+     */
+    body?: string;
+    /**
+     * **Reap the remote head branch inline after a merge lands** (the merged-branch
+     * hygiene task's part (b)). When `true` on the `merge` path, delete the remote
+     * `work/<slug>` head AFTER the work landed on `main` (provably merged, so
+     * ancestor-safe; idempotent no-op when no remote head exists). Threaded straight
+     * to {@link Integrator.integrate}. Ignored in `propose` mode (the branch is the
+     * review surface, reaped later by `gc --remote-branches`).
+     */
+    deleteMergedHead?: boolean;
+    /** Working clone/worktree the integration runs in. */
+    cwd: string;
+    /** Environment for child git processes. */
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * The outcome of asking the seam to apply (publish) a prepared COMPLETE
+ * transition. It is exactly the integration result the {@link Integrator}
+ * produces — the seam adds NO interpretation, it only relocates WHERE the
+ * "apply the complete transition" call is expressed.
+ */
+export type ApplyCompleteTransitionResult = IntegrateResult;
+/**
+ * A *prepared* NEEDS-ATTENTION transition the caller asks the seam to apply: a
+ * stuck claimed item to bounce to `work/needs-attention/` with its reason. Like
+ * the other inputs it is storage-agnostic — it names the slug, the reason prose,
+ * any surfaced questions, and an OPTIONAL arbiter to also push the branch to,
+ * NOT *where* the move commits/publishes (the sole strategy decides that: a
+ * `git mv` from whichever of in-progress/ or done/ holds the item, the
+ * reason-in-the-body, the ONE atomic commit, the optional branch push). This
+ * mirrors {@link RouteToNeedsAttentionOptions} so the move mechanism is unchanged.
+ */
+export type ApplyNeedsAttentionTransitionInput = RouteToNeedsAttentionOptions;
+/**
+ * The outcome of asking the seam to apply a NEEDS-ATTENTION transition — the
+ * move result the folder-native mechanism produces. The RECOVERABLE branch push
+ * outcome rides on `branchPush` (the caller reads it rather than assuming
+ * "pushed" off the local move). The OBSERVABLE half is now the per-item lock
+ * `state: stuck` amend (prd `ledger-status-per-item-lock-refs`); there is no
+ * separate on-`main` surface outcome to report.
+ */
+export type ApplyNeedsAttentionTransitionResult = RouteToNeedsAttentionResult;
+/**
+ * A *prepared* RETURN-TO-BACKLOG transition: re-queue a STUCK item so it can be
+ * re-claimed — recovered from EITHER `needs-attention/` (the resolved-surface
+ * path) OR `in-progress/` (a claim that never surfaced), the slug's actual
+ * current folder resolved on the arbiter and moved to `backlog/`.
+ * Storage-agnostic, mirroring {@link ReturnToBacklogOptions}.
+ */
+export type ApplyReturnToBacklogTransitionInput = ReturnToBacklogOptions;
+/**
+ * The outcome of asking the seam to apply a RETURN-TO-BACKLOG transition. It is
+ * a Promise: like `claim`, the tree-less strategy fetches + CAS-pushes to the
+ * arbiter (async).
+ */
+export type ApplyReturnToBacklogTransitionResult = Promise<ReturnToBacklogResult>;
+/**
+ * A *prepared* TREE-LESS NEEDS-ATTENTION (surface) transition: surface a stuck
+ * AFTER-COMMIT, LEDGER-ONLY item (`in-progress/ → needs-attention/`, with the
+ * reason in the body) WITHOUT a checkout — the SURFACE-direction sibling of the
+ * tree-less requeue, sharing its exact mechanism. The work is ALREADY committed
+ * on the kept `work/<slug>` branch (intact on the arbiter, recoverable), so the
+ * surface is purely the one-file `.md` move + reason — no `pushBranch`, no
+ * worktree. Storage-agnostic, mirroring {@link SurfaceToNeedsAttentionOptions}.
+ * NOT for the wip-save / gate-failed / agent-failed surfaces (which may carry
+ * uncommitted work — those keep {@link applyNeedsAttentionTransition}, the
+ * cwd-bound path that can commit wip first).
+ */
+export type ApplyTreelessNeedsAttentionTransitionInput = SurfaceToNeedsAttentionOptions;
+/**
+ * The outcome of asking the seam to apply a TREE-LESS NEEDS-ATTENTION (surface)
+ * transition. A Promise: like `requeue`/`claim`, the tree-less strategy fetches +
+ * CAS-pushes to the arbiter (async).
+ */
+export type ApplyTreelessNeedsAttentionTransitionResult = Promise<SurfaceToNeedsAttentionResult>;
+/**
+ * A *prepared* RESOLVE-NEEDS-ATTENTION transition: a human is picking up a stuck
+ * item, so the seam must **clear the stuck state** and restore it to `active`.
+ * Storage-agnostic — it names the slug + the working clone (and an OPTIONAL
+ * arbiter to amend the lock on), NOT *where* the stuck state lives. The sole
+ * strategy clears it by amending the per-item lock `stuck → active` on the
+ * arbiter (task `cutover-needs-attention-becomes-lock-stuck-recovery-surface`).
+ */
+export interface ApplyResolveNeedsAttentionTransitionInput {
+    /** The working clone the `work/` tree lives in. */
+    cwd: string;
+    /** The slug of the stuck item to resolve back to active. */
+    slug: string;
+    /**
+     * The arbiter remote whose lock ref to amend (`stuck → active`). Omitted ⇒ a
+     * recorded no-op success (no lock ref to amend; the human-local face).
+     * Storage-agnostic: it names the remote, not `main`.
+     */
+    arbiter?: string;
+    /** Environment for child git processes. */
+    env?: NodeJS.ProcessEnv;
+    /** Sink for human-readable progress notes. */
+    note?: (message: string) => void;
+}
+/** The outcome of asking the seam to apply a RESOLVE-NEEDS-ATTENTION transition. */
+export interface ApplyResolveNeedsAttentionTransitionResult {
+    /** True iff the lock was amended back to active (or the no-arbiter no-op). */
+    moved: boolean;
+    /** When NOT moved, why (no held stuck lock, contention, …). */
+    reasonNotMoved?: string;
+}
+/**
+ * A *prepared* transition the caller asks the seam to publish. Storage-agnostic:
+ * it describes the transition semantically (a kind + a prepared local commit +
+ * the CAS lease), NOT *where* it should be published. The sole strategy decides
+ * that (today: the arbiter's `main`).
+ */
+export interface ApplyTransitionInput {
+    /** Which `work/` transition this is (claim / complete / needs-attention). */
+    kind: LedgerTransitionKind;
+    /** Name of the arbiter git remote the transition is published to. */
+    arbiter: string;
+    /** Local branch carrying the prepared transition commit (its tip = {@link head}). */
+    localBranch: string;
+    /**
+     * The ledger commit the publish must be a fast-forward FROM — the
+     * compare-and-swap lease. If the ledger has moved past this, the publish is
+     * rejected (someone else advanced it under us).
+     */
+    expectedBase: string;
+    /** The commit sha the caller expects to become the ledger tip after publish. */
+    head: string;
+    /** Working clone/worktree the publish runs in. */
+    cwd: string;
+    /** Show the intended publish 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;
+}
+/** The outcome of asking the seam to publish a prepared transition. */
+export interface ApplyTransitionResult {
+    /**
+     * `published` — the transition landed (and was verified to be the ledger tip).
+     * `rejected` — the CAS lease failed (the ledger moved under us); the caller
+     * decides whether to refetch+retry or give up. The seam never throws for this
+     * expected contended case.
+     */
+    kind: 'published' | 'rejected';
+    /** Human-readable summary of the terminal condition. */
+    message: string;
+    /**
+     * The sha that ACTUALLY landed on the ledger when `published`. The seam stamps
+     * each attempt's tip with a fresh `CAS-Nonce` trailer (so the pushed sha is
+     * unique), so the landed commit is NOT the caller's pre-nonce `head` — it is
+     * this nonce'd descendant-in-content. Callers that branch/track/report off the
+     * landed commit (e.g. `claim`'s work-branch hint) MUST use this, not their
+     * input `head`. Absent on `rejected` and on `dryRun`.
+     */
+    publishedHead?: string;
+}
+/**
+ * The write-seam interface: ONE entry point — apply (publish) a prepared `work/`
+ * transition. A future strategy implements this same interface to publish the
+ * transition elsewhere — without any transition call site changing.
+ */
+export interface LedgerWriteStrategy {
+    applyTransition(input: ApplyTransitionInput): Promise<ApplyTransitionResult>;
+    /**
+     * Apply (publish) a prepared COMPLETE transition: integrate a finished work
+     * branch back to the arbiter per its mode. The sole strategy delegates to the
+     * integration mechanism unchanged; a future strategy could integrate elsewhere
+     * without `complete.ts` changing.
+     */
+    applyCompleteTransition(input: ApplyCompleteTransitionInput): Promise<ApplyCompleteTransitionResult>;
+    /**
+     * Apply a NEEDS-ATTENTION transition: bounce a stuck claimed item to
+     * `work/needs-attention/` with its reason recorded in the body. The sole
+     * strategy delegates to the folder-native move mechanism unchanged; a future
+     * strategy could surface the stuck item elsewhere (e.g. the cherry-pick-to-
+     * `main` follow-on) without `complete.ts`/`run.ts` changing.
+     */
+    applyNeedsAttentionTransition(input: ApplyNeedsAttentionTransitionInput): Promise<ApplyNeedsAttentionTransitionResult>;
+    /**
+     * Apply a TREE-LESS NEEDS-ATTENTION (surface) transition: surface a stuck
+     * AFTER-COMMIT, LEDGER-ONLY item (`in-progress/ → needs-attention/`) WITHOUT a
+     * checkout, reusing the SAME tree-less mechanism `requeue` uses for the reverse
+     * direction. The sole strategy delegates to the tree-less surface (now a pure lock amend)
+     * (fetch + scratch-index move + throwaway-ref + leased fast-forward push). NOT
+     * for the uncommitted-wip surfaces, which keep {@link
+     * applyNeedsAttentionTransition} (the cwd-bound path that can commit wip first).
+     */
+    applyTreelessNeedsAttentionTransition(input: ApplyTreelessNeedsAttentionTransitionInput): ApplyTreelessNeedsAttentionTransitionResult;
+    /**
+     * Apply a RETURN-TO-BACKLOG transition: re-queue a STUCK item (in
+     * `needs-attention/` OR `in-progress/` — resolved on the arbiter) for
+     * re-claiming, routed through the SAME seam. Like `claim`, it is TREE-LESS —
+     * the move is a compare-and-swap push to the arbiter ref (it never writes the
+     * cwd tree).
+     */
+    applyReturnToBacklogTransition(input: ApplyReturnToBacklogTransitionInput): ApplyReturnToBacklogTransitionResult;
+    /**
+     * Apply a RESOLVE-NEEDS-ATTENTION transition: a human is picking up a stuck
+     * item, so **clear the stuck surface** and restore it to `in-progress`. The
+     * seam carries only that INTENT — "clear the surface" — NOT *how*; the sole
+     * (mode-M) strategy clears it by reverse-moving needs-attention → in-progress
+     * on the arbiter's `main`, but a future strategy could clear it differently
+     * without `start.ts` changing.
+     */
+    applyResolveNeedsAttentionTransition(input: ApplyResolveNeedsAttentionTransitionInput): Promise<ApplyResolveNeedsAttentionTransitionResult>;
+}
+/** The git trailer key the per-attempt CAS nonce rides in (greppable, round-trips). */
+export declare const CAS_NONCE_TRAILER = "CAS-Nonce";
+/**
+ * The ONLY ledger-write strategy: current behaviour. It CAS-publishes the
+ * prepared transition commit to the arbiter's `main` — the `main` push and the
+ * `--force-with-lease=main:<base>` lease live HERE, not in the public input — and
+ * verifies the arbiter's `main` is now that commit (guarding against an
+ * "Everything up-to-date" push masquerading as a successful transition). A future
+ * strategy would be a different object implementing the same interface — chosen
+ * NOWHERE today (no mode/config selects it).
+ */
+export declare const currentLedgerWrite: LedgerWriteStrategy;
+/**
+ * The active ledger-write strategy. There is exactly one (current behaviour);
+ * this indirection is the seam's single insertion point — NOT a selectable mode.
+ */
+export declare const ledgerWrite: LedgerWriteStrategy;
+//# sourceMappingURL=ledger-write.d.ts.map

package/dist/ledger-write.d.ts.map

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