dorfl 0.0.0 → 0.1.0

package/dist/detect.js

@@ -0,0 +1,118 @@
+import { readdirSync, existsSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { workFolderPath, isWorkItemFile } from './work-layout.js';
+/**
+ * Discovery of `work/`-participating repos in a FOLDER. In the registry model
+ * (ADR `command-surface-and-journeys` §1) the registered set IS the hub-mirror
+ * set on disk — there is NO config `roots`/`remotes` walk. This module is no
+ * longer implicit discovery; its sole remaining job is to serve
+ * **`remote find <folder>`** (ADR §1): walk ONE folder, find the participating
+ * repos, and let the user toggle-add them. `isParticipatingRepo` is the same
+ * predicate `remote find` filters on. A repo participates when it holds dorfl
+ * WORK content in any lifecycle pool (see {@link isParticipatingRepo}), not only
+ * a non-empty `tasks/ready/`.
+ */
+/**
+ * The `work/` pools whose presence makes a repo a dorfl WORK repo. Participation
+ * is NOT "has a claimable task": a repo whose `tasks/ready/` build pool is drained
+ * but whose LIFECYCLE queues are full (answered `questions/` sidecars awaiting
+ * apply, `needsAnswers` observations awaiting surface, staged prds/tasks awaiting
+ * promotion) is still very much participating — the lifecycle rungs
+ * (triage / surface / apply / promote) act on exactly those pools. Gating
+ * participation on `tasks/ready/` ALONE made such a repo read as non-participating,
+ * so `scan --here` returned empty lifecycle buckets and the CI enumerate step found
+ * nothing to do (a silent green no-op while real work sat in `questions/`).
+ *
+ * The predicate therefore mirrors what `enumerate`/`scan` can actually produce
+ * items from: it stays a CHEAP, fetch-free local `readdirSync` (no network — it is
+ * the pre-gate `remote find` and the cwd-section resolver call before paying for a
+ * fetch), just no longer NARROWER than the lifecycle it guards.
+ */
+const PARTICIPATING_POOLS = [
+    'tasks-ready',
+    'tasks-backlog',
+    'specs-proposed',
+    'specs-ready',
+    'observations',
+    'questions',
+];
+/**
+ * A repo participates iff any of its lifecycle-bearing `work/` pools
+ * ({@link PARTICIPATING_POOLS}) contains at least one `.md` file. This is the
+ * predicate `remote find` (ADR §1) filters on AND the fetch-free gate
+ * `scan`/`status` use before resolving the (expensive) cwd section.
+ */
+export function isParticipatingRepo(repoPath) {
+    return PARTICIPATING_POOLS.some((key) => folderHasWorkItem(repoPath, key));
+}
+/** True iff the named work folder exists and holds at least one work-item `.md`. */
+function folderHasWorkItem(repoPath, key) {
+    let entries;
+    try {
+        entries = readdirSync(workFolderPath(repoPath, key));
+    }
+    catch {
+        return false;
+    }
+    return entries.some((name) => isWorkItemFile(name));
+}
+function shouldPrune(name) {
+    return name === 'node_modules' || name.startsWith('.');
+}
+/**
+ * Walk a single folder, collecting participating repo paths. Prunes
+ * `node_modules` and dotdirs, and does not descend into a repo once it is found
+ * to participate (a participating repo's own subtree yields no more repos).
+ */
+function walkFolder(folder, found) {
+    const stack = [folder];
+    while (stack.length > 0) {
+        const dir = stack.pop();
+        if (isParticipatingRepo(dir)) {
+            found.add(dir);
+            // Don't descend further into a participating repo.
+            continue;
+        }
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            if (shouldPrune(entry.name)) {
+                continue;
+            }
+            stack.push(join(dir, entry.name));
+        }
+    }
+}
+/**
+ * Find every `work/`-participating repo under `folder` (recursively), pruning
+ * `node_modules`/dotdirs and not descending into a participating repo. The
+ * returned list is deduplicated and sorted (deterministic). This is the
+ * discovery primitive behind `remote find <folder>` (ADR §1): the caller filters
+ * on {@link isParticipatingRepo} and toggle-adds the chosen ones via `remote
+ * add`. A non-existent / non-directory `folder` yields `[]` (never throws).
+ */
+export function findParticipatingRepos(folder) {
+    const found = new Set();
+    if (!existsSync(folder)) {
+        return [];
+    }
+    try {
+        if (!statSync(folder).isDirectory()) {
+            return [];
+        }
+    }
+    catch {
+        return [];
+    }
+    walkFolder(folder, found);
+    return [...found].sort();
+}
+//# sourceMappingURL=detect.js.map

package/dist/detect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect.js","sourceRoot":"","sources":["../src/detect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAE,UAAU,EAAE,QAAQ,EAAC,MAAM,SAAS,CAAC;AAC1D,OAAO,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AAC/B,OAAO,EAAC,cAAc,EAAE,cAAc,EAAC,MAAM,kBAAkB,CAAC;AAEhE;;;;;;;;;;GAUG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,MAAM,mBAAmB,GAAG;IAC3B,aAAa;IACb,eAAe;IACf,gBAAgB;IAChB,aAAa;IACb,cAAc;IACd,WAAW;CACF,CAAC;AAEX;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAAC,QAAgB;IACnD,OAAO,mBAAmB,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,iBAAiB,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC,CAAC;AAC5E,CAAC;AAED,oFAAoF;AACpF,SAAS,iBAAiB,CACzB,QAAgB,EAChB,GAAyC;IAEzC,IAAI,OAAiB,CAAC;IACtB,IAAI,CAAC;QACJ,OAAO,GAAG,WAAW,CAAC,cAAc,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC,CAAC;IACtD,CAAC;IAAC,MAAM,CAAC;QACR,OAAO,KAAK,CAAC;IACd,CAAC;IACD,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC;AACrD,CAAC;AAED,SAAS,WAAW,CAAC,IAAY;IAChC,OAAO,IAAI,KAAK,cAAc,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;AACxD,CAAC;AAED;;;;GAIG;AACH,SAAS,UAAU,CAAC,MAAc,EAAE,KAAkB;IACrD,MAAM,KAAK,GAAa,CAAC,MAAM,CAAC,CAAC;IACjC,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACzB,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,EAAG,CAAC;QACzB,IAAI,mBAAmB,CAAC,GAAG,CAAC,EAAE,CAAC;YAC9B,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACf,mDAAmD;YACnD,SAAS;QACV,CAAC;QACD,IAAI,OAAmC,CAAC;QACxC,IAAI,CAAC;YACJ,OAAO,GAAG,WAAW,CAAC,GAAG,EAAE,EAAC,aAAa,EAAE,IAAI,EAAC,CAAC,CAAC;QACnD,CAAC;QAAC,MAAM,CAAC;YACR,SAAS;QACV,CAAC;QACD,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;YAC7B,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,EAAE,CAAC;gBAC1B,SAAS;YACV,CAAC;YACD,IAAI,WAAW,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC7B,SAAS;YACV,CAAC;YACD,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;QACnC,CAAC;IACF,CAAC;AACF,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,sBAAsB,CAAC,MAAc;IACpD,MAAM,KAAK,GAAG,IAAI,GAAG,EAAU,CAAC;IAChC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;QACzB,OAAO,EAAE,CAAC;IACX,CAAC;IACD,IAAI,CAAC;QACJ,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC;YACrC,OAAO,EAAE,CAAC;QACX,CAAC;IACF,CAAC;IAAC,MAAM,CAAC;QACR,OAAO,EAAE,CAAC;IACX,CAAC;IACD,UAAU,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC1B,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC,IAAI,EAAE,CAAC;AAC1B,CAAC"}

package/dist/do-autopick.d.ts

@@ -0,0 +1,85 @@
+import { type DoOptions, type DoResult } from './do.js';
+import { type LedgerReadStrategy } from './ledger-read.js';
+import type { Config } from './config.js';
+import type { ConfigOverrideMap } from './config-override.js';
+/**
+ * The MULTI-ITEM selection forms of `do` (ADR `command-surface-and-journeys`
+ * §3), layered ON TOP of the single-item in-place pipeline from `do-in-place`
+ * ({@link performDo}) — it does NOT reimplement that pipeline; it SELECTS +
+ * ORDERS items and runs the existing pipeline per item, SEQUENTIALLY (`do` is
+ * sequential; parallelism is `run`'s job).
+ *
+ *   - **`do` (no arg)** — auto-pick ONE eligible thing and do it.
+ *   - **`do -n <x>`** — do x eligible things, in sequence.
+ *   - **`do <a> <b> …`** — do those NAMED items, in sequence.
+ *
+ * Auto-pick / `-n` draw from TWO POOLS ordered by the configurable
+ * `selectionOrder` (the shared, pure {@link selectPrioritised} helper): eligible
+ * TASKS (the `build` pool — the existing `scan`/`selectCandidates`/eligibility
+ * path) and TASKABLE prds (the `task` pool — built from the prd reader +
+ * `autoslice-gate`'s predicate), in the per-repo `selectionOrder` (default `drain`
+ * = tasks-first). A selected prd dispatches to the `do prd:<slug>` path (tasking
+ * itself is `autoslice-command`, not built here).
+ *
+ * Explicit multi-arg (`do <a> <b>`) bypasses the pools/priority entirely — the
+ * named items are resolved + run in the given order (the operator chose them).
+ */
+/** The single-`do` runner the multi-item layer drives per selected item. */
+export type DoRunner = (options: DoOptions) => Promise<DoResult>;
+/** Options shared with {@link performDo}, threaded verbatim to each per-item run. */
+type SharedDoOptions = Omit<DoOptions, 'arg'>;
+export interface PerformDoMultiOptions extends SharedDoOptions {
+    /**
+     * The resolved repo config (provides `autoTask` for the prd gate,
+     * `selectionOrder` for the pool order, and the task-pool selection caps). The
+     * per-item runs still receive `autoTask`/`integration`/etc. via the spread
+     * `SharedDoOptions`.
+     */
+    config: Config;
+    /**
+     * The per-machine {@link ConfigOverrideMap}. Threaded into the in-place pool
+     * scan (`scanRepoPaths`) so the override applies to autopick eligibility just
+     * as it does to the single-`do` resolution — WITHOUT it the committed
+     * `.dorfl.json` silently beats the per-machine override on this path.
+     */
+    override?: ConfigOverrideMap;
+    /**
+     * `do -n <x>`: how many eligible items to do, in sequence. Auto-pick (no arg,
+     * no count) ⇒ 1. SEQUENTIAL — never a parallelism knob (advance-loop locks
+     * this: `-n` is always sequential for `do`/`advance`).
+     */
+    count?: number;
+    /** Override the single-`do` runner (tests inject a stub). Defaults to {@link performDo}. */
+    run?: DoRunner;
+    /** Override the read seam (prd pool); defaults to the active {@link ledgerRead}. */
+    read?: LedgerReadStrategy;
+}
+/** The aggregate result of a multi-item `do` invocation. */
+export interface DoMultiResult {
+    /** Each per-item {@link DoResult}, in the order they ran. */
+    results: DoResult[];
+    /**
+     * The process exit code for the whole invocation: 0 iff EVERY item that ran
+     * succeeded (or there was nothing eligible to do — an empty auto-pick is not a
+     * failure); otherwise the first non-zero per-item exit code (the worst
+     * outcome surfaces). Mirrors the single-`do` exit contract per item.
+     */
+    exitCode: number;
+    /** Human-readable summary (printed by the CLI). */
+    message: string;
+}
+/**
+ * Run the AUTO-PICK / `-n <x>` form: build the two pools for `cwd`, order them
+ * per the resolved `selectionOrder` (default `drain` = tasks-first), take `count`
+ * (default 1), and run the existing `do` pipeline per selected item, SEQUENTIALLY.
+ */
+export declare function performDoAuto(options: PerformDoMultiOptions): Promise<DoMultiResult>;
+/**
+ * Run the EXPLICIT multi-arg form (`do <a> <b> …`): the named items in the GIVEN
+ * order (no pool/priority — the operator chose them). Each arg is run through the
+ * existing `do` pipeline, which itself resolves bare/`task:`/`prd:` (so a named
+ * prd dispatches to the tasking path and a collision errors), SEQUENTIALLY.
+ */
+export declare function performDoArgs(args: string[], options: PerformDoMultiOptions): Promise<DoMultiResult>;
+export {};
+//# sourceMappingURL=do-autopick.d.ts.map

package/dist/do-autopick.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"do-autopick.d.ts","sourceRoot":"","sources":["../src/do-autopick.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAC,MAAM,SAAS,CAAC;AAEjE,OAAO,EAAa,KAAK,kBAAkB,EAAC,MAAM,kBAAkB,CAAC;AAOrE,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,sBAAsB,CAAC;AAE5D;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,4EAA4E;AAC5E,MAAM,MAAM,QAAQ,GAAG,CAAC,OAAO,EAAE,SAAS,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;AAEjE,qFAAqF;AACrF,KAAK,eAAe,GAAG,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;AAE9C,MAAM,WAAW,qBAAsB,SAAQ,eAAe;IAC7D;;;;;OAKG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,4FAA4F;IAC5F,GAAG,CAAC,EAAE,QAAQ,CAAC;IACf,oFAAoF;IACpF,IAAI,CAAC,EAAE,kBAAkB,CAAC;CAC1B;AAED,4DAA4D;AAC5D,MAAM,WAAW,aAAa;IAC7B,6DAA6D;IAC7D,OAAO,EAAE,QAAQ,EAAE,CAAC;IACpB;;;;;OAKG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB,mDAAmD;IACnD,OAAO,EAAE,MAAM,CAAC;CAChB;AAYD;;;;GAIG;AACH,wBAAsB,aAAa,CAClC,OAAO,EAAE,qBAAqB,GAC5B,OAAO,CAAC,aAAa,CAAC,CAoDxB;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CAClC,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,EAAE,qBAAqB,GAC5B,OAAO,CAAC,aAAa,CAAC,CAUxB"}

package/dist/do-autopick.js

@@ -0,0 +1,112 @@
+import { performDo } from './do.js';
+import { scanRepoPaths } from './scan.js';
+import { ledgerRead } from './ledger-read.js';
+import { selectPrioritised, taskableSpecs, } from './select-priority.js';
+/**
+ * The task-pool caps for an in-place `do` selection. `do` is per-repo +
+ * sequential, so the REAL bound is the requested `count` (handled by the
+ * priority helper); the task-pool selection should not truncate BEFORE the
+ * count + the prd pool are combined. We therefore cap the task pool at "all
+ * eligible" (a large bound) and let {@link selectPrioritised}'s `count` do the
+ * trimming across both pools.
+ */
+const ALL_ELIGIBLE = Number.MAX_SAFE_INTEGER;
+/**
+ * Run the AUTO-PICK / `-n <x>` form: build the two pools for `cwd`, order them
+ * per the resolved `selectionOrder` (default `drain` = tasks-first), take `count`
+ * (default 1), and run the existing `do` pipeline per selected item, SEQUENTIALLY.
+ */
+export async function performDoAuto(options) {
+    const run = options.run ?? performDo;
+    const read = options.read ?? ledgerRead;
+    const note = options.note ?? (() => { });
+    const cwd = options.cwd;
+    const count = options.count ?? 1;
+    // Pool 1 — eligible TASKS via the EXISTING scan/select path (task-only).
+    // Thread `override` so the per-machine override is applied per repo (the
+    // inner `resolveRepoConfig` re-applies it AFTER the committed file, restoring
+    // the override value even though `config` is already resolved).
+    const report = scanRepoPaths([cwd], options.config, new Set(), options.override);
+    // Pool 2 — TASKABLE prds: the NEW pool from the shared prd read path
+    // (`resolveSpecPool`) filtered by `autoslice-gate`'s predicate (not reinvented).
+    const pool = read.resolveSpecPool({ repoPath: cwd });
+    const specCandidates = pool.specs.map((spec) => ({
+        repoPath: cwd,
+        slug: spec.slug,
+        humanOnly: spec.humanOnly,
+        needsAnswers: spec.needsAnswers,
+        taskedAfter: spec.taskedAfter,
+    }));
+    const eligibleSpecs = taskableSpecs({
+        candidates: specCandidates,
+        taskedSlugs: pool.taskedSlugs,
+        autoTask: options.config.autoTask,
+    });
+    // Order across both pools per the resolved `selectionOrder` + bound by count. The
+    // task pool is selected via the SHARED `selectCandidates` primitive `run` uses.
+    const selected = selectPrioritised({
+        report,
+        caps: { maxParallel: ALL_ELIGIBLE, perRepoMax: ALL_ELIGIBLE },
+        specs: eligibleSpecs,
+        selectionOrder: options.config.selectionOrder,
+        count,
+    });
+    if (selected.length === 0) {
+        const message = 'Nothing eligible to do (no eligible tasks and no taskable prds).';
+        note(message);
+        return { results: [], exitCode: 0, message };
+    }
+    return runSelectedInSequence(selected, options, run);
+}
+/**
+ * Run the EXPLICIT multi-arg form (`do <a> <b> …`): the named items in the GIVEN
+ * order (no pool/priority — the operator chose them). Each arg is run through the
+ * existing `do` pipeline, which itself resolves bare/`task:`/`prd:` (so a named
+ * prd dispatches to the tasking path and a collision errors), SEQUENTIALLY.
+ */
+export async function performDoArgs(args, options) {
+    const run = options.run ?? performDo;
+    const selected = args.map((arg) => ({
+        repoPath: options.cwd,
+        slug: arg,
+        // The arg is passed VERBATIM to `performDo` (it does its own slug
+        // resolution); the namespace is irrelevant for explicit args.
+        namespace: 'task',
+    }));
+    return runSelectedInSequence(selected, options, run, { verbatimArg: true });
+}
+/**
+ * Run a list of selected items through the existing `do` pipeline, SEQUENTIALLY,
+ * threading the shared options to each. For the pool path the `do` arg encodes
+ * the namespace (`prd:<slug>` for a selected prd, bare slug for a task); for the
+ * explicit-arg path the caller's raw arg is passed verbatim.
+ */
+async function runSelectedInSequence(selected, options, run, mode = {}) {
+    const shared = sharedDoOptions(options);
+    const results = [];
+    for (const item of selected) {
+        const arg = mode.verbatimArg
+            ? item.slug
+            : item.namespace === 'spec'
+                ? `spec:${item.slug}`
+                : item.slug;
+        const result = await run({ ...shared, arg });
+        results.push(result);
+    }
+    const firstFailure = results.find((r) => r.exitCode !== 0);
+    const exitCode = firstFailure ? firstFailure.exitCode : 0;
+    const ok = results.filter((r) => r.exitCode === 0).length;
+    const message = `did ${results.length} item${results.length === 1 ? '' : 's'} ` +
+        `(${ok} ok, ${results.length - ok} not).`;
+    return { results, exitCode, message };
+}
+/** Strip the multi-only fields, leaving exactly the per-item {@link DoOptions} base. */
+function sharedDoOptions(options) {
+    const { config: _config, count: _count, run: _run, read: _read, ...rest } = options;
+    void _config;
+    void _count;
+    void _run;
+    void _read;
+    return rest;
+}
+//# sourceMappingURL=do-autopick.js.map

package/dist/do-autopick.js.map

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

package/dist/do-config.d.ts

@@ -0,0 +1,312 @@
+import type { Config, IntegrationMode, PartialConfig } from './config.js';
+/**
+ * The CLI flags that select WHICH agent runs and HOW it is launched — shared,
+ * verbatim, by `run` and `do`. Both commands offer `--harness`/`--agent-cmd`/
+ * `--pi-bin`/`--model`; this is the single place their string→`PartialConfig`
+ * mapping lives so there is exactly ONE override path (not a parallel one per
+ * command). `cli.ts`'s `runFlagOverrides` and {@link doFlagOverrides} both fold
+ * this in.
+ */
+export interface HarnessFlags {
+    agentCmd?: string;
+    model?: string;
+    harness?: string;
+    piBin?: string;
+    /**
+     * The HOST-ONLY root folder under which a job's pi session FILE is generated
+     * (`--sessions-dir`). Forwarded verbatim like `piBin`; the path generator turns
+     * it into `<sessionsDir>/<unique-id>.jsonl` at launch (unset ⇒ pi's per-cwd
+     * default folder).
+     */
+    sessionsDir?: string;
+}
+/**
+ * Map the shared harness/adapter flags into a {@link PartialConfig} of overrides
+ * — the per-key mapping `run` and `do` both reuse. Only flags actually present
+ * contribute (absent flag ⇒ absent key), so the override layer never clobbers a
+ * lower precedence source with `undefined`. `--harness` is validated against the
+ * `HarnessAdapter` union (an out-of-range value is dropped, matching `run`).
+ */
+export declare function harnessFlagOverrides(flags: HarnessFlags): PartialConfig;
+/**
+ * Build the flag-override `PartialConfig` for the `do` command. This is the FIX
+ * for the silent-drop bug: `do` DECLARES `--harness`/`--agent-cmd`/`--pi-bin`/
+ * `--model`, so its action MUST thread them into `resolveRepoConfig`'s `flags`
+ * — not just `{integration}`. It reuses the SAME per-key mapping `run` uses
+ * ({@link harnessFlagOverrides}), then folds in the integrate-time mode (the
+ * already-resolved `--merge`/`--propose`, via `integrationFromFlags`) so the
+ * full set rides the same precedence chain (flag > env > per-repo > global >
+ * default).
+ */
+export declare function doFlagOverrides(flags: HarnessFlags & ReviewFlags & TaskerLoopFlags & FreshWorktreeGateFlags & SelectionOrderFlags & ObservationTriageFlags & SurfaceBlockersFlags & MergeQuestionsFlags & StrictMergeApprovalFlags & NoPRFlags & MergeRetriesFlags, integration?: IntegrationMode): PartialConfig;
+/**
+ * The Gate-2 (PR/code review) CLI flags, offered by `do` AND `complete`
+ * (`--review`/`--no-review`, `--review-model`, `--review-max-rounds`). Both commands resolve them through
+ * the SAME `flag > env > per-repo > global > default` chain as `integration`, so
+ * the mapping lives in ONE place (not a parallel copy per command).
+ */
+export interface ReviewFlags {
+    /** `--review` ⇒ true, `--no-review` ⇒ false, absent ⇒ undefined. */
+    review?: boolean;
+    /** `--review-model <id>` — the de-correlated review model (routing intent). */
+    reviewModel?: string;
+    /** `--review-max-rounds <n>` — the revise↔review loop bound (parsed to a number). */
+    reviewMaxRounds?: string;
+}
+/**
+ * The tasker IMPROVER-loop CLI flags (`do` only): `--tasker-loop` /
+ * `--no-tasker-loop` (the on/off toggle), `--tasker-loop-max <n>` (the in-context
+ * convergence cap), and `--tasker-loop-model <id>` (the loop reviewer's
+ * de-correlated model). A DISTINCT family from the acceptance gate's `--review*`
+ * (see {@link ReviewFlags}) — no flag/key/field name spans both. Resolved through
+ * the SAME `flag > env > per-repo > global > default` chain.
+ *
+ * NOTE the flag NAMES are tasking-vocabulary (`--tasker-loop*`, so commander
+ * populates the `taskerLoop*` fields below), and they resolve into the
+ * `taskerLoop*` CONFIG KEYS, so {@link taskerLoopFlagOverrides} bridges the
+ * flag fields onto the config keys.
+ */
+export interface TaskerLoopFlags {
+    /** `--tasker-loop` ⇒ true, `--no-tasker-loop` ⇒ false, absent ⇒ undefined. */
+    taskerLoop?: boolean;
+    /** `--tasker-loop-max <n>` — the loop's in-context convergence cap (parsed to a number). */
+    taskerLoopMax?: string;
+    /** `--tasker-loop-model <id>` — the loop reviewer's de-correlated model (routing intent). */
+    taskerLoopModel?: string;
+}
+/**
+ * Map the Gate-2 review flags into a {@link PartialConfig} of overrides — the
+ * per-key mapping `do` and `complete` both reuse. Only flags actually present
+ * contribute (absent flag ⇒ absent key), so the override layer never clobbers a
+ * lower-precedence source with `undefined`. `--review-max-rounds` is parsed to a
+ * number; a non-numeric value is dropped (the lower layer / default decides).
+ */
+export declare function reviewFlagOverrides(flags: ReviewFlags): PartialConfig;
+/**
+ * Map the tasker IMPROVER-loop flags into a {@link PartialConfig} of overrides.
+ * Only flags actually present contribute (absent flag ⇒ absent key), so the
+ * override layer never clobbers a lower-precedence source with `undefined`.
+ * `--tasker-loop-max` is parsed to a number; a non-numeric value is dropped (the
+ * lower layer / default decides). A DISTINCT family from {@link reviewFlagOverrides}.
+ *
+ * The tasking-vocabulary FLAG fields (`taskerLoop*`) bridge onto the
+ * `taskerLoop*` CONFIG KEYS, so the operator types `--tasker-loop` and the value
+ * resolves through the standard precedence into `config.taskerLoop`.
+ */
+export declare function taskerLoopFlagOverrides(flags: TaskerLoopFlags): PartialConfig;
+/**
+ * The fresh-worktree acceptance-gate CLI flag (`do`/`complete`/`run`):
+ * `--fresh-worktree-gate` / `--no-fresh-worktree-gate`, the POSITIVE boolean
+ * (default ON) toggling whether the acceptance gate (`prepare` then `verify`)
+ * runs against the REBASED tip in a clean throwaway worktree (the merged
+ * artifact) or in the agent's build worktree (the pre-rebase tree). Modelled
+ * EXACTLY on {@link TaskerLoopFlags}'s on/off toggle; a DISTINCT family (no
+ * flag/key/field name spans both). Resolved through the SAME
+ * `flag > env > per-repo > global > default` chain.
+ */
+export interface FreshWorktreeGateFlags {
+    /** `--fresh-worktree-gate` ⇒ true, `--no-fresh-worktree-gate` ⇒ false, absent ⇒ undefined. */
+    freshWorktreeGate?: boolean;
+}
+/**
+ * Map the `--fresh-worktree-gate`/`--no-fresh-worktree-gate` flag into a
+ * {@link PartialConfig} override. Only a present flag contributes (absent ⇒
+ * absent key), so the override layer never clobbers a lower-precedence source
+ * with `undefined`. A negatable boolean (mirrors `taskerLoop`), so the caller
+ * leaves `freshWorktreeGate` UNDEFINED unless the user explicitly passed the
+ * flag (see the cli's option-source read).
+ */
+export declare function freshWorktreeGateFlagOverrides(flags: FreshWorktreeGateFlags): PartialConfig;
+/**
+ * The selection-order CLI flag (`do` AND `advance`): `--selection-order <order>`
+ * (a preset keyword like `drain`/`groom`, or a comma-separated explicit pool
+ * order like `build,task,surface,triage`). Resolved through the SAME
+ * `flag > env > per-repo > global > default` chain as the other `do` flags.
+ */
+export interface SelectionOrderFlags {
+    /** `--selection-order <order>` — a preset keyword or comma-separated pool list. */
+    selectionOrder?: string;
+}
+/**
+ * Map the `--selection-order` flag into a {@link PartialConfig} override. Only a
+ * present flag contributes (absent ⇒ absent key). A value CONTAINING a comma is
+ * parsed into a trimmed, non-empty list (an explicit pool order, mirroring the
+ * env `'list'` coercion); otherwise it is the verbatim string (a preset keyword
+ * or a single pool name). The resolver (`select-order.ts`) does the
+ * validation/expansion + loud failure at selection time — this only normalises
+ * the flag's surface syntax.
+ */
+export declare function selectionOrderFlagOverrides(flags: SelectionOrderFlags): PartialConfig;
+/**
+ * The observation-triage CLI flag (`advance`): `--observation-triage
+ * <off|ask|auto>`, the 3-state gate over the observation INBOX (ADR
+ * `ci-config-policy-and-gate-family`). Resolved through the SAME
+ * `flag > env > per-repo > global > default` chain as the other gate flags.
+ */
+export interface ObservationTriageFlags {
+    /** `--observation-triage <off|ask|auto>` — the observation-inbox gate state. */
+    observationTriage?: string;
+}
+/**
+ * Map the `--observation-triage` flag into a {@link PartialConfig} override. Only
+ * a present flag contributes (absent ⇒ absent key). An INVALID value FAILS LOUDLY
+ * (the same loud-failure contract the env enum coercion enforces) rather than
+ * silently falling through to a lower layer — a typo on an autonomy gate must
+ * never be quietly ignored.
+ */
+export declare function observationTriageFlagOverrides(flags: ObservationTriageFlags): PartialConfig;
+/**
+ * The surface-blockers CLI flag (`advance`): `--surface-blockers` /
+ * `--no-surface-blockers`, the BOOLEAN gate over DECLARED blocked work (whether a
+ * `needsAnswers:true` task/prd is rendered into a question sidecar; ADR
+ * `ci-config-policy-and-gate-family`). The orthogonal PEER of
+ * `--observation-triage`. Resolved through the SAME
+ * `flag > env > per-repo > global > default` chain as the other gate flags.
+ */
+export interface SurfaceBlockersFlags {
+    /** `--surface-blockers` ⇒ true, `--no-surface-blockers` ⇒ false, absent ⇒ undefined. */
+    surfaceBlockers?: boolean;
+}
+/**
+ * Map the `--surface-blockers` flag into a {@link PartialConfig} override. Only a
+ * present flag contributes (absent ⇒ absent key), so the override layer never
+ * clobbers a lower-precedence source with `undefined`. A negatable boolean, so the
+ * caller leaves `surfaceBlockers` UNDEFINED unless the user explicitly passed
+ * `--surface-blockers`/`--no-surface-blockers` (see the cli's option-source read).
+ */
+export declare function surfaceBlockersFlagOverrides(flags: SurfaceBlockersFlags): PartialConfig;
+/**
+ * **The cross-job merge-serialiser CAS-retry cap CLI flag** (`--merge-retries
+ * <n>`) — prd `land-time-reverify-and-parallel-merge-ceiling` Story 5 / Applied
+ * Answer q1 (a). The git-alone FLOOR of the cross-job land-queue; a wide-matrix
+ * CI raises the cap so more contenders converge before any spurious bounce to
+ * needs-attention. Offered by `do`/`run`/`complete`. Resolved through the SAME
+ * `flag > env > per-repo > global > default` chain as `--review-max-rounds` /
+ * `--fresh-worktree-gate`.
+ */
+export interface MergeRetriesFlags {
+    /** `--merge-retries <n>` — the cross-job CAS-retry cap (parsed to a non-negative integer). */
+    mergeRetries?: string;
+}
+/**
+ * Map the `--merge-retries <n>` flag into a {@link PartialConfig} override. Only
+ * a present flag contributes (absent ⇒ absent key), so the override layer never
+ * clobbers a lower-precedence source with `undefined`. The value MUST be a
+ * NON-NEGATIVE integer (`0` is meaningful — it disables the retry, the
+ * un-retried path the engine's tests pin); a non-integer / negative value is
+ * dropped silently so the lower layer / default decides (mirrors
+ * {@link reviewFlagOverrides}'s parse-or-drop on `--review-max-rounds`).
+ */
+export declare function mergeRetriesFlagOverrides(flags: MergeRetriesFlags): PartialConfig;
+/**
+ * The merge-questions CLI flag (`advance`): `--merge-questions <off|ask|auto>`,
+ * the 3-state gate over the MERGE-QUESTION SURFACER (prd
+ * `land-time-reverify-and-parallel-merge-ceiling` Story 17 / task
+ * `merge-questions-gate-axis`). MIRRORS `--observation-triage`'s SHAPE but is a
+ * SEPARATE axis with a HIGHER default (`ask`, never `off` — a dropped merge-
+ * question means pushed work never lands). Resolved through the SAME
+ * `flag > env > per-repo > global > default` chain as the other gate flags.
+ */
+export interface MergeQuestionsFlags {
+    /** `--merge-questions <off|ask|auto>` — the merge-question surfacer gate. */
+    mergeQuestions?: string;
+}
+/**
+ * Map the `--merge-questions` flag into a {@link PartialConfig} override. Only a
+ * present flag contributes (absent ⇒ absent key). An INVALID value FAILS LOUDLY
+ * (the same loud-failure contract `--observation-triage` enforces) rather than
+ * silently falling through — a typo on a question-surfacing gate must never be
+ * quietly ignored.
+ */
+export declare function mergeQuestionsFlagOverrides(flags: MergeQuestionsFlags): PartialConfig;
+/**
+ * **The strict-merge-approval CLI flag** (`--strict-merge-approval` /
+ * `--no-strict-merge-approval`) — prd
+ * `land-time-reverify-and-parallel-merge-ceiling` sidecar OQ6 / task
+ * `strict-merge-approval-gate`. The OPT-IN strictness layered on the OQ6
+ * stale-approval default: ON re-surfaces the merge-question on a merge-base
+ * change instead of auto-landing on a green re-verify (the host-agnostic
+ * analogue of GitHub's "dismiss stale approvals when the base changes"); OFF
+ * (default) honours the prior answer + lands when the rebased tip re-verifies
+ * GREEN. Offered alongside `--merge-questions` on `advance` (the apply rung is
+ * the consumer). Resolved through the SAME `flag > env > per-repo > global >
+ * default` chain as the other gate-family members. A negatable boolean
+ * (mirrors `--fresh-worktree-gate`).
+ */
+export interface StrictMergeApprovalFlags {
+    /** `--strict-merge-approval` ⇒ true, `--no-strict-merge-approval` ⇒ false, absent ⇒ undefined. */
+    strictMergeApproval?: boolean;
+}
+/**
+ * Map the `--strict-merge-approval`/`--no-strict-merge-approval` flag into a
+ * {@link PartialConfig} override. Only a present flag contributes (absent ⇒
+ * absent key), so the override layer never clobbers a lower-precedence source
+ * with `undefined`. A negatable boolean (mirrors
+ * {@link freshWorktreeGateFlagOverrides}): the caller leaves
+ * `strictMergeApproval` UNDEFINED unless the user explicitly passed the flag.
+ */
+export declare function strictMergeApprovalFlagOverrides(flags: StrictMergeApprovalFlags): PartialConfig;
+/**
+ * The PR-INTENT CLI flag (`--no-pr`), offered by `do`/`complete`/`run`: push the
+ * branch but deliberately skip the review request (the explicit suppress-PR
+ * intent, ADR §6). NOT a provider choice. Commander stores the negatable flag as
+ * `pr` (false when `--no-pr` is passed). Resolved through the SAME
+ * `flag > env > per-repo > global > default` chain as `integration`/`review`.
+ */
+export interface NoPRFlags {
+    /** `--no-pr` ⇒ commander stores `pr === false` (the suppress-PR intent). */
+    pr?: boolean;
+}
+/**
+ * Map the `--no-pr` flag into a {@link PartialConfig} override. Only an explicit
+ * `--no-pr` (commander's `pr === false`) contributes `noPR: true`; otherwise the
+ * key stays absent so the lower layer (env / per-repo / global / default) decides.
+ */
+export declare function noPRFlagOverrides(flags: NoPRFlags): PartialConfig;
+/**
+ * The null-default guard: the `null` adapter shells out to `agentCmd`, so it is
+ * required there; the `pi` adapter invokes the pi CLI directly and does not
+ * consume `agentCmd`. Returns `true` when the resolved config selects the null
+ * adapter with no `agentCmd` — the case `do`/`run`/`--remote` must reject with a
+ * clear error ({@link NO_AGENT_CMD_MESSAGE}). All three CLI sites call THIS one
+ * predicate (named here so the fix's no-regression test can pin it).
+ */
+export declare function doNeedsAgentCmd(config: Config): boolean;
+/**
+ * The shared up-front message for the {@link doNeedsAgentCmd} refusal. Names BOTH
+ * escape hatches: the `--harness pi` adapter (which needs no agentCmd) and
+ * setting `harness`/`agentCmd` in config. Shared so `do`/`run`/`--remote` speak
+ * with one voice (and the test that pins `--harness pi` only has to pin it once).
+ */
+export declare const NO_AGENT_CMD_MESSAGE: string;
+/**
+ * The shared up-front message for the PR-INTENT pre-flight refusal: a `propose`
+ * run on a GitHub arbiter intends a PR (`noPR` unset) but a `gh` AUTH/AVAILABILITY
+ * PROBE says `gh` cannot open one. Surfaced BEFORE any claim/onboard/build so no
+ * work is wasted, and naming EVERY real fix (auth `gh`, set a `providers.github`
+ * identity token, switch to `--merge`, or `--no-pr` to push without a PR). The
+ * honest-failure value the `noPR` axis buys: it disambiguates "I deliberately
+ * want no PR" from "I wanted a PR and silently didn't get one". Shared so the
+ * in-place + no-checkout `do` paths speak with one voice.
+ */
+export declare const PROPOSE_PR_INTENT_GH_UNAVAILABLE_MESSAGE: string;
+/**
+ * Should the PR-INTENT pre-flight guard FIRE for this run? It fires ONLY when ALL
+ * hold: the run is `propose` mode (not `merge` — merge never opens a PR), the
+ * arbiter is a GitHub URL (only then is a PR even possible), `noPR` is UNSET (the
+ * operator INTENDS a PR), and the injected `gh` auth/availability `probe` reports
+ * `gh` cannot open one. The probe (mirroring `GitHubProvider.available`) is
+ * the signal, NOT a config inspection: an ABSENT `providers.github` identity must
+ * NOT trip this guard — it falls back to AMBIENT `gh` auth (the common local-dev
+ * case), which the probe correctly reports as available. A genuinely TRANSIENT
+ * mid-run `gh` outage (the probe passes here but the API fails later) is left to
+ * the runtime degrade — the probe only catches the start-of-run unauthed case.
+ */
+export declare function shouldFailProposePrIntent(input: {
+    mode: IntegrationMode;
+    arbiterIsGitHub: boolean;
+    noPR: boolean | undefined;
+    /** The `gh` auth/availability probe (true ⇒ `gh` CAN open a PR). */
+    ghCanOpenPr: () => boolean;
+}): boolean;
+//# sourceMappingURL=do-config.d.ts.map

package/dist/do-config.d.ts.map

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