dorfl 0.0.0 → 0.1.0

package/dist/advance-drivers.js

@@ -0,0 +1,231 @@
+import { performAdvance, } from './advance.js';
+import { pushTreelessResult, TREELESS_RUNGS, } from './advance-treeless-publish.js';
+import { scanRepoPaths } from './scan.js';
+import { ledgerRead } from './ledger-read.js';
+import { selectPrioritised, taskableSpecs, } from './select-priority.js';
+import { gatherLifecycleInPlace } from './lifecycle-gather.js';
+/**
+ * The task-pool caps for an in-place `advance` selection. `advance` (one-shot) is
+ * per-repo + SEQUENTIAL, so the REAL bound is the requested `count`. We cap the
+ * task pool at "all eligible" and let {@link selectPrioritised}'s `count` trim
+ * across both pools — identical to `do-autopick`'s {@link performDoAuto}.
+ */
+const ALL_ELIGIBLE = Number.MAX_SAFE_INTEGER;
+/**
+ * Run the BARE / `-n <x>` form: build the two ELIGIBLE pools for `cwd` (eligible
+ * TASKS gated by `autoBuild`, taskable prds gated by `autoTask`), order them
+ * (plus the lifecycle pools) per the resolved `selectionOrder` with `apply`
+ * pinned first, take `count` (default 1), and run the EXISTING advance tick per
+ * selected item, SEQUENTIALLY. The pools are the EXACT
+ * `do-autopick` pools (the SAME `scoreItems`/`taskableSpecs` predicates), so the
+ * per-action gate family is honoured by construction.
+ *
+ * The bare/`-n` selection draws ONLY from the autonomous pools (eligible tasks +
+ * taskable prds); SURFACE + APPLY of a gated item are reached by NAMING the item
+ * ({@link performAdvanceArgs}) — they are always-allowed and not pool-gated, so the
+ * bare form with every flag off correctly selects NOTHING (zero autonomy) while a
+ * named `advance <slug>` still surfaces/applies.
+ */
+export async function performAdvanceAuto(options) {
+    const run = options.run ?? performAdvance;
+    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. `scoreItems`
+    // inside `scanRepoPaths` gates eligibility on `autoBuild` (the build gate), so
+    // with `autoBuild` off NO task is selected — the build rung is never reached
+    // by the bare/`-n` selection.
+    const report = scanRepoPaths([cwd], options.config, new Set(), options.override);
+    // Pool 2 — TASKABLE prds filtered by `autoslice-gate`'s predicate (gated on
+    // `autoTask`). With `autoTask` off NO prd is selected — the task rung is
+    // never reached by the bare/`-n` selection.
+    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,
+    });
+    // Pools 3 + 4 — the LIFECYCLE pools (untriaged observations + `needsAnswers`-
+    // blocked tasks/prds + answered-sidecar items), built CALLER-SIDE (here, the
+    // `advance` caller) through the SHARED enumeration unit and passed in — NOT baked
+    // into `selectPrioritised` (so `do` is provably unchanged). The create-gates
+    // default OFF (interim hardcoded-off): triage + surface contribute nothing; the
+    // apply sub-pool is always-on (consume), so an answered sidecar still applies.
+    const lifecycle = gatherLifecycleInPlace({
+        repoPath: cwd,
+        read,
+        gates: options.lifecycleGates,
+    });
+    // Order across the (up to) FIVE pools per the resolved `selectionOrder` (apply
+    // pinned first) + bound by count — the SAME shared, pure `selectPrioritised` the
+    // `do` auto-pick driver uses (which passes NO lifecycle pools, so it is unchanged).
+    const selected = selectPrioritised({
+        report,
+        caps: { maxParallel: ALL_ELIGIBLE, perRepoMax: ALL_ELIGIBLE },
+        specs: eligibleSpecs,
+        selectionOrder: options.config.selectionOrder,
+        lifecycle,
+        count,
+    });
+    if (selected.length === 0) {
+        // With every gate off this is the "zero autonomy" case: nothing autonomous to
+        // select. The question loop (surface/apply) is reached by NAMING an item, not
+        // the bare form — so this is calm-at-rest, NOT a failure.
+        const message = 'Nothing eligible to advance (no eligible tasks and no taskable prds ' +
+            'under the per-action gates; name an item to surface/apply its questions).';
+        note(message);
+        return { results: [], exitCode: 0, message };
+    }
+    return runSelectedInSequence(selected, options, run);
+}
+/**
+ * Run the EXPLICIT multi-arg form (`advance <a> <b> …`): the named items in the
+ * GIVEN order (no pool/priority — the operator chose them). Each arg is run
+ * through the existing advance tick, which itself resolves bare/`task:`/`prd:`/
+ * `obs:` (so a named prd drives the task rung, an `obs:` the triage rung, a
+ * collision errors), SEQUENTIALLY. A NAMED item is the always-allowed path — its
+ * surface/apply rung runs regardless of the per-action gates.
+ */
+export async function performAdvanceArgs(args, options) {
+    const run = options.run ?? performAdvance;
+    const selected = args.map((arg) => ({
+        repoPath: options.cwd,
+        slug: arg,
+        // The arg is passed VERBATIM to the tick (it does its own slug resolution
+        // across task/prd/observation); 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 advance tick, SEQUENTIALLY
+ * (US #25 — `-n` is always sequential), threading the shared context to each. For
+ * the pool path the 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. Each tick is INDEPENDENTLY `advancing`-lock-guarded inside
+ * {@link performAdvance} — sequential here means one item at a time, never a
+ * parallelism knob.
+ */
+async function runSelectedInSequence(selected, options, run, mode = {}) {
+    const shared = sharedAdvanceContext(options);
+    const results = [];
+    for (const item of selected) {
+        const arg = mode.verbatimArg ? item.slug : argForSelectedItem(item);
+        const result = await runAdvanceTickWithTreelessPublish({ ...shared, arg, read: options.read }, run);
+        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 = `advanced ${results.length} item${results.length === 1 ? '' : 's'} ` +
+        `(${ok} ok, ${results.length - ok} not).`;
+    return { results, exitCode, message };
+}
+/**
+ * Run ONE in-place advance tick + ff-push a tree-less rung's result to the
+ * arbiter — task `advance-in-place-publishes-treeless-results`. Wraps the
+ * substrate-agnostic tick ({@link AdvanceTickRunner}) with the shared
+ * {@link pushTreelessResult} so a surfaced sidecar / `triaged:` marker /
+ * applied-answer commit committed LOCALLY in the in-place cwd LANDS on the
+ * arbiter's `main` (today the in-place tick commits locally and the work is lost
+ * on an ephemeral CI runner). Mirrors the `--isolated` one-shot + `run` loop
+ * driver call sites byte-for-byte:
+ *
+ *   - gates PURELY on `result.exitCode === 0 && TREELESS_RUNGS.has(result.rung)
+ *     && context.arbiter !== undefined` — the SAME gate the existing drivers
+ *     use, no cleverer guard (a build/task rung integrates through the
+ *     `doDriver` band; a no-arbiter laptop checkout already sits on the real
+ *     `main`);
+ *   - reuses `pushTreelessResult` VERBATIM (its bounded re-fetch+rebase retry is
+ *     LOAD-BEARING for a sequential `-n` batch that integrates a build/task rung
+ *     mid-batch and then runs a later tree-less rung whose `HEAD:main` push is
+ *     non-fast-forward by construction);
+ *   - NEVER `--force`. A push that keeps failing (or a genuine rebase conflict)
+ *     is REPORTED via the `note` sink and does NOT crash the tick — the work
+ *     stays committed in the cwd for the next pass / a human.
+ *
+ * Used by BOTH in-place entry points: {@link runSelectedInSequence} (the
+ * multi-item `-n` / auto-pick / multi-arg path) AND the CLI single-named-item
+ * path (which calls {@link performAdvance} directly, bypassing the sequence
+ * runner — the easy-to-miss site).
+ *
+ * The promote-apply edge mirrors the existing drivers without a special case: an
+ * `apply` rung whose agentic verdict mints an artifact (`mint-task`/`mint-prd`)
+ * runs `promoteObservation`'s OWN arbiter CAS and commits NOTHING tree-less, so the
+ * ff-push here is a harmless no-op (a `HEAD` with nothing new) — it does NOT
+ * double-publish nor clobber the promote CAS.
+ */
+export async function runAdvanceTickWithTreelessPublish(options, run) {
+    const result = await run(options);
+    if (result.exitCode === 0 &&
+        result.rung !== undefined &&
+        TREELESS_RUNGS.has(result.rung) &&
+        options.arbiter !== undefined) {
+        await pushTreelessResult({
+            cwd: options.cwd,
+            arbiter: options.arbiter,
+            // Large liveness ceiling — see `pushTreelessResult`'s C2 docs (task
+            // `c2-rebase-until-real-on-durable-main-promotions`). A clean re-rebase
+            // no longer counts against a small budget; a genuine conflict (slug gone
+            // from its source folder on the new `main`) still stops definitively.
+            retries: 1000,
+            env: undefined,
+            note: options.note ?? (() => { }),
+        });
+    }
+    return result;
+}
+/**
+ * The advance TICK arg for a pool-selected item — the SELECTION->ARG dispatch
+ * (task `advance-autopick-lifecycle-pools`, F-NAMESPACE). The `namespace`
+ * discriminator the selection carried maps to the tick arg the tick then
+ * classifies into the right rung:
+ *   - `observation` → `obs:<slug>` (the triage rung; bare would resolve to a
+ *     task, so the `obs:` prefix is required);
+ *   - `spec` → `spec:<slug>` (a taskable spec's task rung, OR a `needsAnswers` spec
+ *     the tick surfaces/applies);
+ *   - `task` → bare `<slug>` (an eligible task's build rung, OR a `needsAnswers`
+ *     task the tick surfaces/applies).
+ * The tick re-classifies each arg, so a `needsAnswers`-blocked task/prd reaches
+ * surface/apply and an untriaged observation reaches triage — the classifier +
+ * rung bodies are unchanged; only this selection->arg mapping is new.
+ */
+function argForSelectedItem(item) {
+    if (item.namespace === 'observation') {
+        return `obs:${item.slug}`;
+    }
+    if (item.namespace === 'spec') {
+        return `spec:${item.slug}`;
+    }
+    return item.slug;
+}
+/** Strip the multi-only fields, leaving exactly the per-item {@link AdvanceContext}. */
+function sharedAdvanceContext(options) {
+    const { config: _config, count: _count, run: _run, read: _read, lifecycleGates: _lifecycleGates, ...rest } = options;
+    void _config;
+    void _count;
+    void _run;
+    void _read;
+    void _lifecycleGates;
+    return rest;
+}
+/**
+ * Is this aggregate result a CALM-AT-REST (US #31 convergence) one — every item
+ * that ran was a NO-OP (a pending sidecar idling) AND nothing failed? The
+ * convergence/drain tests use this to assert the loop IDLES when there are no
+ * answers (no thrash) and DRAINS monotonically as answers arrive. A pool of
+ * pending-sidecar items advances NOTHING (every tick a clean no-op); as the human
+ * answers, the answered items flip to `apply` and the no-op count shrinks.
+ */
+export function isCalmAtRest(result) {
+    return (result.exitCode === 0 && result.results.every((r) => r.outcome === 'no-op'));
+}
+//# sourceMappingURL=advance-drivers.js.map

package/dist/advance-drivers.js.map

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

package/dist/advance-isolated.d.ts

@@ -0,0 +1,156 @@
+import { type AdvanceContext, type AdvanceResult } from './advance.js';
+import { type LedgerReadStrategy } from './ledger-read.js';
+import type { LifecyclePoolGates } from './lifecycle-pools.js';
+import type { Config } from './config.js';
+import type { AdvanceTickRunner, AdvanceMultiResult } from './advance-drivers.js';
+/**
+ * The **ISOLATED advance-tick RUNNER** + its sequential drivers (prd
+ * `advance-loop`, task `advance-isolated-one-shot`, US #25/26) — the "isolated
+ * one-shot" cell `advance` was missing. It gives `advance` the SAME isolation
+ * ergonomic `do --isolated` has: run the advance TICK ({@link performAdvance}) in
+ * an ISOLATED worktree off THIS repo's arbiter (resolved from cwd), then integrate
+ * + reap — instead of taking over the current checkout in-place.
+ *
+ * **HONEST SCOPE — what is REUSED vs what is NEW here.** The isolation SUBSTRATE is
+ * reused verbatim; the per-item EXECUTION is genuinely new:
+ *
+ *   - REUSED: `resolveArbiterUrlFromCheckout` (`do.ts`, the CLI resolves the
+ *     arbiter URL from cwd and threads it in here); the hub-mirror + isolation
+ *     seam (`ensureMirror` + {@link jobWorktreeDoDriver}, which materialises its
+ *     own job worktree off the arbiter for the build/task rungs + reaps it); and
+ *     the SCAN→SELECT→REFETCH SKELETON of `performDoRemoteAuto` (`do-remote-auto.ts`).
+ *   - NEW: the **isolated advance-tick runner** ({@link performAdvanceIsolated}) —
+ *     the per-item unit that runs `performAdvance` (classify → `advancing` lock →
+ *     surface/apply/triage/build-orchestrate) inside a working clone off the
+ *     cwd-resolved arbiter, then reaps it. `do --isolated`'s per-item runner is
+ *     `performDoRemote` (the DO BUILD/TASK pipeline), which does NOT run the
+ *     advance tick — so it is NOT reusable as the per-item step; only the loop
+ *     SKELETON is. This module builds the advance analogue + its driver wiring; it
+ *     introduces NO new isolation MECHANISM (US #26 stays true).
+ *
+ * **Why an isolated cwd composes with all five rungs (only the runner is new).**
+ * The advance tick threads a `cwd` + `arbiter` + a build/task `doDriver`:
+ *
+ *   - the **build-task / task-spec** rungs ORCHESTRATE `do`/`do spec:` via the
+ *     `doDriver` seam — we inject {@link jobWorktreeDoDriver} (off the cwd-resolved
+ *     arbiter), so they build/task ISOLATED in their OWN job worktree (the SAME
+ *     isolation `do --isolated` gives the build tick) instead of in `process.cwd()`;
+ *   - the **surface / apply / triage** rungs do tree-less, identity-keyed,
+ *     ARBITER-resolved CAS writes (the sidecar + `needsAnswers`, the `advancing`
+ *     borrow, observation→promote new-item creation) — they target the arbiter
+ *     regardless of which checkout the tick runs in, so they compose with an
+ *     isolated cwd unchanged. The isolated cwd is a working CLONE of the arbiter
+ *     (origin = the arbiter), so those rungs commit/CAS against the arbiter exactly
+ *     as the in-place tick does in the human's participating checkout.
+ *
+ * That composition is WHY only the per-item runner is new — the rungs need no
+ * change, just an isolated cwd to run in.
+ */
+/** The per-item context an isolated advance tick consumes (everything BUT `arg`). */
+export interface IsolatedAdvanceContext extends Omit<AdvanceContext, 'cwd'> {
+    /**
+     * The arbiter URL the isolated worktree is off — resolved from the CWD's
+     * arbiter remote by the CLI (`resolveArbiterUrlFromCheckout`), exactly as
+     * `do --isolated` resolves its `remote`. `--remote <url>` supplies a foreign
+     * arbiter URL here instead (mirroring `do`: `--remote` wins over `--isolated`).
+     */
+    remote: string;
+    /**
+     * The agents' execution area (config `workspacesDir`) — where the hub mirror +
+     * the per-item working clone + the build/task job worktrees live. NEVER the
+     * human area.
+     */
+    workspacesDir: string;
+}
+/** Options for {@link performAdvanceIsolated} — the per-item isolated tick. */
+export interface PerformAdvanceIsolatedOptions extends IsolatedAdvanceContext {
+    /** The raw advance arg: bare (= task), `prd:<slug>`, or `obs:<slug>`. */
+    arg: string;
+    /** The read seam (slug resolution / pool); defaults to {@link ledgerRead}. */
+    read?: LedgerReadStrategy;
+    /** Environment for child git/agent processes. */
+    env?: NodeJS.ProcessEnv;
+    /**
+     * Override the per-item tick runner (tests inject a stub to assert the cwd is
+     * the isolated clone, never the checkout). Defaults to {@link performAdvance}.
+     */
+    run?: AdvanceTickRunner;
+}
+/**
+ * Run ONE advance tick ISOLATED off the resolved arbiter — the per-item runner.
+ *
+ * It materialises a per-item working CLONE of the arbiter under the agents' area
+ * (via the shared hub mirror — `ensureMirror` once + a cheap local clone of the
+ * bare mirror, refetched so its `main` is current), points the advance tick's cwd
+ * at it, threads a {@link jobWorktreeDoDriver} so the build/task rungs isolate in
+ * their OWN worktree off the SAME arbiter, runs the tick, then REAPS the clone.
+ * The current checkout is NEVER touched (the isolation point), and a failed tick
+ * reaps its clone like a failed `do --isolated`.
+ */
+export declare function performAdvanceIsolated(options: PerformAdvanceIsolatedOptions): Promise<AdvanceResult>;
+/** Options shared with every per-item isolated tick run, threaded verbatim. */
+type SharedIsolatedContext = IsolatedAdvanceContext;
+export interface PerformAdvanceIsolatedMultiOptions extends SharedIsolatedContext {
+    /**
+     * The resolved (remote) repo config — provides `autoBuild`/`autoTask` (the
+     * mirror scan applies them at the SELECTION layer) + `selectionOrder` (the
+     * cross-pool order), exactly as the in-place one-shot driver applies them.
+     */
+    config: Config;
+    /**
+     * `advance --isolated -n <x>`: how many eligible items to advance, IN SEQUENCE.
+     * Auto-pick (no arg, no count) ⇒ 1. SEQUENTIAL — never a parallelism knob
+     * (US #25; parallelism is `run` / the CI matrix).
+     */
+    count?: number;
+    /** The read seam (mirror pool); defaults to {@link ledgerRead}. */
+    read?: LedgerReadStrategy;
+    /** Environment for child git/agent processes. */
+    env?: NodeJS.ProcessEnv;
+    /** Override the per-item isolated tick runner (tests). Defaults to {@link performAdvanceIsolated}. */
+    runIsolated?: (options: PerformAdvanceIsolatedOptions) => Promise<AdvanceResult>;
+    /** Override the per-tick runner forwarded to {@link performAdvanceIsolated} (tests). */
+    run?: AdvanceTickRunner;
+    /** Sink for a non-fatal mirror-config-read warning, forwarded to the scan. */
+    warn?: (message: string) => void;
+    /**
+     * The LIFECYCLE-POOL create-gates forwarded to {@link scanMirrorPool} (triage /
+     * surface sub-pools), the SAME gates the in-place auto-pick + the loop driver
+     * apply. Omitted ⇒ both off (the apply sub-pool is always-on).
+     */
+    lifecycleGates?: LifecyclePoolGates;
+}
+/**
+ * Run the `advance --isolated` AUTO-PICK / `-n <x>` form — the advance analogue of
+ * `performDoRemoteAuto`, SHARING its scan/select/refetch SKELETON but using the
+ * ISOLATED advance-tick runner as the per-item unit:
+ *
+ *   1. `ensureMirror` ONCE up front (the per-item runner re-`ensureMirror`s the
+ *      SAME mirror idempotently — a fetch, never a re-clone);
+ *   2. {@link scanMirrorPool} over the bare hub mirror's committed `main` (the
+ *      isolated counterpart of the in-place pool scan, gated per-action);
+ *   3. {@link selectPrioritised} (tasks-first / prds-first per `selectionOrder`, bounded by `count`);
+ *   4. a SEQUENTIAL loop over the FROZEN selected set (selected ONCE in 2–3, NEVER
+ *      re-scanned) where each per-item {@link performAdvanceIsolated} re-fetches the
+ *      SAME mirror, so item N's clone branches off a `main` that contains item N-1's
+ *      result (FRESHNESS, not re-selection — the SNAPSHOT-ONCE parity with
+ *      `do --isolated -n`).
+ *
+ * **`-n` is ALWAYS SEQUENTIAL (US #25)** — selecting N items from the mirror and
+ * running them one at a time is a dumb "run the tick N times" loop; parallelism is
+ * `run`'s concurrent loop or the CI matrix, NEVER `-n`. **SNAPSHOT-ONCE, NOT
+ * dependency-aware:** a `blockedBy` dependent ineligible at scan time is NOT
+ * selected and is NOT drained in the same run — IDENTICAL to `do --isolated -n`
+ * (dependency-aware scheduling is a SEPARATE cross-verb enhancement,
+ * `work/notes/observations/do-autopick-no-dependency-aware-scheduling.md`).
+ */
+export declare function performAdvanceIsolatedAuto(options: PerformAdvanceIsolatedMultiOptions): Promise<AdvanceMultiResult>;
+/**
+ * Run the EXPLICIT multi-arg form (`advance --isolated <a> <b> …`): the NAMED items
+ * in the GIVEN order (no pool/priority — the operator chose them), each through the
+ * ISOLATED advance-tick runner, SEQUENTIALLY. No mirror scan is needed (the args
+ * are explicit); the per-item tick resolves each bare/`prd:`/`obs:` arg itself.
+ */
+export declare function performAdvanceIsolatedArgs(args: string[], options: PerformAdvanceIsolatedMultiOptions): Promise<AdvanceMultiResult>;
+export {};
+//# sourceMappingURL=advance-isolated.d.ts.map

package/dist/advance-isolated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"advance-isolated.d.ts","sourceRoot":"","sources":["../src/advance-isolated.ts"],"names":[],"mappings":"AASA,OAAO,EAEN,KAAK,cAAc,EACnB,KAAK,aAAa,EAElB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAa,KAAK,kBAAkB,EAAC,MAAM,kBAAkB,CAAC;AAErE,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,sBAAsB,CAAC;AAC7D,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAC,iBAAiB,EAAE,kBAAkB,EAAC,MAAM,sBAAsB,CAAC;AAEhF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,qFAAqF;AACrF,MAAM,WAAW,sBAAuB,SAAQ,IAAI,CAAC,cAAc,EAAE,KAAK,CAAC;IAC1E;;;;;OAKG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,aAAa,EAAE,MAAM,CAAC;CACtB;AAED,+EAA+E;AAC/E,MAAM,WAAW,6BAA8B,SAAQ,sBAAsB;IAC5E,yEAAyE;IACzE,GAAG,EAAE,MAAM,CAAC;IACZ,8EAA8E;IAC9E,IAAI,CAAC,EAAE,kBAAkB,CAAC;IAC1B,iDAAiD;IACjD,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB;;;OAGG;IACH,GAAG,CAAC,EAAE,iBAAiB,CAAC;CACxB;AAID;;;;;;;;;;GAUG;AACH,wBAAsB,sBAAsB,CAC3C,OAAO,EAAE,6BAA6B,GACpC,OAAO,CAAC,aAAa,CAAC,CAuGxB;AA0BD,+EAA+E;AAC/E,KAAK,qBAAqB,GAAG,sBAAsB,CAAC;AAEpD,MAAM,WAAW,kCAAmC,SAAQ,qBAAqB;IAChF;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,mEAAmE;IACnE,IAAI,CAAC,EAAE,kBAAkB,CAAC;IAC1B,iDAAiD;IACjD,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,sGAAsG;IACtG,WAAW,CAAC,EAAE,CACb,OAAO,EAAE,6BAA6B,KAClC,OAAO,CAAC,aAAa,CAAC,CAAC;IAC5B,wFAAwF;IACxF,GAAG,CAAC,EAAE,iBAAiB,CAAC;IACxB,8EAA8E;IAC9E,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC;;;;OAIG;IACH,cAAc,CAAC,EAAE,kBAAkB,CAAC;CACpC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,0BAA0B,CAC/C,OAAO,EAAE,kCAAkC,GACzC,OAAO,CAAC,kBAAkB,CAAC,CAiE7B;AAED;;;;;GAKG;AACH,wBAAsB,0BAA0B,CAC/C,IAAI,EAAE,MAAM,EAAE,EACd,OAAO,EAAE,kCAAkC,GACzC,OAAO,CAAC,kBAAkB,CAAC,CAQ7B"}

package/dist/advance-isolated.js

@@ -0,0 +1,256 @@
+import { mkdirSync, rmSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { git } from './git.js';
+import { ensureMirror, encodeRepoKey } from './repo-mirror.js';
+import { jobWorktreeDoDriver } from './do.js';
+import { pushTreelessResult, TREELESS_RUNGS, } from './advance-treeless-publish.js';
+import { performAdvance, } from './advance.js';
+import { scanMirrorPool } from './mirror-pool-scan.js';
+import { ledgerRead } from './ledger-read.js';
+import { selectPrioritised } from './select-priority.js';
+const DEFAULT_ARBITER = 'origin';
+/**
+ * Run ONE advance tick ISOLATED off the resolved arbiter — the per-item runner.
+ *
+ * It materialises a per-item working CLONE of the arbiter under the agents' area
+ * (via the shared hub mirror — `ensureMirror` once + a cheap local clone of the
+ * bare mirror, refetched so its `main` is current), points the advance tick's cwd
+ * at it, threads a {@link jobWorktreeDoDriver} so the build/task rungs isolate in
+ * their OWN worktree off the SAME arbiter, runs the tick, then REAPS the clone.
+ * The current checkout is NEVER touched (the isolation point), and a failed tick
+ * reaps its clone like a failed `do --isolated`.
+ */
+export async function performAdvanceIsolated(options) {
+    const note = options.note ?? (() => { });
+    const env = options.env;
+    const run = options.run ?? performAdvance;
+    const arbiterRemoteName = options.arbiter ?? DEFAULT_ARBITER;
+    // 1. Ensure (create/fetch) the hub mirror for the resolved arbiter URL ONCE — the
+    //    SAME isolation substrate `do --isolated` / `run` use. The per-item clone is
+    //    cut from this freshly-fetched bare mirror (a cheap LOCAL clone, never a
+    //    re-clone of the arbiter), so the tick reads the latest committed `main`.
+    let mirror;
+    try {
+        mirror = ensureMirror({
+            url: options.remote,
+            workspacesDir: options.workspacesDir,
+            env,
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        note(message);
+        return { exitCode: 1, outcome: 'usage-error', message };
+    }
+    // 2. A per-item working CLONE of the mirror (the tree-less surface/apply/triage
+    //    rungs' ledger-write cwd — a bare mirror cannot `git mv`/`git commit`). Keyed
+    //    per ARG so two sequential items get DISTINCT clones (the SAME per-job keying
+    //    the remote claim clone uses). Its arbiter remote is wired to the REAL
+    //    arbiter URL so the `advancing` borrow + the observation→promote new-item CAS
+    //    target the arbiter, exactly as the in-place tick does from the human checkout.
+    const argKey = options.arg.replace(/[^a-zA-Z0-9._-]/g, '_');
+    const cloneDir = join(options.workspacesDir, 'advance-cwd', `${encodeRepoKey(mirror.url).split('/').join('__')}__${argKey}`);
+    rmSync(cloneDir, { recursive: true, force: true });
+    mkdirSync(dirname(cloneDir), { recursive: true });
+    try {
+        git(['clone', '--quiet', mirror.path, cloneDir], dirname(cloneDir), { env });
+        // Re-point the clone's arbiter remote at the REAL arbiter URL (a `git clone` of
+        // the bare MIRROR leaves `origin` pointing at the mirror). The tree-less rungs'
+        // ARBITER-resolved CAS writes (`advancing` borrow, observation->promote) + the
+        // ff-push of the result then target the arbiter — so they land there REGARDLESS
+        // of which checkout the tick ran in (the property that lets an isolated cwd
+        // compose with the surface/apply/triage rungs unchanged). When the configured
+        // arbiter remote is NOT `origin`, ADD it alongside the clone's `origin`.
+        if (arbiterRemoteName === 'origin') {
+            git(['remote', 'set-url', 'origin', mirror.url], cloneDir, { env });
+        }
+        else {
+            git(['remote', 'add', arbiterRemoteName, mirror.url], cloneDir, { env });
+        }
+        git(['fetch', '--quiet', arbiterRemoteName], cloneDir, { env });
+        // 3. Run the advance TICK against the isolated clone. The build/task rungs
+        //    ORCHESTRATE `do` through the INJECTED job-worktree driver (their OWN
+        //    worktree off the arbiter — the SAME isolation `run`'s build tick gives),
+        //    NOT in `process.cwd()`. The surface/apply/triage rungs run tree-less in
+        //    the clone, targeting the arbiter remote wired above.
+        const context = {
+            ...stripIsolatedFields(options),
+            cwd: cloneDir,
+            arbiter: arbiterRemoteName,
+            doDriver: jobWorktreeDoDriver({
+                // Off the REAL arbiter URL (NOT the local mirror path) so `performDoRemote`
+                // reuses the SAME hub mirror `ensureMirror` already created above (keyed on
+                // `mirror.url` = the resolved arbiter URL) + integrates back to the arbiter.
+                remote: mirror.url,
+                workspacesDir: options.workspacesDir,
+            }),
+        };
+        const result = await run({
+            ...context,
+            arg: options.arg,
+            read: options.read,
+        });
+        // A TREE-LESS rung (surface/apply/triage) committed the sidecar / marker
+        // LOCALLY in the clone; ff-push it to the arbiter so the result LANDS (a
+        // one-shot from a busy checkout would otherwise vanish with the reaped clone).
+        // The build/task rungs already pushed via the job-worktree `doDriver`.
+        if (result.exitCode === 0 &&
+            result.rung !== undefined &&
+            TREELESS_RUNGS.has(result.rung)) {
+            await pushTreelessResult({
+                cwd: cloneDir,
+                arbiter: arbiterRemoteName,
+                // Large liveness ceiling (C2, task `c2-rebase-until-real-on-durable-main-
+                // promotions`): a clean re-rebase no longer counts against a small budget;
+                // a genuine same-path conflict still stops definitively.
+                retries: 1000,
+                env,
+                note,
+            });
+        }
+        return result;
+    }
+    finally {
+        // 4. REAP the per-item clone (a disposable working tree, like a failed
+        //    `do --isolated`'s worktree). The durable artifact is the arbiter; the
+        //    clone is never the recovery surface.
+        rmSync(cloneDir, { recursive: true, force: true });
+    }
+}
+/** Strip the isolated-only fields, leaving exactly the per-item {@link AdvanceContext} base. */
+function stripIsolatedFields(options) {
+    const { remote: _remote, workspacesDir: _workspacesDir, arg: _arg, read: _read, env: _env, run: _run, arbiter: _arbiter, ...rest } = options;
+    void _remote;
+    void _workspacesDir;
+    void _arg;
+    void _read;
+    void _env;
+    void _run;
+    void _arbiter;
+    return rest;
+}
+/**
+ * Run the `advance --isolated` AUTO-PICK / `-n <x>` form — the advance analogue of
+ * `performDoRemoteAuto`, SHARING its scan/select/refetch SKELETON but using the
+ * ISOLATED advance-tick runner as the per-item unit:
+ *
+ *   1. `ensureMirror` ONCE up front (the per-item runner re-`ensureMirror`s the
+ *      SAME mirror idempotently — a fetch, never a re-clone);
+ *   2. {@link scanMirrorPool} over the bare hub mirror's committed `main` (the
+ *      isolated counterpart of the in-place pool scan, gated per-action);
+ *   3. {@link selectPrioritised} (tasks-first / prds-first per `selectionOrder`, bounded by `count`);
+ *   4. a SEQUENTIAL loop over the FROZEN selected set (selected ONCE in 2–3, NEVER
+ *      re-scanned) where each per-item {@link performAdvanceIsolated} re-fetches the
+ *      SAME mirror, so item N's clone branches off a `main` that contains item N-1's
+ *      result (FRESHNESS, not re-selection — the SNAPSHOT-ONCE parity with
+ *      `do --isolated -n`).
+ *
+ * **`-n` is ALWAYS SEQUENTIAL (US #25)** — selecting N items from the mirror and
+ * running them one at a time is a dumb "run the tick N times" loop; parallelism is
+ * `run`'s concurrent loop or the CI matrix, NEVER `-n`. **SNAPSHOT-ONCE, NOT
+ * dependency-aware:** a `blockedBy` dependent ineligible at scan time is NOT
+ * selected and is NOT drained in the same run — IDENTICAL to `do --isolated -n`
+ * (dependency-aware scheduling is a SEPARATE cross-verb enhancement,
+ * `work/notes/observations/do-autopick-no-dependency-aware-scheduling.md`).
+ */
+export async function performAdvanceIsolatedAuto(options) {
+    const runIsolated = options.runIsolated ?? performAdvanceIsolated;
+    const read = options.read ?? ledgerRead;
+    const note = options.note ?? (() => { });
+    const count = options.count ?? 1;
+    // Ensure the bare hub mirror ONCE up front so the pool scan reads the freshest
+    // committed `main`. Each per-item `performAdvanceIsolated` re-ensures the SAME
+    // mirror idempotently (a fetch, never a re-clone).
+    let mirror;
+    try {
+        mirror = ensureMirror({
+            url: options.remote,
+            workspacesDir: options.workspacesDir,
+            env: options.env,
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        note(message);
+        return { results: [], exitCode: 1, message };
+    }
+    // Scan the mirror's committed `main` for the SAME pools the in-place scan
+    // enumerates (eligible tasks gated on `autoBuild`, taskable prds gated on
+    // `autoTask`, + the lifecycle sub-pools), through the SHARED mirror-pool scan.
+    const scan = await scanMirrorPool({
+        mirrorPath: mirror.path,
+        config: options.config,
+        read,
+        warn: options.warn,
+        env: options.env,
+        lifecycleGates: options.lifecycleGates,
+    });
+    // Order across the pools per the resolved `selectionOrder` + bound by count —
+    // the SAME shared, pure `selectPrioritised` the in-place + `run` drivers use.
+    // Selected ONCE here; the loop iterates the FROZEN set (snapshot-once).
+    const selected = selectPrioritised({
+        report: scan.report,
+        caps: {
+            maxParallel: Number.MAX_SAFE_INTEGER,
+            perRepoMax: Number.MAX_SAFE_INTEGER,
+        },
+        specs: scan.specs,
+        selectionOrder: options.config.selectionOrder,
+        lifecycle: scan.lifecycle,
+        count,
+    });
+    if (selected.length === 0) {
+        const message = 'Nothing eligible to advance on the remote (no eligible tasks and no ' +
+            'taskable prds under the per-action gates).';
+        note(message);
+        return { results: [], exitCode: 0, message };
+    }
+    const results = [];
+    for (const item of selected) {
+        const result = await runIsolated(perItemOptions(options, argForSelected(item)));
+        results.push(result);
+    }
+    return aggregate(results);
+}
+/**
+ * Run the EXPLICIT multi-arg form (`advance --isolated <a> <b> …`): the NAMED items
+ * in the GIVEN order (no pool/priority — the operator chose them), each through the
+ * ISOLATED advance-tick runner, SEQUENTIALLY. No mirror scan is needed (the args
+ * are explicit); the per-item tick resolves each bare/`prd:`/`obs:` arg itself.
+ */
+export async function performAdvanceIsolatedArgs(args, options) {
+    const runIsolated = options.runIsolated ?? performAdvanceIsolated;
+    const results = [];
+    for (const arg of args) {
+        const result = await runIsolated(perItemOptions(options, arg));
+        results.push(result);
+    }
+    return aggregate(results);
+}
+/** The advance arg for a pool-selected item (the SELECTION->ARG dispatch). */
+function argForSelected(item) {
+    if (item.namespace === 'observation') {
+        return `obs:${item.slug}`;
+    }
+    return item.namespace === 'spec' ? `spec:${item.slug}` : item.slug;
+}
+/** Build the per-item {@link PerformAdvanceIsolatedOptions} for one arg. */
+function perItemOptions(options, arg) {
+    const { config: _config, count: _count, read, env, runIsolated: _runIsolated, run, warn: _warn, lifecycleGates: _lifecycleGates, ...rest } = options;
+    void _config;
+    void _count;
+    void _runIsolated;
+    void _warn;
+    void _lifecycleGates;
+    return { ...rest, arg, read, env, run };
+}
+/** Aggregate per-item results into the multi-item contract (mirrors `do`'s). */
+function aggregate(results) {
+    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 = `advanced ${results.length} item${results.length === 1 ? '' : 's'} ` +
+        `(${ok} ok, ${results.length - ok} not).`;
+    return { results, exitCode, message };
+}
+//# sourceMappingURL=advance-isolated.js.map