dorfl 0.0.0 → 0.1.0

package/dist/ledger-read.d.ts

@@ -0,0 +1,357 @@
+/**
+ * The **read half** of the ledger-transition seam (ADR
+ * `docs/adr/claim-ledger-vs-protected-main.md`, status: accepted — the "Read
+ * seam"). ONE entry point — "resolve the live `work/` state for a repo" — that
+ * every reader goes through, so a FUTURE strategy could resolve some states from
+ * elsewhere (e.g. work-branch tips, a dedicated ledger ref) without each reader
+ * (`scan`, eligibility's data, readiness, the claim CAS) learning a new
+ * mechanism.
+ *
+ * It is a PURE REFACTOR: there is exactly ONE strategy ({@link currentLedgerRead})
+ * and it does EXACTLY what the code did before — the local method reads the
+ * working tree (offline, cross-repo); the arbiter method reads `<arbiter>/main`
+ * via `git show`/`ls-tree`. No mode, no config, no `ledgerMode`, no new ref, no
+ * new network read.
+ *
+ * The seam is honest about the real read sources rather than pretending they are
+ * one (per the ADR — do not collapse them):
+ *
+ *   - **local working tree** — a working clone reads `work/tasks/ready|tasks/done`
+ *     from its checkout (pool = `tasks/ready`; staging = `tasks/backlog`, surfaced
+ *     elsewhere). OFFLINE. (Pre-registry `scan`/`status` used this; `run`'s in-place
+ *     checkouts still do.)
+ *   - **arbiter `main`** — the human claim guard (`readiness`) and the claim CAS
+ *     read the task + `work/done/` from `<arbiter>/main`.
+ *   - **hub mirror `main`** — `scan`/`status` (registry model, ADR §1) read the
+ *     full `work/` lifecycle from each BARE hub mirror's `main` ref. A mirror has
+ *     no working tree, so this reads the committed tree via `git ls-tree`/`git
+ *     show` (the SAME mechanism the arbiter `done/` read uses, widened to the
+ *     full backlog set). This read itself is offline; the
+ *     fetch-first contract (ADR §5/§6 — the old "scan is always offline" invariant
+ *     is retired) lives ONE layer up in `scan`/`status`, which refresh the
+ *     mirror's `main` before calling this method. The read STRATEGY here is
+ *     unchanged either way.
+ *
+ * The signatures stay at the SEMANTIC level ("resolve live state") and storage-
+ * agnostic: the ONLY public distinction is local-vs-arbiter (no `main`/path is
+ * baked into the public shape beyond that). `gc` is NOT a consumer — its `work/`
+ * reads are job-WORKTREE discovery under `<workspacesDir>/work/*` (the execution
+ * substrate), not the `work/` lifecycle ledger this seam resolves, so it has no
+ * applicable read to route here.
+ */
+/**
+ * One agent-POOL task's parsed gate/deps, as resolved from the live `work/`
+ * state. The pool lives in `work/tasks/ready/` in the new layout (staging is
+ * `work/tasks/backlog/`); the type name follows the pool noun (`ready`) so a
+ * later reader cannot misread `backlog` as the pool.
+ */
+export interface LedgerReadyItem {
+    /** Filename within `work/tasks/ready/` (e.g. `scan.md`). */
+    file: string;
+    /** Resolved slug (frontmatter `slug:`, falling back to the filename). */
+    slug: string;
+    /** Autonomy axis 1 (DECIDED): `true` (human-only) | `undefined` (undeclared). */
+    humanOnly: boolean | undefined;
+    /** Autonomy axis 2 (DISCOVERED): `true` (open questions) | `undefined`. */
+    needsAnswers: boolean | undefined;
+    /** Slugs this item is blocked by. */
+    blockedBy: string[];
+}
+/**
+ * The result of a prd-existence read (ADR §3a): does a prd named `<slug>` exist,
+ * and where. A prd lives at `work/prds/ready/<slug>.md`; once TASKED it rests at
+ * `work/prds/tasked/<slug>.md` (the tasked resting state, the source of truth for
+ * tasked-ness — task `prd-sliced-folder-step-a`). BOTH folders are consulted (any
+ * is enough): a prd that is up-for-tasking OR already tasked still occupies its
+ * slug, so collision detection must see it. While a prd IS being tasked its body
+ * STAYS in `work/prds/ready/` (the tasking lock no longer moves it — task
+ * `cutover-retire-slicing-advancing-markers-and-trim-folder-sets`; the transient
+ * `tasking/` folder is retired, the in-flight state is the per-item lock ref), so a
+ * mid-tasking prd is detected via its `work/prds/ready/` residence. The slug is resolved
+ * from frontmatter `slug:`, falling back to the filename — the SAME shape the task
+ * readers use.
+ */
+export interface SpecExistence {
+    /**
+     * Whether a prd named `<slug>` exists in `work/prds/ready/` and/or `work/prds/tasked/`
+     * (up-for-tasking OR already tasked — either still claims the slug).
+     */
+    exists: boolean;
+    /** The spec source file, when present (`work/prds/ready/<slug>.md`). */
+    specFile: string | undefined;
+    /**
+     * The tasked resting file, when present (`work/prds/tasked/<slug>.md`) — i.e. the
+     * spec HAS BEEN tasked (the source of truth for tasked-ness, task
+     * `prd-sliced-folder-step-a`). A re-task moves it back `prds/tasked/ -> prds/ready/`.
+     */
+    specTaskedFile: string | undefined;
+}
+/**
+ * One prd enumerated for the AUTO-TASK selection pool (ADR §3 — the
+ * "tasks-first then specs to task" priority). A prd is NOT in the task
+ * scan/candidate model, so the auto-pick pool is built HERE from `work/prds/ready/`
+ * through this single shared prd read path (the same path
+ * {@link SpecExistence} uses, widened from existence to the gate axes the tasking
+ * predicate needs). The tasking-eligibility predicate (`autoslice-gate`'s
+ * `resolveTaskingEligibility`) is applied to these by the selection layer; this
+ * reader does NOT itself decide eligibility (it just surfaces the inputs).
+ */
+export interface LedgerSpecItem {
+    /** Filename within `work/prds/ready/` (e.g. `auto-slice.md`). */
+    file: string;
+    /** Resolved slug (frontmatter `slug:`, falling back to the filename). */
+    slug: string;
+    /** Autonomy axis 1 (DECIDED): `true` (human-only) | `undefined`. */
+    humanOnly: boolean | undefined;
+    /** Autonomy axis 2 (DISCOVERED): `true` (open questions) | `undefined`. */
+    needsAnswers: boolean | undefined;
+    /** Spec-only cross-prd order: prd slugs that must already be TASKED first. */
+    taskedAfter: string[];
+}
+/**
+ * The prd pool of ONE repo, resolved from `work/prds/ready/` (the auto-task candidate
+ * source). Carries every prd's gate axes PLUS the set of already-TASKED slugs so
+ * the selection layer can resolve each prd's `taskedAfter` against `work/prds/tasked/`
+ * RESIDENCE (task `prd-sliced-folder-step-a` / prd `slicing-coherence` US #9): the
+ * FOLDER is the source of truth, like `done/` for tasks (the auto-tasker reads
+ * folder-residence; the `tasked:` marker was removed in
+ * `remove-sliced-marker-step-b`). Built
+ * through the SAME prd read path as {@link SpecExistence}; there is no second prd
+ * reader.
+ */
+export interface LedgerSpecPool {
+    /** Every prd in `work/prds/ready/`, sorted by slug. */
+    specs: LedgerSpecItem[];
+    /** Slugs whose spec resides in `work/prds/tasked/` (resolves `taskedAfter`). */
+    taskedSlugs: Set<string>;
+}
+/**
+ * One OBSERVATION's lifecycle-pool fields, as resolved from `work/notes/observations/`
+ * (the triage candidate source for the advance auto-pick lifecycle pools, task
+ * `advance-autopick-lifecycle-pools`). An observation with NO `triaged:` marker is
+ * UNTRIAGED (still in the triage pool); a non-empty `triaged:` value (`keep` /
+ * `duplicate`) means it is SETTLED and DROPS OUT of the pool (US #30). This is the
+ * FIRST read of `work/notes/observations/` in the seam — `scan`/eligibility read only
+ * `backlog`/`done`/`specs*`.
+ */
+export interface LedgerObservationItem {
+    /** Filename within `work/notes/observations/` (e.g. `stray-note.md`). */
+    file: string;
+    /** Resolved slug (frontmatter `slug:`, falling back to the filename). */
+    slug: string;
+    /**
+     * The SETTLED marker (`triaged:` frontmatter): a non-empty value (`keep` /
+     * `duplicate`) drops the observation out of the triage pool; `undefined` ⇒
+     * UNTRIAGED (still a triage candidate).
+     */
+    triaged: string | undefined;
+}
+/**
+ * The live `work/` lifecycle state of ONE repo as resolved from the LOCAL
+ * working tree. Storage-agnostic in shape: it is "the resolved state", not "the
+ * files on disk".
+ */
+export interface LocalLedgerState {
+    /** Parsed `work/tasks/ready/*.md` (the agent POOL), sorted by slug. */
+    ready: LedgerReadyItem[];
+    /** Slugs present in `work/done/` (per-repo; resolves `blockedBy`). */
+    doneSlugs: Set<string>;
+    /**
+     * `work/notes/observations/*.md` items (sorted by slug) — the triage candidate source
+     * for the advance auto-pick lifecycle pools (task
+     * `advance-autopick-lifecycle-pools`). UNTRIAGED observations (no `triaged:`
+     * marker) are the triage pool; SETTLED ones (`triaged:` non-empty) drop out.
+     */
+    observations: LedgerObservationItem[];
+}
+/** The live `work/` state of ONE repo as resolved from the arbiter. */
+export interface ArbiterLedgerState {
+    /**
+     * The requested task's raw file contents from the arbiter (it may live in
+     * the POOL `tasks/ready/` or in `in-progress/`), or `undefined` when not found
+     * there.
+     */
+    task: string | undefined;
+    /** Slugs present in `work/done/` on the arbiter (per-repo; resolves `blockedBy`). */
+    doneSlugs: Set<string>;
+}
+/** What the LOCAL-tree resolve method needs: which repo checkout to read. */
+export interface ResolveLocalStateInput {
+    /** The repo working-tree root whose `work/` state to resolve. */
+    repoPath: string;
+}
+/** What the prd-existence resolve method needs: which repo + which slug. */
+export interface ResolveSpecExistenceInput {
+    /** The repo root whose `work/prds/ready/`+`work/prds/tasked/` to read. */
+    repoPath: string;
+    /** The slug to look up (matched against frontmatter `slug:`, then filename). */
+    slug: string;
+}
+/** What the prd-pool resolve method needs: which repo's `work/prds/ready/` to enumerate. */
+export interface ResolveSpecPoolInput {
+    /** The repo working-tree root whose `work/prds/ready/` to read. */
+    repoPath: string;
+}
+/**
+ * What the MIRROR-ref resolve method needs to read the full `work/` lifecycle
+ * from a BARE hub mirror's committed tree.
+ */
+export interface ResolveMirrorStateInput {
+    /** The bare hub mirror directory (`<workspacesDir>/repos/<key>.git`). */
+    mirrorPath: string;
+    /**
+     * The mirror-LOCAL ref whose `work/` tree to read (default `main`). A hub
+     * mirror is bare, so `main` is a LOCAL branch — read `main:work/...`, NOT
+     * `origin/main:work/...`.
+     */
+    ref?: string;
+    /** Environment for child git processes. */
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * What the MIRROR-ref prd-pool method needs: which bare hub mirror's committed
+ * `work/prds/ready/`+`work/prds/tasked/` tree to enumerate.
+ */
+export interface ResolveMirrorSpecPoolInput {
+    /** The bare hub mirror directory (`<workspacesDir>/repos/<key>.git`). */
+    mirrorPath: string;
+    /** The mirror-LOCAL ref whose `work/prds*` tree to read (default `main`). */
+    ref?: string;
+    /** Environment for child git processes. */
+    env?: NodeJS.ProcessEnv;
+}
+/** What the ARBITER resolve method needs to read committed `work/` state. */
+export interface ResolveArbiterStateInput {
+    /** The slug whose task file to resolve (`work/{backlog,in-progress}/<slug>.md`). */
+    slug: string;
+    /** A working clone whose remotes include the arbiter (the reads run here). */
+    cwd: string;
+    /** Name of the arbiter git remote (its `main` is the source of truth). */
+    arbiter: string;
+    /** Environment for child git processes. */
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * The read-seam interface: ONE entry with THREE resolve-methods. The local
+ * method is synchronous and OFFLINE; the arbiter and mirror methods are async
+ * (they shell out to git). A future strategy implements this same interface to
+ * resolve some states elsewhere — without any reader changing.
+ */
+export interface LedgerReadStrategy {
+    /** Resolve a repo's live `work/` state from its LOCAL working tree (offline). */
+    resolveLocalState(input: ResolveLocalStateInput): LocalLedgerState;
+    /** Resolve a repo's live `work/` state from the ARBITER (`<arbiter>/main`). */
+    resolveArbiterState(input: ResolveArbiterStateInput): Promise<ArbiterLedgerState>;
+    /**
+     * Resolve the FULL live `work/` lifecycle (backlog + done + observations) of
+     * a repo from its BARE hub mirror's `main` ref. Mirrors have no working
+     * tree, so `resolveLocalState`'s `readdirSync`/`readFileSync` cannot read them
+     * — this reads the committed tree via `git ls-tree`/`git show` (the same
+     * mechanism the arbiter method uses for `done/`, widened to the full set).
+     */
+    resolveMirrorState(input: ResolveMirrorStateInput): Promise<LocalLedgerState>;
+    /**
+     * Enumerate the repo's prd pool from a BARE hub mirror's committed `work/prds/ready/`
+     * tree (+ already-TASKED slugs from `work/prds/tasked/` residence) — the
+     * mirror-ref counterpart of {@link LedgerReadStrategy.resolveSpecPool}, for the
+     * NO-CHECKOUT mirror-side auto-pick (`run`'s isolated loop + the one-shot/CI
+     * `advance --remote -n`). A mirror is bare, so this reads the committed tree via
+     * `git ls-tree`/`git show` (the SAME mechanism {@link resolveMirrorState} uses),
+     * not a working-tree `readdirSync`. Returns the SAME {@link LedgerSpecPool} shape
+     * the working-tree reader returns, so the tasking-eligibility predicate
+     * (`taskableSpecs`) applies byte-identically to either source.
+     */
+    resolveMirrorSpecPool(input: ResolveMirrorSpecPoolInput): Promise<LedgerSpecPool>;
+    /**
+     * Resolve whether a prd named `<slug>` exists in the LOCAL working tree's
+     * `work/prds/ready/` (the prd source — where a mid-tasking prd ALSO rests now that the
+     * `tasking/` folder is retired) and/or `work/prds/tasked/` (the tasked resting
+     * state). The slug is resolved from each candidate file's frontmatter `slug:`,
+     * falling back to the filename — the SAME shape the task readers use.
+     *
+     * This is the FIRST prd read path in the seam: `ledger-read.ts`/`scan.ts` read
+     * only `backlog`/`done`, NEVER `work/prds/ready/`. It is added here
+     * so the §3a slug-namespace resolver, and later the auto-tasking / `do prd:` work,
+     * share ONE prd read path rather than each growing a bespoke scan. Synchronous
+     * and OFFLINE (a working-tree read), like {@link resolveLocalState}.
+     */
+    resolveSpecExistence(input: ResolveSpecExistenceInput): SpecExistence;
+    /**
+     * Enumerate the repo's prd pool from `work/prds/ready/` (the auto-task candidate
+     * source for the `do`/`run` "tasks-first then specs to task" priority, ADR
+     * §3). Returns every prd's gate axes (`humanOnly`/`needsAnswers`/`taskedAfter`)
+     * PLUS the set of already-TASKED slugs so the selection layer can resolve
+     * `taskedAfter` against `work/prds/tasked/` residence (the FOLDER is the source of
+     * truth) and apply `autoslice-gate`'s
+     * predicate. This is the SAME prd read path {@link resolveSpecExistence} uses,
+     * widened from a single-slug existence check to a full enumeration — NOT a
+     * second prd reader. Synchronous and OFFLINE (a working-tree read), like
+     * {@link resolveLocalState}.
+     */
+    resolveSpecPool(input: ResolveSpecPoolInput): LedgerSpecPool;
+    /**
+     * Enumerate `work/tasks/backlog/*.md` (the TASK STAGING folder) into the SAME
+     * {@link LedgerReadyItem} shape `resolveLocalState().ready` returns for the pool
+     * — the SURFACE-on-staging widening (prd
+     * `staging-surface-and-apply-promote-safety` F2). Synchronous + OFFLINE
+     * (working-tree read), like {@link resolveLocalState}. The pool / staging
+     * folders are distinct durable status folders (one-slug-one-folder — a slug
+     * is in at most one), so the two reads compose without de-duplication
+     * gymnastics. Missing folder reads as empty. CONSUMED ONLY by the lifecycle
+     * GATHER under the `surfaceStaging` gate — the BUILD/claim pool stays
+     * pool-only (`resolveLocalState().ready`), untouched by this read.
+     */
+    resolveLocalTaskStaging(input: ResolveLocalStateInput): LedgerReadyItem[];
+    /**
+     * Enumerate `work/prds/proposed/*.md` (the PRD STAGING folder) into the
+     * SAME {@link LedgerSpecItem} shape `resolveSpecPool().specs` returns for the
+     * pool — the PRD-symmetric `surfaceStaging` widening (prd
+     * `staging-surface-and-apply-promote-safety` F2, prd q4 answer). Sync + OFFLINE.
+     */
+    resolveLocalSpecStaging(input: ResolveSpecPoolInput): LedgerSpecItem[];
+    /**
+     * Enumerate `work/prds/tasked/*.md` (the TASKED resting folder) into the SAME
+     * {@link LedgerSpecItem} shape `resolveSpecPool().specs` returns. UNLIKE the pool
+     * (`prds/ready/`) and staging (`prds/proposed/`) readers, this exists so the
+     * lifecycle GATHER can surface/apply a `needsAnswers:true` prd that drifted
+     * AFTER it was tasked and rests IN PLACE in `prds/tasked/` (WORK-CONTRACT
+     * "A PRD that has drifted AFTER it was TASKED"). Without it, such a prd's
+     * ANSWERED sidecar is enumerated by no pool and the human's answer is STRANDED
+     * (observation `tasked-prd-needsanswers-sidecar-stranded-no-apply-pool`).
+     * `resolveSpecPool` deliberately returns tasked specs only as `taskedSlugs`
+     * (residence, for `taskedAfter`), NOT as enumerable gate-bearing items, so this
+     * is a SEPARATE read. Sync + OFFLINE.
+     */
+    resolveLocalSpecTasked(input: ResolveSpecPoolInput): LedgerSpecItem[];
+    /**
+     * Mirror-ref counterpart of {@link resolveLocalTaskStaging}: read
+     * `<ref>:work/tasks/backlog/*.md` from a BARE hub mirror via `git ls-tree` +
+     * `git show` (the SAME mechanism `resolveMirrorState` uses for the pool).
+     */
+    resolveMirrorTaskStaging(input: ResolveMirrorStateInput): Promise<LedgerReadyItem[]>;
+    /**
+     * Mirror-ref counterpart of {@link resolveLocalSpecStaging}: read
+     * `<ref>:work/prds/proposed/*.md` from a bare mirror.
+     */
+    resolveMirrorSpecStaging(input: ResolveMirrorSpecPoolInput): Promise<LedgerSpecItem[]>;
+    /**
+     * Mirror-ref counterpart of {@link resolveLocalSpecTasked}: read
+     * `<ref>:work/prds/tasked/*.md` from a bare mirror, so a `needsAnswers` tasked
+     * prd's answered sidecar is never stranded on the mirror-side advance path
+     * either.
+     */
+    resolveMirrorSpecTasked(input: ResolveMirrorSpecPoolInput): Promise<LedgerSpecItem[]>;
+}
+/**
+ * The ONLY ledger-read strategy: current behaviour. The local method reads the
+ * working tree (offline); the arbiter method reads `<arbiter>/main`. A future
+ * strategy would be a different object implementing the same interface — chosen
+ * NOWHERE today (no mode/config selects it).
+ */
+export declare const currentLedgerRead: LedgerReadStrategy;
+/**
+ * The active ledger-read strategy. There is exactly one (current behaviour);
+ * this indirection is the seam's single insertion point — NOT a selectable mode.
+ */
+export declare const ledgerRead: LedgerReadStrategy;
+//# sourceMappingURL=ledger-read.d.ts.map

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

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