dorfl 0.0.0 → 0.1.0

package/dist/advance-loop-driver.js

@@ -0,0 +1,437 @@
+import { performAdvance, } from './advance.js';
+import { scanMirrorPool } from './mirror-pool-scan.js';
+import { ledgerRead } from './ledger-read.js';
+import { selectPrioritised } from './select-priority.js';
+import { runConcurrent } from './concurrency.js';
+import { scan } from './scan.js';
+import { run as runProcess } from './git.js';
+import { jobWorktreeDoDriver } from './do.js';
+import { pushTreelessResult, TREELESS_RUNGS, } from './advance-treeless-publish.js';
+/**
+ * Run ONE batch of the loop driver: scan the mirror's eligible pool, select +
+ * order it (gated per-action), and run the advance TICK per item CONCURRENTLY,
+ * each independently `advancing`-lock-guarded inside {@link performAdvance}.
+ * Returns every item's result (input order preserved). A `run` daemon / CI cron
+ * loops THIS — the loop owns cadence, the batch owns one round's work.
+ */
+export async function advanceOnce(options) {
+    const run = options.run ?? performAdvance;
+    const read = options.read ?? ledgerRead;
+    const maxParallel = options.maxParallel ?? options.config.maxParallel;
+    const perRepoMax = options.perRepoMax ?? options.config.perRepoMax;
+    // Enumerate the eligible pool from the bare mirror's committed `main` — the
+    // SHARED `mirror-side-eligible-pool-scan` (gated on `autoBuild`/`autoTask`).
+    const scan = await scanMirrorPool({
+        mirrorPath: options.mirrorPath,
+        config: options.config,
+        ref: options.ref,
+        read,
+        warn: options.warn,
+        env: options.env,
+        lifecycleGates: options.lifecycleGates,
+    });
+    // Order across the (up to) FIVE pools per the resolved `selectionOrder` (apply
+    // pinned first) — ALL eligible items (the loop drains the whole pool each batch;
+    // `count` is the one-shot/`-n` concern). The lifecycle pools come from the SHARED
+    // mirror enumeration, so the loop/CI selection agrees with the in-place one-shot.
+    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,
+    });
+    if (selected.length === 0) {
+        return { items: [] };
+    }
+    // Run the tick per item CONCURRENTLY (the SAME bounded scheduler `run`'s build
+    // tick uses), each independently `advancing`-lock-guarded inside the tick. The
+    // scheduler never rejects — a thrown tick is captured, so one item can never
+    // abort the batch (mirrors `runOnce`'s settled-slot contract).
+    const settled = await runConcurrent({
+        items: selected,
+        maxInFlight: Math.max(1, maxParallel),
+        // The mirror is ONE repo, so every item shares the repo key — `perRepoMax`
+        // bounds the whole batch (matching `run`'s per-repo cap semantics).
+        keyFor: () => options.mirrorPath,
+        perKeyMax: Math.max(1, perRepoMax),
+        worker: async (item) => {
+            const result = await run({
+                ...options.context,
+                arg: argForSelected(item),
+                read,
+            });
+            // A TREE-LESS rung (surface/apply/triage) committed its sidecar / marker
+            // LOCALLY in the shared per-mirror `treelessCwd` (`context.cwd`); ff-push
+            // it to the mirror's arbiter so the result LANDS on `main` (the CLI wipes +
+            // re-clones that cwd EACH TICK, so an un-pushed local commit is lost). The
+            // build/task rungs already pushed via the job-worktree `doDriver`.
+            //
+            // The bounded re-fetch+rebase retry inside `pushTreelessResult` is
+            // LOAD-BEARING here: the `treelessCwd` is cloned ONCE per mirror at tick
+            // start and SHARED across the mirror's SERIAL batch, so a `build`/`task`
+            // rung EARLIER in the batch can integrate to the mirror's `main` mid-tick
+            // and a LATER tree-less push is non-fast-forward BY CONSTRUCTION — the
+            // retry rebases the slug-only commit onto the advanced `main` and lands it.
+            if (result.exitCode === 0 &&
+                result.rung !== undefined &&
+                TREELESS_RUNGS.has(result.rung) &&
+                options.context.cwd !== undefined) {
+                await pushTreelessResult({
+                    cwd: options.context.cwd,
+                    arbiter: options.context.arbiter ?? 'origin',
+                    // 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: options.env,
+                    note: options.context.note ?? (() => { }),
+                });
+            }
+            return result;
+        },
+    });
+    const items = settled.map((slot, i) => {
+        const arg = argForSelected(selected[i]);
+        if ('ok' in slot) {
+            return { arg, result: slot.ok };
+        }
+        // A captured throw → a usage-error result (never crashes the batch).
+        const detail = slot.error instanceof Error ? slot.error.message : String(slot.error);
+        return {
+            arg,
+            result: { exitCode: 1, outcome: 'usage-error', message: detail },
+        };
+    });
+    return { items };
+}
+/**
+ * The advance arg for a selected item (the SELECTION->ARG dispatch): `obs:<slug>`
+ * for an observation (the triage rung), `spec:<slug>` for a spec, bare slug for a
+ * task. The tick re-classifies each arg into the right rung (surface/apply for a
+ * `needsAnswers`-blocked task/spec; triage for an observation).
+ */
+function argForSelected(item) {
+    if (item.namespace === 'observation') {
+        return `obs:${item.slug}`;
+    }
+    return item.namespace === 'spec' ? `spec:${item.slug}` : item.slug;
+}
+/**
+ * Read a bare hub mirror's `origin` URL (`git -C <mirror> remote get-url
+ * origin`) — the arbiter URL the per-mirror job-worktree `do` driver
+ * ({@link jobWorktreeDoDriver}) materialises its worktree off (the SAME URL
+ * `run`'s `claimAgainstRepo` resolves; `registry.ts readOriginUrl` reads it for
+ * the registry view). Falls back to a `file://<path>` URL when the remote is
+ * unreadable, so a malformed/origin-less mirror still resolves to SOMETHING
+ * addressable rather than throwing mid-batch.
+ */
+function mirrorOriginUrl(mirrorPath, env) {
+    const result = runProcess('git', ['remote', 'get-url', 'origin'], mirrorPath, { env });
+    const url = result.status === 0 ? result.stdout.trim() : '';
+    return url !== '' ? url : `file://${mirrorPath}`;
+}
+/**
+ * The **registry-set advance DRIVER** with **per-mirror job-worktree isolation**
+ * (task `advance-loop-driver-registry-set-job-worktrees`) — the advance-tick TWIN
+ * of `runOnce`/`runOneItem`'s build substrate, the substrate `run-uses-advance-tick`
+ * needs to become a clean tick swap. Where {@link advanceOnce} drains ONE named
+ * mirror's pool IN-PLACE (the single-mirror path), this driver:
+ *
+ *   1. **discovers the REGISTRY SET** the SAME way `runOnce` does — via
+ *      {@link scan} over `config.workspacesDir`'s hub mirrors (NOT a single
+ *      `--advance <mirror>` arg); and
+ *   2. loops {@link advanceOnce}'s batch over that set, GENUINELY CONCURRENT
+ *      ACROSS REPOS under {@link runConcurrent} (`maxParallel` global /
+ *      `perRepoMax` per repo — the SAME scheduler `run`'s build tick uses), each
+ *      mirror's pool itself drained concurrently by `advanceOnce` (reusing the
+ *      per-item `advancing` borrow INSIDE {@link performAdvance} — no new lock,
+ *      no new scheduler); and
+ *   3. threads a **per-mirror job-worktree `doDriver`** ({@link jobWorktreeDoDriver})
+ *      into each mirror's advance context, so the build/task rungs run isolated
+ *      in their OWN worktree off THAT mirror's arbiter (the SAME isolation
+ *      `runOneItem` gives the build tick) instead of in `process.cwd()`. The
+ *      surface/triage/apply rungs stay on their tree-less ledger-write moves
+ *      (no build worktree needed) — the worktree driver governs ONLY the
+ *      build/task orchestration target.
+ *
+ * Under calm gates (both lifecycle create-gates off) this is the OBSERVABLE-
+ * OUTCOME equivalent of plain `run`'s build tick over the same registry: build
+ * ready tasks / task ready prds, each per-job-worktree-isolated off the
+ * mirror's arbiter, same integration result — two callers of one
+ * `performIntegration` band (the advance build rung reaches it via `performDo`
+ * → `performDoRemote`; `runOneItem` reaches it directly), NOT a shared code path.
+ */
+export async function advanceRegistrySet(options) {
+    const config = options.config;
+    const workspace = options.workspace ?? config.workspacesDir;
+    // DISCOVERY = the registry (the hub-mirror set, ADR §1) — the SAME `scan(config)`
+    // `runOnce` uses. Each row's `path` is a bare hub mirror to drain.
+    const report = options.report ??
+        (await scan(config, {
+            warn: options.warn,
+            env: options.env,
+            override: options.override,
+        }));
+    const mirrors = report.repos.map((repo) => repo.path);
+    // GENUINELY CONCURRENT ACROSS REPOS (the registry-set point) under the SAME
+    // bounded scheduler `run`'s build tick uses: `maxParallel` bounds the whole
+    // registry sweep, one `advanceOnce` per mirror in flight.
+    //
+    // WITHIN one mirror the batch is SERIALISED (`perRepoMax: 1` into `advanceOnce`).
+    // WHY: the per-item `advancing` borrow + the tree-less surface/triage/apply rungs
+    // commit in the per-mirror `context.cwd` working tree, and the borrow's CAS is
+    // race-correct ONLY when each contender holds its OWN clone (the distinct-clone
+    // model `advancing-lock.ts` is built + tested against — two contenders sharing
+    // one checkout corrupt each other's HEAD/index, the SAME reason `run` serialises
+    // the per-repo CLAIM via `createKeyedLock`). A bare mirror has no per-item cwd, so
+    // the build/task rungs already get their OWN job worktree (via `jobWorktreeDoDriver`
+    // → `performDoRemote`) but the lock + tree-less rungs share the one cwd — so within
+    // ONE mirror they must run one-at-a-time. Cross-mirror concurrency (distinct
+    // arbiters → distinct cwds, no contention) stays GENUINE, which is the
+    // registry-set point. Per-item-cwd isolation (to also parallelise WITHIN a
+    // mirror) is a follow-up; this task keeps the borrow reused unchanged + correct.
+    const settled = await runConcurrent({
+        items: mirrors,
+        maxInFlight: Math.max(1, config.maxParallel),
+        keyFor: (mirrorPath) => mirrorPath,
+        perKeyMax: 1,
+        worker: (mirrorPath) => {
+            const originUrl = mirrorOriginUrl(mirrorPath, options.env);
+            // The per-mirror context the CLI shaped (gates + doOptions base) PLUS the
+            // per-mirror job-worktree `doDriver` injected here, so the build/task rungs
+            // build isolated off THIS mirror's arbiter (cwd untouched).
+            const baseContext = options.contextFor({ mirrorPath, originUrl });
+            const context = {
+                ...baseContext,
+                doDriver: jobWorktreeDoDriver({
+                    remote: originUrl,
+                    workspacesDir: workspace,
+                }),
+            };
+            return advanceOnce({
+                mirrorPath,
+                config,
+                context,
+                run: options.run,
+                read: options.read,
+                warn: options.warn,
+                env: options.env,
+                lifecycleGates: options.lifecycleGates,
+                // SERIALISE within the mirror (one tick at a time over the shared cwd) —
+                // the borrow + tree-less rungs commit in `context.cwd` and are race-correct
+                // only per distinct clone (see the block above). Cross-mirror concurrency
+                // is genuine (the outer `runConcurrent`).
+                maxParallel: 1,
+                perRepoMax: 1,
+            });
+        },
+    });
+    // One mirror can never abort the registry sweep: a captured throw becomes an
+    // empty batch (mirrors `advanceOnce`'s per-item settled-slot contract one layer up).
+    const mirrorResults = settled.map((slot, i) => ({
+        mirrorPath: mirrors[i],
+        batch: 'ok' in slot ? slot.ok : { items: [] },
+    }));
+    return { mirrors: mirrorResults };
+}
+/** Project a whole registry-set batch onto the convergence counts (a pure sum). */
+export function advanceRegistrySetSummary(result) {
+    let advanced = 0;
+    let idle = 0;
+    let stuck = 0;
+    let total = 0;
+    for (const { batch } of result.mirrors) {
+        const s = advanceBatchSummary(batch);
+        advanced += s.advanced;
+        idle += s.idle;
+        stuck += s.stuck;
+        total += s.total;
+    }
+    return { advanced, idle, stuck, total };
+}
+/** Summarise a batch into the convergence counts (a pure projection). */
+export function advanceBatchSummary(result) {
+    let advanced = 0;
+    let idle = 0;
+    let stuck = 0;
+    for (const { result: r } of result.items) {
+        if (r.outcome === 'no-op') {
+            idle++;
+        }
+        else if (r.exitCode === 0) {
+            advanced++;
+        }
+        else {
+            stuck++;
+        }
+    }
+    return { advanced, idle, stuck, total: result.items.length };
+}
+/**
+ * Is this batch CALM-AT-REST (US #31) — every selected item idled (a pending
+ * sidecar awaiting a human) and nothing failed? A pending-sidecar pool is STABLE:
+ * the loop re-ticks it, finds all no-ops, and idles without thrash. As answers
+ * arrive the idle count shrinks MONOTONICALLY (an answered item flips to an
+ * advance), so the loop converges.
+ */
+export function isBatchCalmAtRest(result) {
+    const s = advanceBatchSummary(result);
+    return s.total > 0 && s.advanced === 0 && s.stuck === 0;
+}
+/**
+ * Adapt the {@link advanceOnce} LOOP DRIVER to the {@link RunTick} swap SEAM so
+ * `run` (≡ CI, US #7) drives the ADVANCE tick over the mirror-side eligible pool
+ * instead of the build tick. `run.ts` deliberately writes {@link runLoop} against
+ * {@link RunTick} (NOT against `runOnce`) precisely so the advance-loop prd can
+ * swap the tick WITHOUT re-architecting the loop — this is that swap.
+ *
+ * The seam is `(RunOnceOptions) => Promise<RunOnceResult>`; one advance batch is
+ * `(AdvanceOnceOptions) => Promise<AdvanceBatchResult>`. The deps the advance
+ * batch needs that the generic per-tick options do NOT carry (the mirror to
+ * drain, the remote config, the per-item advance context) are CLOSED OVER here;
+ * the per-tick `RunOnceOptions` contribute only the cross-cutting seams that DO
+ * generalise — `onWarn` (the warning sink) and `env` (the git env). The batch's
+ * own item-level pool scan supersedes `RunOnceOptions.report` (the build tick's
+ * checkout scan), so that field is ignored for the advance tick.
+ *
+ * The {@link AdvanceBatchResult} is projected onto {@link RunOnceResult} so the
+ * loop's aggregation/reporting (`claimedAndDone` / `skipped` / `failed` /
+ * `needsAttention`) works UNCHANGED — an `advanced` item is `claimed-done`, an
+ * idling pending-sidecar `no-op` is `lost-race` (skipped, calm-at-rest), a CAS
+ * loser is `claim-contended` (skipped), and any error is `needs-attention`. So
+ * the loop's existing convergence signal (`claimedAndDone` falls to 0 once the
+ * pool is all idle) doubles as the advance loop's drain/idle signal (US #31).
+ */
+export function advanceRunTick(deps) {
+    return async (options) => {
+        const batch = await advanceOnce({
+            mirrorPath: deps.mirrorPath,
+            config: deps.config,
+            ref: deps.ref,
+            context: deps.context,
+            run: deps.run,
+            read: deps.read,
+            lifecycleGates: deps.lifecycleGates,
+            maxParallel: deps.maxParallel,
+            perRepoMax: deps.perRepoMax,
+            // Cross-cutting seams that DO generalise come from the per-tick options
+            // (the SAME ones the build tick receives) — so a `run` daemon threads its
+            // warning sink + git env to the advance tick identically.
+            warn: options.onWarn,
+            env: options.env,
+        });
+        return batchToRunOnceResult(batch, deps.mirrorPath);
+    };
+}
+/**
+ * Adapt the REGISTRY-SET advance DRIVER ({@link advanceRegistrySet}) onto the
+ * {@link RunTick} swap SEAM so plain `run` (no flag) drives the ADVANCE tick over
+ * the WHOLE registry instead of the build tick (`runOnce`) — the task
+ * `run-uses-advance-tick`. `run.ts` deliberately writes {@link runLoop} against
+ * {@link RunTick} (NOT against `runOnce`) precisely so the advance-loop design can
+ * swap the tick WITHOUT re-architecting the loop; this is that swap, now pointing
+ * the seam at the REGISTRY-SET advance driver the precursor built (registry-set
+ * discovery + per-mirror job-worktree isolation — the SAME substrate plain `run`'s
+ * build tick uses).
+ *
+ * Under calm gates (both lifecycle create-gates off) this is the OBSERVABLE-
+ * OUTCOME equivalent of plain `run`'s build tick over the same registry: build
+ * ready tasks / task ready prds, each per-job-worktree-isolated off the
+ * mirror's arbiter, same integration result; touch no observations, surface no
+ * questions. Flip a gate and the SAME tick performs the lifecycle
+ * (triage / surface / apply) for free — no separate `--advance` mode to discover.
+ *
+ * The seam is `(RunOnceOptions) => Promise<RunOnceResult>`; one registry-set
+ * batch is `(AdvanceRegistrySetOptions) => Promise<AdvanceRegistrySetResult>`. The
+ * deps the batch needs that the generic per-tick options do NOT carry (the config,
+ * the per-mirror context factory, the workspace) are CLOSED OVER here; the
+ * per-tick `RunOnceOptions` contribute only the cross-cutting seams that DO
+ * generalise — `onWarn` (the warning sink) and `env` (the git env). The batch's
+ * own registry discovery supersedes `RunOnceOptions.report` (the build tick's
+ * checkout scan), so that field is ignored for the advance tick.
+ */
+export function advanceRegistrySetRunTick(deps) {
+    return async (options) => {
+        const result = await advanceRegistrySet({
+            config: deps.config,
+            override: deps.override,
+            contextFor: deps.contextFor,
+            workspace: deps.workspace,
+            run: deps.run,
+            read: deps.read,
+            lifecycleGates: deps.lifecycleGates,
+            // Cross-cutting seams that DO generalise come from the per-tick options
+            // (the SAME ones the build tick receives) — so the `run` daemon threads its
+            // warning sink + git env to the advance tick identically.
+            warn: options.onWarn,
+            env: options.env,
+        });
+        return registrySetToRunOnceResult(result);
+    };
+}
+/**
+ * Project a whole REGISTRY-SET advance batch onto a {@link RunOnceResult} so the
+ * existing run loop aggregates + reports it with NO advance-specific code. Each
+ * mirror's per-item results are flattened (the `repoPath` is that mirror; the
+ * `slug` is the advanced arg), reusing the SAME per-item status mapping the
+ * single-mirror {@link batchToRunOnceResult} uses — so the loop's convergence
+ * signal (`claimedAndDone` falls to 0 once every pool idles) holds across the
+ * registry exactly as it does for one mirror.
+ */
+function registrySetToRunOnceResult(result) {
+    const items = result.mirrors.flatMap(({ mirrorPath, batch }) => batch.items.map(({ arg, result: r }) => ({
+        repoPath: mirrorPath,
+        slug: arg,
+        status: advanceOutcomeToItemStatus(r),
+        detail: r.message,
+    })));
+    const claimedAndDone = items.filter((i) => i.status === 'claimed-done').length;
+    const skipped = items.filter((i) => i.status === 'lost-race' || i.status === 'claim-contended').length;
+    const needsAttention = items.filter((i) => i.status === 'needs-attention').length;
+    const failed = needsAttention;
+    return { claimedAndDone, skipped, failed, needsAttention, items };
+}
+/**
+ * Project one advance batch onto a {@link RunOnceResult} so the existing run loop
+ * aggregates + reports it with NO advance-specific code. The `repoPath` is the
+ * mirror (the one repo this batch drains); the `slug` is the advanced arg.
+ */
+function batchToRunOnceResult(batch, mirrorPath) {
+    const items = batch.items.map(({ arg, result }) => ({
+        repoPath: mirrorPath,
+        slug: arg,
+        status: advanceOutcomeToItemStatus(result),
+        detail: result.message,
+    }));
+    const claimedAndDone = items.filter((i) => i.status === 'claimed-done').length;
+    const skipped = items.filter((i) => i.status === 'lost-race' || i.status === 'claim-contended').length;
+    const needsAttention = items.filter((i) => i.status === 'needs-attention').length;
+    const failed = needsAttention;
+    return { claimedAndDone, skipped, failed, needsAttention, items };
+}
+/**
+ * Map one advance tick's outcome onto the run loop's {@link ItemStatus} so the
+ * loop's counters carry the convergence semantics: an item that ADVANCED a rung
+ * is `claimed-done`; a `no-op` (an idling pending sidecar — the calm-at-rest
+ * population) is `lost-race` (skipped, NOT a failure — the loop does no work on
+ * it and does not retry); a CAS `lost`/`contended` is `lost-race`/
+ * `claim-contended` (a parallel sibling won; back off); anything else (a
+ * usage/invariant error or a captured throw) is `needs-attention`.
+ */
+function advanceOutcomeToItemStatus(result) {
+    if (result.exitCode === 0) {
+        return result.outcome === 'no-op' ? 'lost-race' : 'claimed-done';
+    }
+    if (result.exitCode === 2 || result.outcome === 'lost') {
+        return 'lost-race';
+    }
+    if (result.exitCode === 3 || result.outcome === 'contended') {
+        return 'claim-contended';
+    }
+    return 'needs-attention';
+}
+//# sourceMappingURL=advance-loop-driver.js.map

package/dist/advance-loop-driver.js.map

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

package/dist/advance-treeless-publish.d.ts

@@ -0,0 +1,108 @@
+/**
+ * The SHARED tree-less-result PUBLISH (task
+ * `loop-advance-persists-treeless-rungs-to-arbiter`) — the ONE implementation of
+ * "ff-push a locally-committed tree-less rung result to the arbiter" called by
+ * BOTH advance drivers that run the tick in a working clone:
+ *
+ *   - the one-shot ISOLATED runner (`advance-isolated.ts`'s
+ *     {@link import('./advance-isolated.js')} `performAdvanceIsolated`), and
+ *   - the LOOP / registry-set driver (`advance-loop-driver.ts`'s `advanceOnce`),
+ *     whose per-mirror `treelessCwd` (cloned once per tick by the CLI) is wiped +
+ *     re-cloned every tick, so a locally-committed sidecar would otherwise be lost.
+ *
+ * The tree-less lifecycle rungs (surface / apply / triage-observation) commit the
+ * sidecar / `needsAnswers` / `triaged:` marker LOCALLY in their working clone
+ * (`surface-persist.ts`, `apply-persist.ts`); only the `advancing` borrow + the
+ * promote-CAS reach the arbiter on their own. The arbiter is the source of truth
+ * for the ledger, so a local commit in a per-tick clone is NOT on the ledger until
+ * pushed. This is that push — NO new isolation MECHANISM, just a git ff-push of an
+ * already-committed `main`.
+ *
+ * The bounded re-fetch + rebase retry is LOAD-BEARING, not defensive padding:
+ *   - one-shot: a sequential `-n` run ff-pushes item 1's surface, then item 2's
+ *     clone branches off the advanced `main`;
+ *   - loop: a single mirror's SERIAL batch routinely MIXES rungs — a `build`/`task`
+ *     rung integrates `work/<slug>` to the mirror's `main` MID-TICK (via the
+ *     job-worktree `doDriver`), and a LATER tree-less rung in the SAME batch holds a
+ *     `treelessCwd` cloned BEFORE that integration. So its `HEAD:main` push is
+ *     non-fast-forward BY CONSTRUCTION (not a rare concurrent race) — the retry MUST
+ *     re-fetch the advanced `main` and rebase the one slug-only tree-less commit onto
+ *     it before pushing. The tree-less commit touches only the slug's sidecar/marker,
+ *     so the rebase applies cleanly.
+ *
+ * **C2 rebase-until-real-conflict (task `c2-rebase-until-real-on-durable-main-
+ * promotions`).** This same `HEAD:main` push carries the won't-proceed terminal
+ * `tasks/ready → tasks/cancelled` / `prds/ready → prds/dropped` (slug-RELOCATION
+ * family) when `apply-persist.ts` resolves a `dropped` disposition; under sustained
+ * parallel load on the shared `main` ref two DIFFERENT items' concurrent promotions
+ * can falsely-contend even though nothing tree-conflicts, exhausting a small fixed
+ * cap. C2 turns the existing bounded retry into rebase-until-real-conflict: the
+ * GENUINE conflict terminator is REUSED — a rebase replay that fails (the slug is
+ * gone from its expected source folder on the new `main`, e.g. a concurrent
+ * legitimate same-item transition already moved it) STOPS the loop with the
+ * existing definitive outcome (the `rebase --abort` + note path below). A CLEAN
+ * re-rebase no longer counts against a tiny budget; `retries` is now a LARGE
+ * LIVENESS CEILING on the pathological livelock tail. Modest jitter on the refetch
+ * desynchronises the herd. SCOPE caveat (the SCOPE box in the design trail): a
+ * relocation MUST keep its source-folder precondition recheck — the rebase replay
+ * IS that recheck (the `git mv` fails when the source path is missing on new
+ * `main`), so the genuine-conflict signal is preserved verbatim.
+ *
+ * NEVER `--force`. A push that keeps failing (or a genuine rebase conflict) is
+ * REPORTED via `note` but does NOT crash the tick — the work stays committed in the
+ * clone for the next pass / a human.
+ */
+export interface PushTreelessResultParams {
+    /** The working clone whose `HEAD:main` carries the tree-less commit to publish. */
+    cwd: string;
+    /** Name of the arbiter git remote in `cwd` (the ledger to publish to). */
+    arbiter: string;
+    /**
+     * LIVENESS CEILING for the re-fetch+rebase retry on a non-fast-forward push.
+     * Under C2 (task `c2-rebase-until-real-on-durable-main-promotions`) this is no
+     * longer a small false-contention budget: a CLEAN re-rebase loops without
+     * counting against a tiny cap; a GENUINE conflict (the rebase fails because the
+     * slug's source path is gone on the new `main` — a concurrent legitimate
+     * same-item transition already moved it) STOPS definitively. The ceiling bounds
+     * only the pathological livelock tail; pass a small value (e.g. `0`) in tests
+     * to exercise the un-retried / cap-exhausted path deterministically.
+     */
+    retries: number;
+    /**
+     * Modest jitter (ms) on the refetch between retries — load-bearing under
+     * sustained parallel load to desynchronise a thundering-herd lockstep loop (C2,
+     * task `c2-rebase-until-real-on-durable-main-promotions`). Each non-final
+     * attempt sleeps a uniformly-random integer in `[0, jitterMs]` ms. Defaults to
+     * {@link DEFAULT_TREELESS_JITTER_MS}; pass `0` in tests for deterministic,
+     * latency-free retries.
+     */
+    jitterMs?: number;
+    /** Environment for child git processes. */
+    env: NodeJS.ProcessEnv | undefined;
+    /** Sink for the non-fatal "could not publish" note. */
+    note: (m: string) => void;
+}
+/**
+ * Default modest jitter (ms) on the refetch between {@link pushTreelessResult}
+ * retries — see the `PushTreelessResultParams.jitterMs` doc + the C2 block at the
+ * top of this file. Mirrors `integration-core.ts`'s `DEFAULT_MERGE_JITTER_MS`.
+ */
+export declare const DEFAULT_TREELESS_JITTER_MS = 25;
+/**
+ * Fast-forward-push the working clone's `main` to the arbiter after a tree-less
+ * rung committed locally, so the sidecar / marker LANDS on the arbiter. Re-fetches
+ * + retries a bounded few times if `main` advanced under us (NEVER `--force`); a
+ * push that keeps failing is reported but does not crash the tick (the work is
+ * still saved in the clone for the next pass / a human).
+ */
+export declare function pushTreelessResult(params: PushTreelessResultParams): Promise<void>;
+/**
+ * The rung kinds that commit a tree-less result LOCALLY (sidecar / `needsAnswers`
+ * / `triaged:` marker) and therefore need {@link pushTreelessResult} to reach the
+ * arbiter. The build/task rungs are NOT here — they already push via the
+ * job-worktree `doDriver` → `performIntegration` band. The `advancing` borrow +
+ * the promote-CAS are NOT here either — they CAS straight to the arbiter, so
+ * publishing here would double-publish nothing they own.
+ */
+export declare const TREELESS_RUNGS: ReadonlySet<string>;
+//# sourceMappingURL=advance-treeless-publish.d.ts.map

package/dist/advance-treeless-publish.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"advance-treeless-publish.d.ts","sourceRoot":"","sources":["../src/advance-treeless-publish.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,MAAM,WAAW,wBAAwB;IACxC,mFAAmF;IACnF,GAAG,EAAE,MAAM,CAAC;IACZ,0EAA0E;IAC1E,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;;;;OASG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2CAA2C;IAC3C,GAAG,EAAE,MAAM,CAAC,UAAU,GAAG,SAAS,CAAC;IACnC,uDAAuD;IACvD,IAAI,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CAC1B;AAED;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,KAAK,CAAC;AAM7C;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACvC,MAAM,EAAE,wBAAwB,GAC9B,OAAO,CAAC,IAAI,CAAC,CAuDf;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,EAAE,WAAW,CAAC,MAAM,CAI7C,CAAC"}

package/dist/advance-treeless-publish.js

@@ -0,0 +1,71 @@
+import { runAsync } from './git.js';
+/**
+ * Default modest jitter (ms) on the refetch between {@link pushTreelessResult}
+ * retries — see the `PushTreelessResultParams.jitterMs` doc + the C2 block at the
+ * top of this file. Mirrors `integration-core.ts`'s `DEFAULT_MERGE_JITTER_MS`.
+ */
+export const DEFAULT_TREELESS_JITTER_MS = 25;
+function sleepMs(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Fast-forward-push the working clone's `main` to the arbiter after a tree-less
+ * rung committed locally, so the sidecar / marker LANDS on the arbiter. Re-fetches
+ * + retries a bounded few times if `main` advanced under us (NEVER `--force`); a
+ * push that keeps failing is reported but does not crash the tick (the work is
+ * still saved in the clone for the next pass / a human).
+ */
+export async function pushTreelessResult(params) {
+    const { cwd, arbiter, retries, env, note } = params;
+    const jitterMs = params.jitterMs ?? DEFAULT_TREELESS_JITTER_MS;
+    for (let i = 0; i <= retries; i++) {
+        const push = await runAsync('git', ['push', '--quiet', arbiter, 'HEAD:main'], cwd, { env });
+        if (push.status === 0) {
+            return;
+        }
+        const contended = /non-fast-forward|rejected|fetch first|stale info/i.test(push.stderr);
+        if (!contended || i === retries) {
+            note(`advance: could not publish the tree-less result to ` +
+                `${arbiter}/main (${push.stderr.trim() || 'push failed'}); the work is ` +
+                `saved in the working clone and will re-apply on the next pass.`);
+            return;
+        }
+        // Modest jitter on the refetch (C2, task `c2-rebase-until-real-on-durable-main-
+        // promotions`): an instant lockstep refetch→re-push loop maximises mutual
+        // rejection under sustained parallel load (thundering herd). A uniformly-
+        // random `[0, jitterMs]` ms sleep desynchronises the herd; `jitterMs: 0` opts
+        // out (the test seam).
+        if (jitterMs > 0) {
+            await sleepMs(Math.floor(Math.random() * (jitterMs + 1)));
+        }
+        // `main` advanced under us — re-fetch + rebase our (one) commit onto it, retry.
+        // A CLEAN rebase loops; a GENUINE conflict (the slug's source path is gone on
+        // the new `main` because a concurrent legitimate same-item transition already
+        // moved it — the slug-relocation source-folder precondition recheck) STOPS
+        // definitively below. The natural rebase-conflict IS the C2 terminator (we add
+        // no new conflict-detection path; the SCOPE box requires reusing the existing
+        // recheck).
+        await runAsync('git', ['fetch', '--quiet', arbiter], cwd, { env });
+        const rebase = await runAsync('git', ['rebase', '--quiet', `${arbiter}/main`], cwd, { env });
+        if (rebase.status !== 0) {
+            await runAsync('git', ['rebase', '--abort'], cwd, { env });
+            note(`advance: the tree-less result conflicted with ${arbiter}/main; ` +
+                `the work is saved in the working clone for the next pass / a human.`);
+            return;
+        }
+    }
+}
+/**
+ * The rung kinds that commit a tree-less result LOCALLY (sidecar / `needsAnswers`
+ * / `triaged:` marker) and therefore need {@link pushTreelessResult} to reach the
+ * arbiter. The build/task rungs are NOT here — they already push via the
+ * job-worktree `doDriver` → `performIntegration` band. The `advancing` borrow +
+ * the promote-CAS are NOT here either — they CAS straight to the arbiter, so
+ * publishing here would double-publish nothing they own.
+ */
+export const TREELESS_RUNGS = new Set([
+    'surface',
+    'apply',
+    'triage-observation',
+]);
+//# sourceMappingURL=advance-treeless-publish.js.map

package/dist/advance-treeless-publish.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"advance-treeless-publish.js","sourceRoot":"","sources":["../src/advance-treeless-publish.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,UAAU,CAAC;AAuFlC;;;;GAIG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,EAAE,CAAC;AAE7C,SAAS,OAAO,CAAC,EAAU;IAC1B,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;AAC1D,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACvC,MAAgC;IAEhC,MAAM,EAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,IAAI,EAAC,GAAG,MAAM,CAAC;IAClD,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,0BAA0B,CAAC;IAC/D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,OAAO,EAAE,CAAC,EAAE,EAAE,CAAC;QACnC,MAAM,IAAI,GAAG,MAAM,QAAQ,CAC1B,KAAK,EACL,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,WAAW,CAAC,EACzC,GAAG,EACH,EAAC,GAAG,EAAC,CACL,CAAC;QACF,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACvB,OAAO;QACR,CAAC;QACD,MAAM,SAAS,GAAG,mDAAmD,CAAC,IAAI,CACzE,IAAI,CAAC,MAAM,CACX,CAAC;QACF,IAAI,CAAC,SAAS,IAAI,CAAC,KAAK,OAAO,EAAE,CAAC;YACjC,IAAI,CACH,qDAAqD;gBACpD,GAAG,OAAO,UAAU,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,aAAa,iBAAiB;gBACxE,gEAAgE,CACjE,CAAC;YACF,OAAO;QACR,CAAC;QACD,gFAAgF;QAChF,0EAA0E;QAC1E,0EAA0E;QAC1E,8EAA8E;QAC9E,uBAAuB;QACvB,IAAI,QAAQ,GAAG,CAAC,EAAE,CAAC;YAClB,MAAM,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,QAAQ,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3D,CAAC;QACD,gFAAgF;QAChF,8EAA8E;QAC9E,8EAA8E;QAC9E,2EAA2E;QAC3E,+EAA+E;QAC/E,8EAA8E;QAC9E,YAAY;QACZ,MAAM,QAAQ,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,EAAC,GAAG,EAAC,CAAC,CAAC;QACjE,MAAM,MAAM,GAAG,MAAM,QAAQ,CAC5B,KAAK,EACL,CAAC,QAAQ,EAAE,SAAS,EAAE,GAAG,OAAO,OAAO,CAAC,EACxC,GAAG,EACH,EAAC,GAAG,EAAC,CACL,CAAC;QACF,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACzB,MAAM,QAAQ,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE,SAAS,CAAC,EAAE,GAAG,EAAE,EAAC,GAAG,EAAC,CAAC,CAAC;YACzD,IAAI,CACH,iDAAiD,OAAO,SAAS;gBAChE,qEAAqE,CACtE,CAAC;YACF,OAAO;QACR,CAAC;IACF,CAAC;AACF,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,cAAc,GAAwB,IAAI,GAAG,CAAC;IAC1D,SAAS;IACT,OAAO;IACP,oBAAoB;CACpB,CAAC,CAAC"}