dorfl 0.0.0 → 0.1.0

package/dist/scan.js

@@ -0,0 +1,374 @@
+import { resolveEligibility } from './eligibility.js';
+import { ledgerRead, } from './ledger-read.js';
+import { listMirrors } from './registry.js';
+import { fetchMirrorMainOrWarn, resolveRepoConfigFromMirror, } from './repo-mirror.js';
+import { resolveRepoConfig } from './repo-config.js';
+import { taskableSpecs } from './select-priority.js';
+import { lintLocalLedger, lintRefLedger, } from './ledger-lint.js';
+import { gatherLifecycleInPlace, gatherLifecycleMirror, } from './lifecycle-gather.js';
+import { heldTaskSlugs, listItemLockEntries, } from './item-lock.js';
+/**
+ * The CREATE-side lifecycle gates for the propose-matrix lifecycle pool, derived
+ * from a repo's resolved config. Maps the config's question-surfacing gate family
+ * onto the boolean {@link LifecyclePoolGates} `buildLifecyclePools` takes:
+ *
+ *   - `observationTriage !== 'off'` ⇒ `triage` ON (BOTH `ask` and `auto` enumerate
+ *     triage candidates into the matrix identically; the ask/auto distinction is a
+ *     DISPOSITION concern enforced LATER by the triage rung itself, not by whether
+ *     a leg exists — the matrix only decides "is there a leg at all?").
+ *   - `surfaceBlockers` ⇒ `surface` ON.
+ *
+ * `apply` is NOT a gate (CONSUME is always-on; `buildLifecyclePools` enumerates
+ * answered sidecars regardless), so a committed answer always applies even with
+ * both create-gates calm — the same create-vs-consume invariant the autopick
+ * drivers honour (ADR `ci-config-policy-and-gate-family` §4). Reused on BOTH the
+ * mirror (`scan`) and in-place (`scanRepoPaths`) substrates so the propose matrix
+ * agrees with the `advance -n` / `run` selection.
+ */
+export function lifecycleGatesFrom(config) {
+    return {
+        triage: config.observationTriage !== 'off',
+        surface: config.surfaceBlockers === true,
+        surfaceStaging: config.surfaceStaging === true,
+    };
+}
+/**
+ * Collect the set of slugs present in a repo's `work/done/`. Used to resolve
+ * `blockedBy` (per-repo only). Falls back to the filename when an item has no
+ * `slug` frontmatter. Resolves THROUGH the read seam's local-tree method
+ * ({@link ledgerRead}) — the single insertion point for the `work/` state read.
+ */
+export function readDoneSlugs(repoPath) {
+    return ledgerRead.resolveLocalState({ repoPath }).doneSlugs;
+}
+/**
+ * Read and parse every `work/tasks/ready/*.md` (the agent POOL) for a repo, sorted
+ * by slug. Resolves THROUGH the read seam's local-tree method
+ * ({@link ledgerRead}).
+ */
+export function readReadyItems(repoPath) {
+    return ledgerRead.resolveLocalState({ repoPath }).ready;
+}
+/**
+ * Resolve a per-repo `ScannedItem[]` from an already-resolved `work/` state +
+ * the repo's `autoBuild` policy. The shared core of BOTH the registry scan
+ * (mirror-ref state) and the working-tree scan (`run`/in-place) — neither learns
+ * how the `work/` state was read; they just hand it here. Exported so the
+ * MIRROR-SIDE pool scan (`mirror-pool-scan.ts`) scores the bare-mirror task pool
+ * through the EXACT same eligibility path as in-place (`do-autopick`), not a fork.
+ */
+/**
+ * Score a prd pool down to its TASKABLE subset, then label every prd with
+ * `eligibility.eligible` (true ⇔ taskable). REUSES {@link taskableSpecs} —
+ * the SAME `autoslice-gate` predicate the mirror-side `scanMirrorPool` + the
+ * in-place `do-autopick` pool already run — so what is taskable does not
+ * fork between the autopick paths and the propose-matrix `scan --json` pool.
+ * The `autoTask` gate BINDS through that predicate; a config-less repo with
+ * `autoTask` off yields an all-`eligible:false` pool (no `spec:` legs).
+ */
+export function scoreSpecs(repoPath, pool, autoTask) {
+    const taskable = new Set(taskableSpecs({
+        candidates: pool.specs.map((p) => ({
+            repoPath,
+            slug: p.slug,
+            humanOnly: p.humanOnly,
+            needsAnswers: p.needsAnswers,
+            taskedAfter: p.taskedAfter,
+        })),
+        taskedSlugs: pool.taskedSlugs,
+        autoTask,
+    }).map((p) => p.slug));
+    return pool.specs.map((p) => ({
+        slug: p.slug,
+        eligibility: { eligible: taskable.has(p.slug) },
+    }));
+}
+/**
+ * Project the shared {@link buildLifecyclePools} result (via `gatherLifecycle*`)
+ * onto the `scan --json` {@link ScannedLifecycle} shape: triage items keep only
+ * their `slug` (the `obs:` prefix is fixed in the matrix `jq`), surface/apply keep
+ * `{namespace, slug}` so the `jq` projects the right `task:`/`spec:` prefix. NOT a
+ * re-enumeration — a pure shape map over the already-gated pools.
+ *
+ * The pool items' `namespace` is the wider {@link SelectedNamespace}. SURFACE by
+ * construction only carries `'task'`/`'prd'` (an observation with no sidecar is a
+ * `triage` candidate, never `surface`), so it narrows + drops any non-task/prd
+ * defensively. APPLY additionally admits `'observation'` (an answered observation
+ * sidecar → apply), and it MUST be kept so the matrix `jq` emits its
+ * `observation:<slug>` apply leg — narrowing it away here is exactly what stranded
+ * answered observations (present in neither `triage` nor `apply`). Any OTHER
+ * namespace is still dropped defensively.
+ */
+export function toScannedLifecycle(pools) {
+    const BLOCKED_NAMESPACES = new Set(['task', 'spec', 'observation']);
+    // SURFACE stays task/spec-only; APPLY additionally keeps an answered observation.
+    const asBlocked = (items, allowObservation) => items
+        .filter((i) => i.namespace === 'task' ||
+        i.namespace === 'spec' ||
+        (allowObservation && i.namespace === 'observation'))
+        .filter((i) => BLOCKED_NAMESPACES.has(i.namespace))
+        .map((i) => ({
+        namespace: i.namespace,
+        slug: i.slug,
+    }));
+    return {
+        triage: pools.triage.map((t) => ({ slug: t.slug })),
+        surface: asBlocked(pools.surface, false),
+        apply: asBlocked(pools.apply, true),
+    };
+}
+export function scoreItems(state, autoBuild, counts, heldSlugs = new Set()) {
+    // HELD-SLUG SUBTRACTION (prd `ledger-status-per-item-lock-refs` US #15; task
+    // `claim-acquires-unified-lock-no-body-move`): exclude any pool slug whose
+    // per-item lock is currently held — the eligible pool is "in `tasks/ready/` on
+    // `main` AND no lock held".
+    //
+    // LOAD-BEARING since the lock cut-over: the claim NO LONGER moves the body to
+    // `in-progress/` (it stays at `tasks/ready/` on `main`, the held lock IS the
+    // claim), so this subtraction is the ONLY thing keeping a claimed / in-flight
+    // item out of the eligible pool, NOT the redundant belt-and-suspenders it was
+    // while the body-move still removed claimed items. An ACTIVE (in-progress) lock
+    // is a legitimate, primary claim signal here.
+    //
+    // FAIL-OPEN CAVEAT (known defect; selection should fail CLOSED): the held set
+    // is gathered by the CALLER and is EMPTY when the lock read is
+    // unavailable/offline, so a READ FAULT currently degrades to "subtract nothing"
+    // and an in-flight item can leak back into the pool (re-claimed → empty diff →
+    // spurious `stuck`). Now that the subtraction is load-bearing this is wrong for
+    // SELECTION: a failed lock read must not re-make a held item eligible. See the
+    // observation/task on fail-closed lock-read for selection.
+    return state.ready
+        .filter((item) => !heldSlugs.has(item.slug))
+        .map((item) => {
+        const eligibility = resolveEligibility({
+            humanOnly: item.humanOnly,
+            needsAnswers: item.needsAnswers,
+            blockedBy: item.blockedBy,
+            doneSlugs: state.doneSlugs,
+            autoBuild,
+        });
+        counts.totalItems++;
+        if (eligibility.eligible) {
+            counts.totalEligible++;
+        }
+        return { ...item, eligibility };
+    });
+}
+/**
+ * Read-only end-to-end scan over the REGISTRY (ADR §1): enumerate the registered
+ * hub mirrors under `<workspacesDir>/repos/`, **fetch each mirror's `main` first**
+ * (ADR §5/§6 — the remote is the source of truth in the registry model), then read
+ * each one's full `work/` lifecycle from its BARE `main` ref through the read
+ * seam's mirror method (mirrors have no working tree — `resolveLocalState`'s
+ * `readdirSync` cannot read them), and resolve eligibility per item (autonomy
+ * gate + per-repo `blockedBy`). Claims and runs nothing.
+ *
+ * **Fetch-first, never fatal:** the old "scan is always offline" invariant is
+ * RETIRED (it was the roots-local model); `scan` now refreshes each mirror's
+ * `main` before reading. A failed fetch (offline, dead arbiter) is NOT an error —
+ * it WARNS via `warn` and falls back to that mirror's last-known `main`, so the
+ * queue still reports (its freshness = the last successful fetch). This does NOT
+ * change the ledger read STRATEGY (`claim-ledger-vs-protected-main.md`): the
+ * offline read of `<mirror>/main:work/...` stays the single strategy — `scan`
+ * merely ensures that ref is fresh before reading it.
+ *
+ * Discovery is the registered hub-mirror set, NOT a config `roots` walk (there is
+ * no `roots`/`remotes` field). `scan`/`status` share the {@link listMirrors}
+ * primitive; the per-repo `work/` read goes through the seam's mirror-ref method.
+ *
+ * The autonomy gate's `autoBuild` policy is resolved PER REPO. NOTE: a bare
+ * mirror has no checked-out `.dorfl.json`, so the per-repo file cannot be
+ * read from it — the global/env-resolved policy applies (the per-repo override is
+ * a working-checkout concern, served by {@link scanRepoPaths}).
+ */
+export async function scan(config, options = {}) {
+    const mirrors = listMirrors({
+        workspacesDir: config.workspacesDir,
+        env: options.env,
+    });
+    const repos = [];
+    const counts = { totalItems: 0, totalEligible: 0 };
+    for (const mirror of mirrors) {
+        // Fetch-first (ADR §5/§6): refresh this mirror's `main` so the read below
+        // sees the remote truth. Never fatal — a failed fetch WARNS and falls back to
+        // the mirror's last-known `main` (the read strategy is unchanged).
+        fetchMirrorMainOrWarn({
+            mirrorPath: mirror.path,
+            warn: options.warn,
+            env: options.env,
+        });
+        // Read the full `work/` lifecycle from the mirror's bare `main` ref through
+        // the read seam (git ls-tree/show; NOT a working-tree read).
+        const state = await ledgerRead.resolveMirrorState({
+            mirrorPath: mirror.path,
+            env: options.env,
+        });
+        const autoBuild = resolveRepoConfig({
+            repoPath: mirror.path,
+            global: config,
+            override: options.override,
+        }).config.autoBuild;
+        // Held-slug subtraction: a bare hub mirror's arbiter is its `origin`. Reads
+        // the lock refs from the mirror's origin; non-fatal (empty set on any fault),
+        // so the read-only scan degrades gracefully exactly as its config reads do.
+        const heldSlugs = await heldTaskSlugs(mirror.path, 'origin', options.env);
+        // The PER-ITEM LOCK in-flight view (prd US #8; task
+        // `needs-attention-as-stuck-lock-state`): ADDITIONALLY read the full held
+        // lock entries (action × state + reason) from the mirror's lock refs, so the
+        // scan surfaces held (in-progress) + stuck (needs-attention) items. Read from
+        // the mirror's `origin` (the SAME handle the held-slug subtraction uses);
+        // best-effort (empty list on any fault), so the read-only scan degrades
+        // gracefully. This is a SURFACE only — eligibility/selection stay offline on
+        // `main` (the subtraction above), not gated on this view.
+        const lockHeld = await listItemLockEntries(mirror.path, 'origin', options.env);
+        // Spec pool — the TASKABLE-PRD companion of the task pool above
+        // (`ci-propose-matrix-must-enumerate-sliceable-prds-not-only-slices`). Resolve
+        // `autoTask` PER REPO from the mirror's COMMITTED `.dorfl.json`
+        // (exactly as the mirror-side pool scan does — NOT forked); a read fault is
+        // non-fatal (warn + global fall-back), since `scan` is read-only and must
+        // degrade gracefully (ADR §5/§6).
+        let repoAutoTask = config.autoTask;
+        try {
+            repoAutoTask = resolveRepoConfigFromMirror({
+                mirrorPath: mirror.path,
+                global: config,
+                env: options.env,
+                override: options.override,
+            }).autoTask;
+        }
+        catch (err) {
+            const reason = err instanceof Error ? err.message : String(err);
+            options.warn?.(`could not read the target repo's config from ${mirror.path}/main; ` +
+                `resolving autoTask from global + default. ${reason}`);
+        }
+        const specPool = await ledgerRead.resolveMirrorSpecPool({
+            mirrorPath: mirror.path,
+            env: options.env,
+        });
+        const specs = scoreSpecs(mirror.path, specPool, repoAutoTask);
+        // The per-repo LIFECYCLE pool (`ci-propose-matrix-enumerates-lifecycle-items`),
+        // gated by this mirror's question-surfacing config (resolved from its committed
+        // `.dorfl.json`, with the same non-fatal global fall-back as `autoTask`
+        // above) and computed by REUSING `gatherLifecycleMirror` → `buildLifecyclePools`
+        // (NOT a forked predicate), so it AGREES with the `run` selection.
+        let repoLifecycleConfig = {
+            observationTriage: config.observationTriage,
+            surfaceBlockers: config.surfaceBlockers,
+            surfaceStaging: config.surfaceStaging,
+        };
+        try {
+            const resolved = resolveRepoConfigFromMirror({
+                mirrorPath: mirror.path,
+                global: config,
+                env: options.env,
+                override: options.override,
+            });
+            repoLifecycleConfig = {
+                observationTriage: resolved.observationTriage,
+                surfaceBlockers: resolved.surfaceBlockers,
+                surfaceStaging: resolved.surfaceStaging,
+            };
+        }
+        catch {
+            // Non-fatal: a config read fault already WARNED on the `autoTask` read
+            // above; fall back to the global-resolved gates (scan is read-only and must
+            // degrade gracefully, ADR §5/§6).
+        }
+        const lifecycle = toScannedLifecycle(await gatherLifecycleMirror({
+            mirrorPath: mirror.path,
+            gates: lifecycleGatesFrom(repoLifecycleConfig),
+            env: options.env,
+        }));
+        // The one-slug-one-folder LINT (prd story 3): derive any slug residing in >1
+        // status folder from the mirror's committed `main` tree (the SAME `ls-tree`
+        // read the seam uses), so a corrupt ledger is surfaced LOUDLY by the formatter.
+        const ledgerDuplicates = lintRefLedger('main', mirror.path, options.env);
+        repos.push({
+            path: mirror.path,
+            items: scoreItems(state, autoBuild, counts, heldSlugs),
+            specs,
+            lifecycle,
+            ledgerDuplicates,
+            lockHeld,
+        });
+    }
+    return {
+        repos,
+        totalItems: counts.totalItems,
+        totalEligible: counts.totalEligible,
+    };
+}
+/**
+ * Read-only scan over an EXPLICIT set of working checkouts, used by the in-place
+ * worker paths (`run`) that operate on a real checkout rather than the registry's
+ * bare mirrors. This is a working-TREE read (it has nothing to fetch — the
+ * checkout IS the local state); the fetch-first contract (ADR §5/§6) applies to
+ * the REGISTRY `scan` above, which refreshes each bare mirror before reading.
+ * Reads each repo's `work/` via the read seam's local-tree method and honours its
+ * per-repo `.dorfl.json` `autoBuild`. The registry `scan` above is the
+ * mirror-ref counterpart; this is its working-tree sibling.
+ */
+export function scanRepoPaths(repoPaths, config, 
+/**
+ * The HELD-SLUG set to SUBTRACT from each repo's pool (`tasks/ready/`) (prd
+ * `ledger-status-per-item-lock-refs` US #15). This is a WORKING-TREE, OFFLINE
+ * scan (it has no arbiter handle to fetch the lock refs from — that is the
+ * registry `scan`'s job), so the held set is supplied by the in-place CALLER
+ * (which knows its arbiter) and DEFAULTS to empty: with the body still moving to
+ * `in-progress/` on claim the subtraction is redundant-but-harmless, so omitting
+ * it preserves the offline read while keeping the seam in place for task #9.
+ */
+heldSlugs = new Set(), 
+/**
+ * The per-machine {@link ConfigOverrideMap} — threaded into the per-repo
+ * resolution so the override applies to the in-place scan path too. Default:
+ * empty (no override).
+ */
+override) {
+    const repos = [];
+    const counts = { totalItems: 0, totalEligible: 0 };
+    for (const path of repoPaths) {
+        const state = ledgerRead.resolveLocalState({ repoPath: path });
+        const resolved = resolveRepoConfig({
+            repoPath: path,
+            global: config,
+            override,
+        }).config;
+        // Spec pool — the TASKABLE-PRD companion of the task pool. Resolve
+        // `autoTask` PER REPO from the working-tree `.dorfl.json` (the same
+        // way `autoBuild` is resolved); `taskableSpecs` (the SAME `autoslice-gate`
+        // predicate the autopick paths run) decides what is taskable — no forked
+        // predicate. This is what makes the propose-mode CI matrix enumerate `spec:`
+        // legs (see `ci-propose-matrix-must-enumerate-sliceable-prds-not-only-slices`).
+        const specPool = ledgerRead.resolveSpecPool({ repoPath: path });
+        const specs = scoreSpecs(path, specPool, resolved.autoTask);
+        // The per-repo LIFECYCLE pool (`ci-propose-matrix-enumerates-lifecycle-items`),
+        // gated by this working tree's `observationTriage` / `surfaceBlockers` (resolved
+        // the same way as `autoBuild`/`autoTask`) and computed by REUSING
+        // `gatherLifecycleInPlace` → `buildLifecyclePools` (NOT a forked predicate). CI
+        // runs IN-PLACE, so this is the surface the propose matrix reads.
+        const lifecycle = toScannedLifecycle(gatherLifecycleInPlace({
+            repoPath: path,
+            gates: lifecycleGatesFrom({
+                observationTriage: resolved.observationTriage,
+                surfaceBlockers: resolved.surfaceBlockers,
+                surfaceStaging: resolved.surfaceStaging,
+            }),
+        }));
+        // The one-slug-one-folder LINT over THIS working tree's `work/` ledger.
+        const ledgerDuplicates = lintLocalLedger(path);
+        repos.push({
+            path,
+            items: scoreItems(state, resolved.autoBuild, counts, heldSlugs),
+            specs,
+            lifecycle,
+            ledgerDuplicates,
+        });
+    }
+    return {
+        repos,
+        totalItems: counts.totalItems,
+        totalEligible: counts.totalEligible,
+    };
+}
+//# sourceMappingURL=scan.js.map

package/dist/scan.js.map

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

package/dist/select-order.d.ts

@@ -0,0 +1,75 @@
+/**
+ * The pure SELECTION-ORDER resolver: turn the per-repo `selectionOrder` config
+ * value (a PRESET keyword OR an explicit pool-name list) into the canonical
+ * ordered list of the FOUR orderable pools, which {@link selectPrioritised}
+ * interleaves AFTER the always-first `apply` pool.
+ *
+ * Two load-bearing rules (ADR `ci-config-policy-and-gate-family`, selection-order
+ * section; task `advance-selection-order-config`):
+ *
+ *  1. **`apply` is PINNED FIRST and is NOT nameable here.** Consuming a human's
+ *     committed answer is highest-value, cheap (no model), and someone is waiting
+ *     — deprioritizing it is never a real want (consume-always-wins). So this
+ *     resolver ranks ONLY the other four; naming `apply` in `selectionOrder` is a
+ *     LOUD usage error (it signals a misunderstanding — `apply` cannot be reordered).
+ *  2. **The value is a PRESET STRING or an explicit ORDER LIST** (the preset is
+ *     sugar over a list; the canonical form is the list). A single recognized
+ *     preset keyword EXPANDS to its list; ANYTHING else is parsed as an explicit
+ *     pool-name list, validating each name. An unknown pool name OR an unknown
+ *     single keyword FAILS LOUDLY naming the offending value.
+ *
+ * Pure: no I/O, no config read. The callers resolve `config.selectionOrder`
+ * through this, then hand the ordered list to {@link selectPrioritised}.
+ */
+/**
+ * The four ORDERABLE pools (the ones `selectionOrder` ranks). `apply` is
+ * deliberately ABSENT — it is pinned first and not configurable, so it is not a
+ * member of this union and naming it is a usage error.
+ *
+ *  - `build` — build an eligible task;
+ *  - `task` — task a taskable prd;
+ *  - `surface` — render a `needsAnswers` blocker into an answerable sidecar;
+ *  - `triage` — triage an untriaged observation.
+ */
+export type SelectionPool = 'build' | 'task' | 'surface' | 'triage';
+/** The orderable pools, in their canonical "drain" order (the default). */
+export declare const SELECTION_POOLS: readonly SelectionPool[];
+/**
+ * The recognized PRESET keywords, each sugar over an explicit pool-order list:
+ *
+ *  - `drain` (the DEFAULT) — drain ready work, then create, then ask:
+ *    `[build, task, surface, triage]`. Reproduces today's drain-first
+ *    "drain before create" default (`build` before `task`).
+ *  - `groom` — ask/groom first, build later: `[surface, triage, build, task]`.
+ *
+ * Kept deliberately SMALL (the minimize-head-space stance): a third preset earns
+ * its place only when a real need appears.
+ */
+export declare const SELECTION_ORDER_PRESETS: Record<string, readonly SelectionPool[]>;
+/** The default `selectionOrder` value when unset (the `drain` preset). */
+export declare const DEFAULT_SELECTION_ORDER = "drain";
+/**
+ * The config value a user writes for `selectionOrder`: a preset keyword (or a
+ * single explicit pool name) as a STRING, or an explicit ordered LIST of pool
+ * names (the env `'list'` coercion always yields the list form).
+ */
+export type SelectionOrderConfig = string | string[];
+/**
+ * Resolve a `selectionOrder` config value into the canonical ordered list of the
+ * four orderable pools. A single recognized preset keyword expands to its list;
+ * anything else is treated as an explicit pool-name list (each name validated).
+ *
+ * FAILS LOUDLY (throws) on:
+ *  - an unknown SINGLE keyword (not a preset AND not a pool name);
+ *  - an unknown pool name anywhere in an explicit list;
+ *  - naming `apply` (it is pinned first, not orderable);
+ *  - an empty order (no pools named);
+ *  - a duplicate pool name in an explicit list.
+ *
+ * The list form is taken VERBATIM (no implicit padding of omitted pools — a list
+ * names exactly the orderable pools the user wants, in order; an omitted pool is
+ * simply ranked nowhere, which only matters if that pool is present, see the gate
+ * orthogonality note in {@link selectPrioritised}).
+ */
+export declare function resolveSelectionOrder(value: SelectionOrderConfig): SelectionPool[];
+//# sourceMappingURL=select-order.d.ts.map

package/dist/select-order.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-order.d.ts","sourceRoot":"","sources":["../src/select-order.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;;;;GASG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEpE,2EAA2E;AAC3E,eAAO,MAAM,eAAe,EAAE,SAAS,aAAa,EAKnD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,aAAa,EAAE,CAI3E,CAAC;AAEH,0EAA0E;AAC1E,eAAO,MAAM,uBAAuB,UAAU,CAAC;AAE/C;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC;AAKrD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CACpC,KAAK,EAAE,oBAAoB,GACzB,aAAa,EAAE,CAiDjB"}

package/dist/select-order.js

@@ -0,0 +1,108 @@
+/**
+ * The pure SELECTION-ORDER resolver: turn the per-repo `selectionOrder` config
+ * value (a PRESET keyword OR an explicit pool-name list) into the canonical
+ * ordered list of the FOUR orderable pools, which {@link selectPrioritised}
+ * interleaves AFTER the always-first `apply` pool.
+ *
+ * Two load-bearing rules (ADR `ci-config-policy-and-gate-family`, selection-order
+ * section; task `advance-selection-order-config`):
+ *
+ *  1. **`apply` is PINNED FIRST and is NOT nameable here.** Consuming a human's
+ *     committed answer is highest-value, cheap (no model), and someone is waiting
+ *     — deprioritizing it is never a real want (consume-always-wins). So this
+ *     resolver ranks ONLY the other four; naming `apply` in `selectionOrder` is a
+ *     LOUD usage error (it signals a misunderstanding — `apply` cannot be reordered).
+ *  2. **The value is a PRESET STRING or an explicit ORDER LIST** (the preset is
+ *     sugar over a list; the canonical form is the list). A single recognized
+ *     preset keyword EXPANDS to its list; ANYTHING else is parsed as an explicit
+ *     pool-name list, validating each name. An unknown pool name OR an unknown
+ *     single keyword FAILS LOUDLY naming the offending value.
+ *
+ * Pure: no I/O, no config read. The callers resolve `config.selectionOrder`
+ * through this, then hand the ordered list to {@link selectPrioritised}.
+ */
+/** The orderable pools, in their canonical "drain" order (the default). */
+export const SELECTION_POOLS = [
+    'build',
+    'task',
+    'surface',
+    'triage',
+];
+/**
+ * The recognized PRESET keywords, each sugar over an explicit pool-order list:
+ *
+ *  - `drain` (the DEFAULT) — drain ready work, then create, then ask:
+ *    `[build, task, surface, triage]`. Reproduces today's drain-first
+ *    "drain before create" default (`build` before `task`).
+ *  - `groom` — ask/groom first, build later: `[surface, triage, build, task]`.
+ *
+ * Kept deliberately SMALL (the minimize-head-space stance): a third preset earns
+ * its place only when a real need appears.
+ */
+export const SELECTION_ORDER_PRESETS = {
+    drain: ['build', 'task', 'surface', 'triage'],
+    groom: ['surface', 'triage', 'build', 'task'],
+};
+/** The default `selectionOrder` value when unset (the `drain` preset). */
+export const DEFAULT_SELECTION_ORDER = 'drain';
+const POOL_SET = new Set(SELECTION_POOLS);
+const PRESET_NAMES = Object.keys(SELECTION_ORDER_PRESETS);
+/**
+ * Resolve a `selectionOrder` config value into the canonical ordered list of the
+ * four orderable pools. A single recognized preset keyword expands to its list;
+ * anything else is treated as an explicit pool-name list (each name validated).
+ *
+ * FAILS LOUDLY (throws) on:
+ *  - an unknown SINGLE keyword (not a preset AND not a pool name);
+ *  - an unknown pool name anywhere in an explicit list;
+ *  - naming `apply` (it is pinned first, not orderable);
+ *  - an empty order (no pools named);
+ *  - a duplicate pool name in an explicit list.
+ *
+ * The list form is taken VERBATIM (no implicit padding of omitted pools — a list
+ * names exactly the orderable pools the user wants, in order; an omitted pool is
+ * simply ranked nowhere, which only matters if that pool is present, see the gate
+ * orthogonality note in {@link selectPrioritised}).
+ */
+export function resolveSelectionOrder(value) {
+    // Normalise to a list of trimmed, non-empty tokens. A bare string is one token
+    // (so `'drain'` and `['drain']` resolve identically — the env single-keyword
+    // case); a list is its trimmed entries.
+    const tokens = (typeof value === 'string' ? [value] : value)
+        .map((t) => t.trim())
+        .filter((t) => t !== '');
+    // A SINGLE token that is a recognized preset keyword expands to its list. This
+    // is the ONLY place a preset is honoured: a preset keyword mixed into a
+    // multi-element list is NOT a pool name and so fails loudly below.
+    if (tokens.length === 1 && tokens[0] in SELECTION_ORDER_PRESETS) {
+        return [...SELECTION_ORDER_PRESETS[tokens[0]]];
+    }
+    if (tokens.length === 0) {
+        throw new Error(`Invalid selectionOrder: empty. Expected a preset ` +
+            `(${PRESET_NAMES.join(' / ')}) or an explicit pool-order list ` +
+            `(${SELECTION_POOLS.join(', ')}).`);
+    }
+    // Otherwise an EXPLICIT pool-name list: validate each name is a known orderable
+    // pool, failing loudly on `apply` (pinned, not orderable) or any unknown name.
+    const seen = new Set();
+    const order = [];
+    for (const token of tokens) {
+        if (token === 'apply') {
+            throw new Error(`Invalid selectionOrder: 'apply' is pinned FIRST and is not ` +
+                `orderable — remove it. selectionOrder ranks only: ` +
+                `${SELECTION_POOLS.join(', ')}.`);
+        }
+        if (!POOL_SET.has(token)) {
+            throw new Error(`Invalid selectionOrder: unknown pool '${token}'. Expected a preset ` +
+                `(${PRESET_NAMES.join(' / ')}) or pool names from: ` +
+                `${SELECTION_POOLS.join(', ')}.`);
+        }
+        if (seen.has(token)) {
+            throw new Error(`Invalid selectionOrder: duplicate pool '${token}'.`);
+        }
+        seen.add(token);
+        order.push(token);
+    }
+    return order;
+}
+//# sourceMappingURL=select-order.js.map

package/dist/select-order.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-order.js","sourceRoot":"","sources":["../src/select-order.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAcH,2EAA2E;AAC3E,MAAM,CAAC,MAAM,eAAe,GAA6B;IACxD,OAAO;IACP,MAAM;IACN,SAAS;IACT,QAAQ;CACR,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,uBAAuB,GACnC;IACC,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,CAAC;IAC7C,KAAK,EAAE,CAAC,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,CAAC;CAC7C,CAAC;AAEH,0EAA0E;AAC1E,MAAM,CAAC,MAAM,uBAAuB,GAAG,OAAO,CAAC;AAS/C,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAS,eAAe,CAAC,CAAC;AAClD,MAAM,YAAY,GAAG,MAAM,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;AAE1D;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,qBAAqB,CACpC,KAA2B;IAE3B,+EAA+E;IAC/E,6EAA6E;IAC7E,wCAAwC;IACxC,MAAM,MAAM,GAAG,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;SAC1D,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;SACpB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC;IAE1B,+EAA+E;IAC/E,wEAAwE;IACxE,mEAAmE;IACnE,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,IAAI,uBAAuB,EAAE,CAAC;QACjE,OAAO,CAAC,GAAG,uBAAuB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAChD,CAAC;IAED,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CACd,mDAAmD;YAClD,IAAI,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,mCAAmC;YAC/D,IAAI,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CACnC,CAAC;IACH,CAAC;IAED,gFAAgF;IAChF,+EAA+E;IAC/E,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,MAAM,KAAK,GAAoB,EAAE,CAAC;IAClC,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC5B,IAAI,KAAK,KAAK,OAAO,EAAE,CAAC;YACvB,MAAM,IAAI,KAAK,CACd,6DAA6D;gBAC5D,oDAAoD;gBACpD,GAAG,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CACjC,CAAC;QACH,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CACd,yCAAyC,KAAK,uBAAuB;gBACpE,IAAI,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,wBAAwB;gBACpD,GAAG,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CACjC,CAAC;QACH,CAAC;QACD,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,2CAA2C,KAAK,IAAI,CAAC,CAAC;QACvE,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAChB,KAAK,CAAC,IAAI,CAAC,KAAsB,CAAC,CAAC;IACpC,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC"}